diff --git a/.ghjk/lock.json b/.ghjk/lock.json index 5ed112822..5fa29adf4 100644 --- a/.ghjk/lock.json +++ b/.ghjk/lock.json @@ -384,6 +384,11 @@ }, "portRef": "npmi_npm@0.1.0", "packageName": "@bytecodealliance/jco" + }, + "f4760b34b6c9f9f96207cfb380deb77007a212a60bd10bdb3dc9d20b94c2785c": { + "version": "v8.15.2", + "depConfigs": {}, + "portRef": "pnpm_ghrel@0.1.0" } } }, @@ -746,7 +751,7 @@ } }, { - "version": "v8.8.0", + "version": "v8.15.2", "port": { "ty": "denoWorker@v1", "name": "pnpm_ghrel", diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 6416fcf9f..dc9340a48 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -121,8 +121,9 @@ jobs: strategy: matrix: include: - - os: macos-latest - activate: "source .venv/bin/activate" + # TODO + # - os: macos-latest + # activate: "source .venv/bin/activate" - os: macos-14 activate: "source .venv/bin/activate" #- os: windows-latest @@ -186,8 +187,10 @@ jobs: runner: ubuntu-latest # FIXME: try macos-14 runner once all actions support it # docker buildx action broken as of 2024-02-09 - - platform: linux/arm64 - runner: custom-macos + + # TODO + # - platform: linux/arm64 + # runner: custom-macos steps: - uses: actions/checkout@v4 - uses: docker/setup-buildx-action@v3 diff --git a/Cargo.lock b/Cargo.lock index 9d72ba990..f39a5f5b2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1209,9 +1209,9 @@ dependencies = [ [[package]] name = "clap-verbosity-flag" -version = "2.1.2" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b57f73ca21b17a0352944b9bb61803b6007bd911b6cccfef7153f7f0600ac495" +checksum = "bb9b20c0dd58e4c2e991c8d203bbeb76c11304d1011659686b5b644bc29aa478" dependencies = [ "clap", "log", @@ -1567,9 +1567,9 @@ checksum = "ccaeedb56da03b09f598226e25e80088cb4cd25f316e6e4df7d695f0feeb1403" [[package]] name = "crc32fast" -version = "1.3.2" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" +checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa" dependencies = [ "cfg-if", ] @@ -4553,9 +4553,9 @@ dependencies = [ [[package]] name = "hermit-abi" -version = "0.3.5" +version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0c62115964e08cb8039170eb33c1d0e2388a256930279edca206fff675f82c3" +checksum = "bd5256b483761cd23699d0da46cc6fd2ee3be420bbe6d020ae4a091e70b7e9fd" [[package]] name = "hex" @@ -5068,7 +5068,7 @@ version = "1.0.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2" dependencies = [ - "hermit-abi 0.3.5", + "hermit-abi 0.3.6", "libc", "windows-sys 0.48.0", ] @@ -5109,7 +5109,7 @@ version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b" dependencies = [ - "hermit-abi 0.3.5", + "hermit-abi 0.3.6", "libc", "windows-sys 0.52.0", ] @@ -6108,7 +6108,7 @@ checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a" [[package]] name = "mysql_async" version = "0.31.3" -source = "git+https://github.com/prisma/mysql_async?branch=vendored-openssl#d8ffc297874bf4b12ce8387c4a01836b52fd3216" +source = "git+https://github.com/prisma/mysql_async?branch=vendored-openssl#0d40d0d2c332fc97512bff81e82e62002f03c224" dependencies = [ "bytes", "crossbeam", @@ -6117,6 +6117,7 @@ dependencies = [ "futures-sink", "futures-util", "lazy_static 1.4.0", + "lexical", "lru 0.8.1", "mio", "mysql_common", @@ -6126,6 +6127,7 @@ dependencies = [ "percent-encoding", "pin-project", "priority-queue", + "regex", "serde 1.0.196", "serde_json", "socket2 0.4.10", @@ -6525,7 +6527,7 @@ version = "1.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" dependencies = [ - "hermit-abi 0.3.5", + "hermit-abi 0.3.6", "libc", ] @@ -6627,9 +6629,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" [[package]] name = "openssl-src" -version = "300.2.2+3.2.1" +version = "300.2.3+3.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8bbfad0063610ac26ee79f7484739e2b07555a75c42453b89263830b5c8103bc" +checksum = "5cff92b6f71555b61bb9315f7c64da3ca43d87531622120fea0195fc761b4843" dependencies = [ "cc", ] @@ -7170,9 +7172,9 @@ dependencies = [ [[package]] name = "pkg-config" -version = "0.3.29" +version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2900ede94e305130c13ddd391e0ab7cbaeb783945ae07a279c268cb05109c6cb" +checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" [[package]] name = "platforms" @@ -10551,7 +10553,7 @@ dependencies = [ "serde 1.0.196", "serde_spanned", "toml_datetime", - "toml_edit 0.22.4", + "toml_edit 0.22.5", ] [[package]] @@ -10571,20 +10573,20 @@ checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1" dependencies = [ "indexmap 2.2.3", "toml_datetime", - "winnow", + "winnow 0.5.40", ] [[package]] name = "toml_edit" -version = "0.22.4" +version = "0.22.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c9ffdf896f8daaabf9b66ba8e77ea1ed5ed0f72821b398aba62352e95062951" +checksum = "99e68c159e8f5ba8a28c4eb7b0c0c190d77bb479047ca713270048145a9ad28a" dependencies = [ "indexmap 2.2.3", "serde 1.0.196", "serde_spanned", "toml_datetime", - "winnow", + "winnow 0.6.1", ] [[package]] @@ -11658,18 +11660,18 @@ dependencies = [ [[package]] name = "wasm-encoder" -version = "0.41.1" +version = "0.41.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ce14de623d48dda4c10698c4dadae2366b5c2c8e81bad981d5a0625a5fcf68c" +checksum = "972f97a5d8318f908dded23594188a90bcd09365986b1163e66d70170e5287ae" dependencies = [ "leb128", ] [[package]] name = "wasm-metadata" -version = "0.10.18" +version = "0.10.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "977038054fd97977d2b7889005b5f20b62fd3563f2dc8dedfb534e3fdea6b7a7" +checksum = "18ebaa7bd0f9e7a5e5dd29b9a998acf21c4abed74265524dd7e85934597bfb10" dependencies = [ "anyhow", "indexmap 2.2.3", @@ -11677,8 +11679,8 @@ dependencies = [ "serde_derive", "serde_json", "spdx", - "wasm-encoder 0.41.1", - "wasmparser 0.121.1", + "wasm-encoder 0.41.2", + "wasmparser 0.121.2", ] [[package]] @@ -11770,9 +11772,9 @@ dependencies = [ [[package]] name = "wasmparser" -version = "0.121.1" +version = "0.121.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99ffe16b4aa1ebab8724f61c9ee38cd5481c89caf10bf1a5af9eab8f0c2e6c05" +checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab" dependencies = [ "bitflags 2.4.2", "indexmap 2.2.3", @@ -11781,22 +11783,22 @@ dependencies = [ [[package]] name = "wast" -version = "71.0.0" +version = "71.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a10dad39ea4623ed4c304fb42bd455eca6d212f7e5e0cb59681fed7e4d128a2e" +checksum = "647c3ac4354da32688537e8fc4d2fe6c578df51896298cb64727d98088a1fd26" dependencies = [ "bumpalo", "leb128", "memchr", "unicode-width", - "wasm-encoder 0.41.1", + "wasm-encoder 0.41.2", ] [[package]] name = "wat" -version = "1.0.86" +version = "1.0.88" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b724419d3bffeff174745b924f6ed053095ac58f9ae72e87d2e0f8ef6df6df96" +checksum = "b69c36f634411568a2c6d24828b674961e37ea03340fe1d605c337ed8162d901" dependencies = [ "wast", ] @@ -12152,9 +12154,18 @@ checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04" [[package]] name = "winnow" -version = "0.5.39" +version = "0.5.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876" +dependencies = [ + "memchr", +] + +[[package]] +name = "winnow" +version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5389a154b01683d28c77f8f68f49dea75f0a4da32557a58f68ee51ebba472d29" +checksum = "d90f4e0f530c4c69f62b80d839e9ef3855edc9cba471a160c4d692deed62b401" dependencies = [ "memchr", ] diff --git a/dev/lock.yml b/dev/lock.yml index fda048d89..e9001083a 100644 --- a/dev/lock.yml +++ b/dev/lock.yml @@ -82,7 +82,7 @@ dev: RUST_VERSION: 1.75.0 DENO_VERSION: 1.40.1 NODE_VERSION: 20.8.0 - PNPM_VERSION: v8.8.0 + PNPM_VERSION: v8.15.2 CARGO_INSTA_VERSION: 1.33.0 WASM_TOOLS_VERSION: 1.0.53 JCO_VERSION: 1.0.0 diff --git a/examples/typegraphs/authentication.py b/examples/typegraphs/authentication.py index 53157fa16..eb0de0bf4 100644 --- a/examples/typegraphs/authentication.py +++ b/examples/typegraphs/authentication.py @@ -16,7 +16,7 @@ def authentication(g: Graph): deno = DenoRuntime() public = Policy.public() - ctx = t.struct({"username": t.string().optional().from_context("username")}) + ctx = t.struct({"username": t.string().optional()}) # highlight-start # expects a secret in metatype.yml @@ -26,6 +26,10 @@ def authentication(g: Graph): # highlight-end g.expose( - get_context=deno.identity(ctx), + get_context=deno.identity(ctx).apply( + { + "username": g.from_context("username"), + } + ), default_policy=[public], ) diff --git a/examples/typegraphs/authentication.ts b/examples/typegraphs/authentication.ts index 80bbaf820..a41a11332 100644 --- a/examples/typegraphs/authentication.ts +++ b/examples/typegraphs/authentication.ts @@ -14,7 +14,7 @@ typegraph({ const pub = Policy.public(); const ctx = t.struct({ - "username": t.string().optional().fromContext("username"), + "username": t.string().optional(), }); // highlight-start @@ -25,6 +25,8 @@ typegraph({ // highlight-end g.expose({ - get_context: deno.identity(ctx).withPolicy(pub), + get_context: deno.identity(ctx).apply({ + username: g.fromContext("username"), + }).withPolicy(pub), }); }); diff --git a/examples/typegraphs/basic.py b/examples/typegraphs/basic.py index 81232acac..ee4cd8bc7 100644 --- a/examples/typegraphs/basic.py +++ b/examples/typegraphs/basic.py @@ -14,12 +14,16 @@ def basic_authentication(g: Graph): deno = DenoRuntime() public = Policy.public() - ctx = t.struct({"username": t.string().optional().from_context("username")}) + ctx = t.struct({"username": t.string().optional()}) # highlight-next-line g.auth(Auth.basic(["admin"])) g.expose( public, - get_context=deno.identity(ctx), + get_context=deno.identity(ctx).apply( + { + "username": g.from_context("username"), + } + ), ) diff --git a/examples/typegraphs/basic.ts b/examples/typegraphs/basic.ts index 36c79b6a6..54c27266c 100644 --- a/examples/typegraphs/basic.ts +++ b/examples/typegraphs/basic.ts @@ -14,13 +14,15 @@ typegraph({ const pub = Policy.public(); const ctx = t.struct({ - "username": t.string().optional().fromContext("username"), + "username": t.string().optional(), }); // highlight-next-line g.auth(Auth.basic(["admin"])); g.expose({ - get_context: deno.identity(ctx).withPolicy(pub), + get_context: deno.identity(ctx).apply({ + username: g.fromContext("username"), + }).withPolicy(pub), }); }); diff --git a/examples/typegraphs/execute.py b/examples/typegraphs/execute.py index d063f5380..ed46b9971 100644 --- a/examples/typegraphs/execute.py +++ b/examples/typegraphs/execute.py @@ -84,7 +84,9 @@ def roadmap(g: Graph): ), EffectUpdate(True), ), - get_context=deno.identity( - t.struct({"username": t.string().optional().from_context("username")}) + get_context=deno.identity(t.struct({"username": t.string().optional()})).apply( + { + "username": g.from_context("username"), + } ), ) diff --git a/examples/typegraphs/execute.ts b/examples/typegraphs/execute.ts index 86258351b..dd5425d47 100644 --- a/examples/typegraphs/execute.ts +++ b/examples/typegraphs/execute.ts @@ -81,7 +81,9 @@ typegraph({ effects.update(), ), get_context: deno.identity( - t.struct({ "username": t.string().optional().fromContext("username") }), - ), + t.struct({ "username": t.string().optional() }), + ).apply({ + "username": g.fromContext("username"), + }), }, pub); }); diff --git a/examples/typegraphs/jwt.py b/examples/typegraphs/jwt.py index 9759e8777..d56632fec 100644 --- a/examples/typegraphs/jwt.py +++ b/examples/typegraphs/jwt.py @@ -14,13 +14,15 @@ def jwt_authentication(g: Graph): deno = DenoRuntime() public = Policy.public() - ctx = t.struct( - {"your_own_content": t.string().optional().from_context("your_own_content")} - ) + ctx = t.struct({"your_own_content": t.string().optional()}) # highlight-next-line g.auth(Auth.hmac256("custom")) g.expose( - get_context=deno.identity(ctx), + get_context=deno.identity(ctx).apply( + { + "your_own_content": g.from_context("your_own_content"), + } + ), default_policy=[public], ) diff --git a/examples/typegraphs/jwt.ts b/examples/typegraphs/jwt.ts index 33e0f7458..2b0be121e 100644 --- a/examples/typegraphs/jwt.ts +++ b/examples/typegraphs/jwt.ts @@ -13,15 +13,15 @@ typegraph({ const deno = new DenoRuntime(); const pub = Policy.public(); - const ctx = t.struct( - { - "your_own_content": t.string().optional().fromContext("your_own_content"), - }, - ); + const ctx = t.struct({ + "your_own_content": t.string().optional(), + }); // highlight-next-line g.auth(Auth.hmac256("custom")); g.expose({ - get_context: deno.identity(ctx), + get_context: deno.identity(ctx).apply({ + your_own_content: g.fromContext("your_own_content"), + }), }, pub); }); diff --git a/examples/typegraphs/oauth2.py b/examples/typegraphs/oauth2.py index 8f744031f..2ee552c3f 100644 --- a/examples/typegraphs/oauth2.py +++ b/examples/typegraphs/oauth2.py @@ -14,7 +14,7 @@ def oauth2_authentication(g: Graph): deno = DenoRuntime() public = Policy.public() - ctx = t.struct({"exp": t.integer().optional().from_context("exp")}) + ctx = t.struct({"exp": t.integer().optional()}) # highlight-start g.auth(Auth.oauth2_github("openid profile email")) @@ -22,5 +22,9 @@ def oauth2_authentication(g: Graph): g.expose( public, - get_context=deno.identity(ctx), + get_context=deno.identity(ctx).apply( + { + "exp": g.from_context("exp"), + } + ), ) diff --git a/examples/typegraphs/oauth2.ts b/examples/typegraphs/oauth2.ts index d3de8b84b..cf98a9a72 100644 --- a/examples/typegraphs/oauth2.ts +++ b/examples/typegraphs/oauth2.ts @@ -13,7 +13,7 @@ typegraph({ const deno = new DenoRuntime(); const pub = Policy.public(); - const ctx = t.struct({ "exp": t.integer().optional().fromContext("exp") }); + const ctx = t.struct({ "exp": t.integer().optional() }); // highlight-start g.auth( @@ -22,6 +22,8 @@ typegraph({ // highlight-end g.expose({ - get_context: deno.identity(ctx), + get_context: deno.identity(ctx).apply({ + exp: g.fromContext("exp"), + }), }, pub); }); diff --git a/ghjk.ts b/ghjk.ts index 39ca640b8..a63417ce0 100644 --- a/ghjk.ts +++ b/ghjk.ts @@ -5,7 +5,7 @@ import * as ports from "https://raw.github.com/metatypedev/ghjk/f380522/ports/mo const PROTOC_VERSION = "v24.1"; const POETRY_VERSION = "1.7.0"; const PYTHON_VERSION = "3.8.18"; -const PNPM_VERSION = "v8.8.0"; +const PNPM_VERSION = "v8.15.2"; const WASM_TOOLS_VERSION = "1.0.53"; const JCO_VERSION = "1.0.0"; const WASMEDGE_VERSION = "0.13.5"; diff --git a/libs/common/src/typegraph/mod.rs b/libs/common/src/typegraph/mod.rs index 140b73ee2..29925a236 100644 --- a/libs/common/src/typegraph/mod.rs +++ b/libs/common/src/typegraph/mod.rs @@ -1,6 +1,7 @@ // Copyright Metatype OÜ, licensed under the Elastic License 2.0. // SPDX-License-Identifier: Elastic-2.0 +pub mod parameter_transform; pub mod runtimes; pub mod types; pub mod utils; diff --git a/libs/common/src/typegraph/parameter_transform.rs b/libs/common/src/typegraph/parameter_transform.rs new file mode 100644 index 000000000..343f3560c --- /dev/null +++ b/libs/common/src/typegraph/parameter_transform.rs @@ -0,0 +1,60 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +use std::collections::HashMap; + +#[cfg(feature = "codegen")] +use schemars::JsonSchema; +use serde::{Deserialize, Serialize}; + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +#[serde(tag = "source", rename_all = "lowercase")] +pub enum ParameterTransformLeafNode { + #[serde(rename_all = "camelCase")] + Arg { name: String }, + #[serde(rename_all = "camelCase")] + Static { value_json: String }, + #[serde(rename_all = "camelCase")] + Secret { key: String }, + #[serde(rename_all = "camelCase")] + Context { key: String }, + #[serde(rename_all = "camelCase")] + Parent { parent_idx: u32 }, +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +#[serde(tag = "type", rename_all = "lowercase")] +pub enum ParameterTransformParentNode { + #[serde(rename_all = "camelCase")] + Object { + fields: HashMap, + }, + #[serde(rename_all = "camelCase")] + Array { items: Vec }, +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +#[serde(untagged)] +pub enum ParameterTransformNodeData { + Leaf(ParameterTransformLeafNode), + Parent(ParameterTransformParentNode), +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +#[serde(rename_all = "camelCase")] +pub struct ParameterTransformNode { + pub type_idx: u32, + // #[serde(flatten)] + pub data: ParameterTransformNodeData, +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct FunctionParameterTransform { + pub resolver_input: u32, + pub transform_root: ParameterTransformNode, +} diff --git a/libs/common/src/typegraph/types.rs b/libs/common/src/typegraph/types.rs index 7965df4a1..575df5867 100644 --- a/libs/common/src/typegraph/types.rs +++ b/libs/common/src/typegraph/types.rs @@ -9,7 +9,7 @@ use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use serde_with::skip_serializing_none; -use super::{EffectType, PolicyIndices}; +use super::{parameter_transform::FunctionParameterTransform, EffectType, PolicyIndices}; #[cfg_attr(feature = "codegen", derive(JsonSchema))] #[derive(Serialize, Deserialize, Clone, Debug)] @@ -105,7 +105,7 @@ pub struct IntegerTypeData { } #[cfg_attr(feature = "codegen", derive(JsonSchema))] -#[derive(Serialize, Deserialize, Clone, Debug)] +#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)] #[serde(rename_all = "kebab-case")] pub enum StringFormat { Uuid, @@ -166,6 +166,8 @@ pub struct ListTypeData { #[derive(Serialize, Deserialize, Clone, Debug)] pub struct FunctionTypeData { pub input: u32, + #[serde(rename = "parameterTransform")] + pub parameter_transform: Option, pub output: u32, pub materializer: u32, #[serialize_always] diff --git a/libs/common/src/typegraph/validator/common.rs b/libs/common/src/typegraph/validator/common.rs new file mode 100644 index 000000000..565dbe18f --- /dev/null +++ b/libs/common/src/typegraph/validator/common.rs @@ -0,0 +1,93 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +use crate::typegraph::{EitherTypeData, TypeNode, Typegraph, UnionTypeData}; + +impl Typegraph { + pub fn check_enum_values( + &self, + type_idx: u32, + enum_values: &[String], + ) -> Result<(), Vec> { + let type_node = self.types.get(type_idx as usize).unwrap(); + let mut errors = Vec::new(); + if matches!(type_node, TypeNode::Optional { .. }) { + errors.push("optional not cannot have enumerated values".to_owned()); + } else { + for value in enum_values { + match serde_json::from_str::(value) { + Ok(val) => match self.validate_value(type_idx, &val) { + Ok(_) => {} + Err(err) => errors.push(err.to_string()), + }, + Err(e) => errors.push(format!( + "Error while deserializing enum value {value:?}: {e:?}" + )), + } + } + } + + if errors.is_empty() { + Ok(()) + } else { + Err(errors) + } + } + + pub fn collect_nested_variants_into(&self, out: &mut Vec, variants: &[u32]) { + for idx in variants { + let node = self.types.get(*idx as usize).unwrap(); + match node { + TypeNode::Union { + data: UnionTypeData { any_of: variants }, + .. + } + | TypeNode::Either { + data: EitherTypeData { one_of: variants }, + .. + } => self.collect_nested_variants_into(out, variants), + _ => out.push(*idx), + } + } + } + + pub fn check_union_variants(&self, variants: &[u32]) -> Result<(), String> { + let mut object_count = 0; + + for variant_type in variants + .iter() + .map(|idx| self.types.get(*idx as usize).unwrap()) + { + match variant_type { + TypeNode::Object { .. } => object_count += 1, + TypeNode::Boolean { .. } + | TypeNode::Float { .. } + | TypeNode::Integer { .. } + | TypeNode::String { .. } => { + // scalar + } + TypeNode::List { data, .. } => { + let item_type = self.types.get(data.items as usize).unwrap(); + if !item_type.is_scalar() { + return Err(format!( + "array of '{}' not allowed as union/either variant", + item_type.type_name() + )); + } + } + _ => { + return Err(format!( + "type '{}' not allowed as union/either variant", + variant_type.type_name() + )); + } + } + } + + if object_count != 0 && object_count != variants.len() { + return Err("union variants must either be all scalars or all objects".to_owned()); + } + + Ok(()) + } +} diff --git a/libs/common/src/typegraph/validator/input.rs b/libs/common/src/typegraph/validator/input.rs new file mode 100644 index 000000000..e7e03894a --- /dev/null +++ b/libs/common/src/typegraph/validator/input.rs @@ -0,0 +1,109 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +use serde_json::Value; + +use crate::typegraph::{ + visitor::{CurrentNode, TypeVisitor, VisitResult}, + Injection, TypeNode, +}; + +use super::{ + types::{EnsureSubtypeOf, ErrorCollector, ExtendedTypeNode}, + TypeVisitorContext, Validator, ValidatorContext, +}; + +impl Validator { + pub fn visit_input_type_impl( + &mut self, + current_node: CurrentNode<'_>, + context: &::Context, + ) -> VisitResult<::Return> { + let type_node = current_node.type_node; + + if let TypeNode::Function { .. } = type_node { + // TODO suggest to use composition-- when available + self.push_error(current_node.path, "Function is not allowed in input types."); + return VisitResult::Continue(false); + } + + if let Some(injection) = &type_node.base().injection { + self.validate_injection(injection, current_node, context); + } + + if let Some(enumeration) = &type_node.base().enumeration { + match context + .get_typegraph() + .check_enum_values(current_node.type_idx, enumeration) + { + Ok(_) => {} + Err(err) => { + for e in err { + self.push_error(current_node.path, e); + } + } + } + } + + VisitResult::Continue(true) + } +} + +impl Validator { + fn validate_injection( + &mut self, + injection: &Injection, + current_node: CurrentNode<'_>, + context: &ValidatorContext<'_>, + ) { + let typegraph = context.get_typegraph(); + + match injection { + Injection::Static(data) => { + for value in data.values().iter() { + match serde_json::from_str::(value) { + Ok(val) => match typegraph.validate_value(current_node.type_idx, &val) { + Ok(_) => {} + Err(err) => self.push_error(current_node.path, err.to_string()), + }, + Err(e) => { + self.push_error( + current_node.path, + format!( + "Error while parsing static injection value {value:?}: {e:?}", + value = value + ), + ); + } + } + } + } + Injection::Parent(data) => { + let sources = data.values(); + for source_idx in sources.iter().copied() { + self.validate_parent_injection(*source_idx, ¤t_node, context); + } + } + _ => (), + } + } + + fn validate_parent_injection( + &mut self, + source_idx: u32, + current_node: &CurrentNode<'_>, + context: &ValidatorContext<'_>, + ) { + let typegraph = context.get_typegraph(); + let source = ExtendedTypeNode::new(typegraph, source_idx); + let target = ExtendedTypeNode::new(typegraph, current_node.type_idx); + let mut errors = ErrorCollector::default(); + source.ensure_subtype_of(&target, typegraph, &mut errors); + for error in errors.errors.into_iter() { + self.push_error( + current_node.path, + format!("from_parent injection: {error}", error = error), + ); + } + } +} diff --git a/libs/common/src/typegraph/validator/mod.rs b/libs/common/src/typegraph/validator/mod.rs new file mode 100644 index 000000000..82d2ae72e --- /dev/null +++ b/libs/common/src/typegraph/validator/mod.rs @@ -0,0 +1,134 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +mod common; +mod input; +mod types; +mod value; + +use crate::typegraph::{TypeNode, Typegraph}; + +use super::visitor::{ + CurrentNode, Edge, Path, PathSegment, TypeVisitor, TypeVisitorContext, VisitResult, + VisitorResult, +}; + +pub fn validate_typegraph(tg: &Typegraph) -> Vec { + let context = ValidatorContext { typegraph: tg }; + let validator = Validator::default(); + tg.traverse_types(validator, &context).unwrap() +} + +#[derive(Debug)] +pub struct ValidatorError { + pub path: String, + pub message: String, +} + +#[derive(Debug, Clone)] +pub struct ValidatorContext<'a> { + typegraph: &'a Typegraph, +} + +#[derive(Debug, Default)] +struct Validator { + errors: Vec, +} + +impl Validator { + fn push_error(&mut self, path: &[PathSegment], message: impl Into) { + self.errors.push(ValidatorError { + path: Path(path).to_string(), + message: message.into(), + }); + } +} + +impl VisitorResult for Vec { + fn from_error(path: String, message: String) -> Self { + vec![ValidatorError { path, message }] + } +} + +impl<'a> TypeVisitorContext for ValidatorContext<'a> { + fn get_typegraph(&self) -> &Typegraph { + self.typegraph + } +} + +impl<'a> TypeVisitor<'a> for Validator { + type Return = Vec; + type Context = ValidatorContext<'a>; + + fn visit( + &mut self, + current_node: CurrentNode<'_>, + context: &Self::Context, + ) -> VisitResult { + let typegraph = context.get_typegraph(); + let type_node = current_node.type_node; + + let last_seg = current_node.path.last(); + if let Some(last_seg) = last_seg { + if let Edge::FunctionInput = last_seg.edge { + self.visit_input_type(current_node, context); + return VisitResult::Continue(false); + } + } + + match type_node { + TypeNode::Union { .. } | TypeNode::Either { .. } => { + let mut variants = vec![]; + typegraph.collect_nested_variants_into(&mut variants, &[current_node.type_idx]); + match typegraph.check_union_variants(&variants) { + Ok(_) => {} + Err(err) => { + self.push_error(current_node.path, err); + return VisitResult::Continue(false); + } + } + } + TypeNode::Function { .. } => { + // validate materializer?? + // TODO deno static + } + _ => {} + } + + if let Some(enumeration) = &type_node.base().enumeration { + match context + .get_typegraph() + .check_enum_values(current_node.type_idx, enumeration) + { + Ok(_) => {} + Err(err) => { + for e in err { + self.push_error(current_node.path, e); + } + } + } + } + + if type_node.base().injection.is_some() { + self.push_error( + current_node.path, + "Injection is not allowed in output types".to_owned(), + ); + return VisitResult::Continue(false); + } + + VisitResult::Continue(true) + } + + fn visit_input_type( + &mut self, + current_node: CurrentNode<'_>, + context: &Self::Context, + ) -> VisitResult { + self.visit_input_type_impl(current_node, context) + } + + fn take_result(&mut self) -> Option { + Some(std::mem::take(&mut self.errors)) + } +} diff --git a/libs/common/src/typegraph/validator/types.rs b/libs/common/src/typegraph/validator/types.rs new file mode 100644 index 000000000..a6e5b818f --- /dev/null +++ b/libs/common/src/typegraph/validator/types.rs @@ -0,0 +1,354 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +use crate::typegraph::{ + EitherTypeData, FileTypeData, FloatTypeData, IntegerTypeData, ListTypeData, ObjectTypeData, + StringTypeData, TypeNode, Typegraph, UnionTypeData, +}; +use std::{collections::HashSet, fmt::Display}; + +pub struct ExtendedTypeNode<'a>(u32, &'a TypeNode); + +impl<'a> ExtendedTypeNode<'a> { + pub fn new(typegraph: &'a Typegraph, idx: u32) -> Self { + ExtendedTypeNode(idx, typegraph.types.get(idx as usize).unwrap()) + } +} + +#[derive(Debug, Default)] +pub struct ErrorCollector { + pub errors: Vec, +} + +impl ErrorCollector { + fn push(&mut self, message: impl Into) { + self.errors.push(message.into()); + } +} + +pub trait EnsureSubtypeOf { + fn ensure_subtype_of(&self, sup: &Self, typegraph: &Typegraph, errors: &mut ErrorCollector); +} + +fn ensure_subtype_of_for_min( + sub_min: Option, + sup_min: Option, + key: &str, + errors: &mut ErrorCollector, +) where + T: Display + PartialOrd, +{ + if let Some(sub_min) = sub_min { + if let Some(sup_min) = sup_min { + if sub_min < sup_min { + errors.push(format!("{key} is less than the {key} of the supertype")); + } + } + } else if sup_min.is_some() { + errors.push(format!("{key} is not defined in the subtype")); + } +} + +fn ensure_subtype_of_for_max( + sub_max: Option, + sup_max: Option, + key: &str, + errors: &mut ErrorCollector, +) where + T: Display + PartialOrd, +{ + if let Some(sub_max) = sub_max { + if let Some(sup_max) = sup_max { + if sub_max > sup_max { + errors.push(format!("{key} is greater than the {key} of the supertype")); + } + } + } else if sup_max.is_some() { + errors.push(format!("{key} is not defined in the subtype")); + } +} + +fn ensure_subtype_of_for_multiple_of( + sub_multiple_of: Option, + sup_multiple_of: Option, + key: &str, + errors: &mut ErrorCollector, +) where + T: Display + std::ops::Rem + Copy + Default + PartialEq, +{ + if let Some(sub_multiple_of) = sub_multiple_of { + if let Some(sup_multiple_of) = sup_multiple_of { + if sub_multiple_of % sup_multiple_of != Default::default() { + errors.push(format!( + "{key} is not a multiple of the {key} of the supertype" + )); + } + } + } else if sup_multiple_of.is_some() { + errors.push(format!("{key} is not defined in the subtype")); + } +} + +impl EnsureSubtypeOf for IntegerTypeData { + fn ensure_subtype_of(&self, sup: &Self, _tg: &Typegraph, errors: &mut ErrorCollector) { + ensure_subtype_of_for_min(self.minimum, sup.minimum, "minimum", errors); + ensure_subtype_of_for_max(self.maximum, sup.maximum, "maximum", errors); + ensure_subtype_of_for_min( + self.exclusive_minimum, + sup.exclusive_minimum, + "exclusive_minimum", + errors, + ); + ensure_subtype_of_for_max( + self.exclusive_maximum, + sup.exclusive_maximum, + "exclusive_maximum", + errors, + ); + ensure_subtype_of_for_multiple_of(self.multiple_of, sup.multiple_of, "multiple_of", errors); + } +} + +impl EnsureSubtypeOf for FloatTypeData { + fn ensure_subtype_of(&self, sup: &Self, _tg: &Typegraph, errors: &mut ErrorCollector) { + ensure_subtype_of_for_min(self.minimum, sup.minimum, "minimum", errors); + ensure_subtype_of_for_max(self.maximum, sup.maximum, "maximum", errors); + ensure_subtype_of_for_min( + self.exclusive_minimum, + sup.exclusive_minimum, + "exclusive_minimum", + errors, + ); + ensure_subtype_of_for_max( + self.exclusive_maximum, + sup.exclusive_maximum, + "exclusive_maximum", + errors, + ); + ensure_subtype_of_for_multiple_of(self.multiple_of, sup.multiple_of, "multiple_of", errors); + } +} + +impl EnsureSubtypeOf for StringTypeData { + fn ensure_subtype_of(&self, sup: &Self, _tg: &Typegraph, errors: &mut ErrorCollector) { + ensure_subtype_of_for_min(self.min_length, sup.min_length, "minimum_length", errors); + ensure_subtype_of_for_max(self.max_length, sup.max_length, "maximum_length", errors); + + if let Some(sub_pattern) = &self.pattern { + if let Some(sup_pattern) = &sup.pattern { + if sub_pattern != sup_pattern { + errors.push("pattern does not match the pattern of the supertype"); + } + } + } else if sup.pattern.is_some() { + errors.push("pattern is not defined in the subtype"); + } + + if let Some(sub_format) = &self.format { + if let Some(sup_format) = &sup.format { + if sub_format != sup_format { + errors.push("format does not match the format of the supertype"); + } + } + } else if sup.format.is_some() { + errors.push("format is not defined in the subtype"); + } + } +} + +impl EnsureSubtypeOf for FileTypeData { + fn ensure_subtype_of(&self, sup: &Self, _tg: &Typegraph, errors: &mut ErrorCollector) { + ensure_subtype_of_for_min(self.min_size, sup.min_size, "minimum_size", errors); + ensure_subtype_of_for_max(self.max_size, sup.max_size, "maximum_size", errors); + + if let Some(sub_mime_types) = &self.mime_types { + if let Some(sup_mime_types) = &sup.mime_types { + // check if sub_mime_types is a subset of sup_mime_types + if sub_mime_types + .iter() + .any(|sub| !sup_mime_types.contains(sub)) + { + errors.push("mime_types is not a subset of the mime_types of the supertype"); + } + } + } else if sup.mime_types.is_some() { + errors.push("mime_types is not defined in the subtype"); + } + } +} + +impl EnsureSubtypeOf for ObjectTypeData { + fn ensure_subtype_of(&self, sup: &Self, tg: &Typegraph, errors: &mut ErrorCollector) { + let mut sup_props_left = sup.properties.keys().collect::>(); + + for (key, sub_idx) in &self.properties { + if let Some(sup_idx) = sup.properties.get(key) { + ExtendedTypeNode::new(tg, *sub_idx).ensure_subtype_of( + &ExtendedTypeNode::new(tg, *sup_idx), + tg, + errors, + ); + } else { + errors.push(format!("property {} is not defined in the supertype", key)); + } + sup_props_left.remove(key); + } + + for key in sup_props_left { + let type_idx = sup.properties.get(key).unwrap(); + let type_node = tg.types.get(*type_idx as usize).unwrap(); + if !matches!(type_node, TypeNode::Optional { .. }) { + errors.push(format!("property {} is not optional in the supertype", key)); + } + } + + for key in &self.required { + if !sup.required.contains(key) { + errors.push(format!("property {} is not required in the supertype", key)); + } + } + } +} + +impl EnsureSubtypeOf for ListTypeData { + fn ensure_subtype_of(&self, sup: &Self, typegraph: &Typegraph, errors: &mut ErrorCollector) { + ensure_subtype_of_for_min(self.min_items, sup.min_items, "minimum_items", errors); + ensure_subtype_of_for_max(self.max_items, sup.max_items, "maximum_items", errors); + if self.unique_items.unwrap_or(false) && !sup.unique_items.unwrap_or(false) { + errors.push("unique_items is not defined in the subtype"); + } + ExtendedTypeNode::new(typegraph, self.items).ensure_subtype_of( + &ExtendedTypeNode::new(typegraph, sup.items), + typegraph, + errors, + ); + } +} + +impl EnsureSubtypeOf for UnionTypeData { + fn ensure_subtype_of(&self, sup: &Self, typegraph: &Typegraph, errors: &mut ErrorCollector) { + GenericUnionVariants(&self.any_of).ensure_subtype_of( + &GenericUnionVariants(&sup.any_of), + typegraph, + errors, + ); + } +} + +impl EnsureSubtypeOf for EitherTypeData { + fn ensure_subtype_of(&self, sup: &Self, typegraph: &Typegraph, errors: &mut ErrorCollector) { + GenericUnionVariants(&self.one_of).ensure_subtype_of( + &GenericUnionVariants(&sup.one_of), + typegraph, + errors, + ); + } +} + +struct GenericUnionVariants<'a>(&'a [u32]); +impl<'a> EnsureSubtypeOf for GenericUnionVariants<'a> { + fn ensure_subtype_of(&self, sup: &Self, typegraph: &Typegraph, errors: &mut ErrorCollector) { + // any variant is a subtype of a variant in the supertype + for sub_idx in self.0 { + let sub_type = ExtendedTypeNode::new(typegraph, *sub_idx); + let mut found = false; + for sup_idx in sup.0 { + let sup_type = ExtendedTypeNode::new(typegraph, *sup_idx); + + let mut error_collector = ErrorCollector::default(); + sub_type.ensure_subtype_of(&sup_type, typegraph, &mut error_collector); + if error_collector.errors.is_empty() { + found = true; + break; + } + } + if !found { + errors.push("Union type does not match the supertype"); + } + } + } +} + +impl<'a> EnsureSubtypeOf for ExtendedTypeNode<'a> { + fn ensure_subtype_of(&self, sup: &Self, tg: &Typegraph, errors: &mut ErrorCollector) { + let sub_idx = self.0; + let sup_idx = sup.0; + if sub_idx != sup_idx { + // self.1.ensure_subtype_of(sup.1, typegraph, errors); + match (self.1, sup.1) { + (TypeNode::Optional { data: sub, .. }, TypeNode::Optional { data: sup, .. }) => { + ExtendedTypeNode::new(tg, sub.item).ensure_subtype_of( + &ExtendedTypeNode::new(tg, sup.item), + tg, + errors, + ); + } + (_, TypeNode::Optional { data: sup, .. }) => { + self.ensure_subtype_of(&ExtendedTypeNode::new(tg, sup.item), tg, errors); + } + (TypeNode::Boolean { .. }, TypeNode::Boolean { .. }) => { /* nothing to check */ } + (TypeNode::Integer { data: sub, .. }, TypeNode::Integer { data: sup, .. }) => { + sub.ensure_subtype_of(sup, tg, errors) + } + (TypeNode::Float { data: sub, .. }, TypeNode::Float { data: sup, .. }) => { + sub.ensure_subtype_of(sup, tg, errors) + } + (TypeNode::String { data: sub, .. }, TypeNode::String { data: sup, .. }) => { + sub.ensure_subtype_of(sup, tg, errors) + } + (TypeNode::File { data: sub, .. }, TypeNode::File { data: sup, .. }) => { + sub.ensure_subtype_of(sup, tg, errors) + } + (TypeNode::Object { data: sub, .. }, TypeNode::Object { data: sup, .. }) => { + sub.ensure_subtype_of(sup, tg, errors) + } + (TypeNode::List { data: sub, .. }, TypeNode::List { data: sup, .. }) => { + sub.ensure_subtype_of(sup, tg, errors) + } + (TypeNode::Union { data: sub, .. }, TypeNode::Union { data: sup, .. }) => { + sub.ensure_subtype_of(sup, tg, errors) + } + (TypeNode::Either { data: sub, .. }, TypeNode::Union { data: sup, .. }) => { + GenericUnionVariants(&sub.one_of).ensure_subtype_of( + &GenericUnionVariants(&sup.any_of), + tg, + errors, + ) + } + (TypeNode::Union { data: sub, .. }, TypeNode::Either { data: sup, .. }) => { + GenericUnionVariants(&sub.any_of).ensure_subtype_of( + &GenericUnionVariants(&sup.one_of), + tg, + errors, + ) + } + (TypeNode::Either { data: sub, .. }, TypeNode::Either { data: sup, .. }) => { + sub.ensure_subtype_of(sup, tg, errors) + } + (_, TypeNode::Union { data: sup, .. }) => { + let sub = UnionTypeData { + any_of: vec![sub_idx], + }; + sub.ensure_subtype_of(sup, tg, errors); + } + (_, TypeNode::Either { data: sup, .. }) => { + let sub = EitherTypeData { + one_of: vec![sub_idx], + }; + sub.ensure_subtype_of(sup, tg, errors); + } + (_, TypeNode::Function { .. }) => { + errors.push("Function types are not supported for supertype"); + } + (TypeNode::Function { data, .. }, _) => { + ExtendedTypeNode::new(tg, data.output).ensure_subtype_of(sup, tg, errors); + } + (x, y) => errors.push(format!( + "Type mismatch: {} to {}", + x.type_name(), + y.type_name() + )), + } + } + } +} diff --git a/libs/common/src/typegraph/validator.rs b/libs/common/src/typegraph/validator/value.rs similarity index 56% rename from libs/common/src/typegraph/validator.rs rename to libs/common/src/typegraph/validator/value.rs index 1fc757785..dc9527ce4 100644 --- a/libs/common/src/typegraph/validator.rs +++ b/libs/common/src/typegraph/validator/value.rs @@ -3,207 +3,21 @@ use std::collections::HashSet; -use crate::typegraph::{TypeNode, Typegraph}; use anyhow::{anyhow, bail, Result}; use serde_json::Value; -use super::{ - visitor::{Path, PathSegment, TypeVisitor, VisitResult}, - EitherTypeData, FloatTypeData, Injection, IntegerTypeData, ListTypeData, ObjectTypeData, - StringTypeData, UnionTypeData, +use crate::typegraph::{ + EitherTypeData, FloatTypeData, IntegerTypeData, ListTypeData, ObjectTypeData, StringTypeData, + TypeNode, Typegraph, UnionTypeData, }; -pub fn validate_typegraph(tg: &Typegraph) -> Vec { - let validator = Validator::default(); - tg.traverse_types(validator).unwrap() -} - -#[derive(Debug)] -pub struct ValidatorError { - pub path: String, - pub message: String, -} - -#[derive(Default)] -struct Validator { - errors: Vec, -} - -impl Validator { - fn push_error(&mut self, path: &[PathSegment], message: impl Into) { - self.errors.push(ValidatorError { - path: Path(path).to_string(), - message: message.into(), - }); - } -} - fn to_string(value: &Value) -> String { serde_json::to_string(value).unwrap() } -impl Typegraph { - fn collect_nested_variants_into(&self, out: &mut Vec, variants: &[u32]) { - for idx in variants { - let node = self.types.get(*idx as usize).unwrap(); - match node { - TypeNode::Union { - data: UnionTypeData { any_of: variants }, - .. - } - | TypeNode::Either { - data: EitherTypeData { one_of: variants }, - .. - } => self.collect_nested_variants_into(out, variants), - _ => out.push(*idx), - } - } - } -} - -impl TypeVisitor for Validator { - type Return = Vec; - - fn visit( - &mut self, - type_idx: u32, - path: &[PathSegment], - tg: &Typegraph, - as_input: bool, - ) -> VisitResult { - let node = &tg.types[type_idx as usize]; - - if as_input { - // do not allow t.func in input types - if let TypeNode::Function { .. } = node { - self.push_error(path, "function is not allowed in input types"); - return VisitResult::Continue(false); - } - } else { - match node { - TypeNode::Union { .. } | TypeNode::Either { .. } => { - let mut variants = vec![]; - tg.collect_nested_variants_into(&mut variants, &[type_idx]); - let mut object_count = 0; - - for variant_type in variants - .iter() - .map(|idx| tg.types.get(*idx as usize).unwrap()) - { - match variant_type { - TypeNode::Object { .. } => object_count += 1, - TypeNode::Boolean { .. } - | TypeNode::Float { .. } - | TypeNode::Integer { .. } - | TypeNode::String { .. } => { - // scalar - } - TypeNode::List { data, .. } => { - let item_type = tg.types.get(data.items as usize).unwrap(); - if !item_type.is_scalar() { - self.push_error( - path, - format!( - "array of '{}' not allowed as union/either variant", - item_type.type_name() - ), - ); - return VisitResult::Continue(false); - } - } - _ => { - self.push_error( - path, - format!( - "type '{}' not allowed as union/either variant", - variant_type.type_name() - ), - ); - return VisitResult::Continue(false); - } - } - } - - if object_count != 0 && object_count != variants.len() { - self.push_error( - path, - "union variants must either be all scalars or all objects", - ); - return VisitResult::Continue(false); - } - } - TypeNode::Function { .. } => { - // validate materializer?? - // TODO deno static - } - _ => {} - } - } - - if let Some(enumeration) = &node.base().enumeration { - if matches!(node, TypeNode::Optional { .. }) { - self.push_error( - path, - "optional not cannot have enumerated values".to_owned(), - ); - } else { - for value in enumeration.iter() { - match serde_json::from_str::(value) { - Ok(val) => match tg.validate_value(type_idx, &val) { - Ok(_) => {} - Err(err) => self.push_error(path, err.to_string()), - }, - Err(e) => self.push_error( - path, - format!("Error while deserializing enum value {value:?}: {e:?}"), - ), - } - } - } - } - - if let Some(injection) = &node.base().injection { - match injection { - Injection::Static(data) => { - for value in data.values().iter() { - match serde_json::from_str::(value) { - Ok(val) => match tg.validate_value(type_idx, &val) { - Ok(_) => {} - Err(err) => self.push_error(path, err.to_string()), - }, - Err(e) => { - self.push_error( - path, - format!( - "Error while parsing static injection value {value:?}: {e:?}", - value = value - ), - ); - } - } - } - } - Injection::Parent(_data) => { - // TODO match type to parent type - } - _ => (), - } - - // - VisitResult::Continue(false) - } else { - VisitResult::Continue(true) - } - } - - fn get_result(self) -> Option { - Some(self.errors) - } -} - // TODO validation path impl Typegraph { - fn validate_value(&self, type_idx: u32, value: &Value) -> Result<()> { + pub fn validate_value(&self, type_idx: u32, value: &Value) -> Result<()> { let type_node = &self.types[type_idx as usize]; match type_node { diff --git a/libs/common/src/typegraph/visitor.rs b/libs/common/src/typegraph/visitor.rs index 500f7e00b..a51240dc4 100644 --- a/libs/common/src/typegraph/visitor.rs +++ b/libs/common/src/typegraph/visitor.rs @@ -8,27 +8,35 @@ use super::{TypeNode, Typegraph}; impl Typegraph { /// Depth-first traversal over all the types - pub fn traverse_types(&self, visitor: V) -> Option { + pub fn traverse_types<'a, V>(&'a self, visitor: V, context: &'a V::Context) -> Option + where + V: TypeVisitor<'a> + Sized, + { let mut traversal = TypegraphTraversal { tg: self, path: vec![], - as_input: false, visited_types: HashSet::new(), visited_input_types: HashSet::new(), visitor, + as_input: false, }; traversal - .visit_type(0) - .or_else(|| traversal.visitor.get_result()) - // if let Some(ret) = traversal.visit_type(0) { - // ret - // } else { - // traversal.visitor.get_result() - // } + .visit_type(0, context) + .or_else(|| traversal.visitor.take_result()) } } -struct TypegraphTraversal<'a, V: TypeVisitor + Sized> { +pub struct FunctionMetadata { + pub idx: u32, + // TODO Vec<> + pub path: String, + pub parent_struct_idx: u32, +} + +struct TypegraphTraversal<'a, V> +where + V: TypeVisitor<'a> + Sized, +{ tg: &'a Typegraph, path: Vec>, as_input: bool, @@ -37,34 +45,55 @@ struct TypegraphTraversal<'a, V: TypeVisitor + Sized> { visitor: V, } -impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { - fn visit_type(&mut self, type_idx: u32) -> Option { - if self.as_input { +impl<'a, V> TypegraphTraversal<'a, V> +where + V: TypeVisitor<'a> + Sized, +{ + fn visit_type(&mut self, type_idx: u32, context: &'a V::Context) -> Option { + let res = if self.as_input { if self.visited_input_types.contains(&type_idx) { return None; } self.visited_input_types.insert(type_idx); + let type_node = &context.get_typegraph().types[type_idx as usize]; + let node = CurrentNode { + type_idx, + type_node, + path: &self.path, + }; + + self.visitor.visit_input_type(node, context) } else { if self.visited_types.contains(&type_idx) { return None; } self.visited_types.insert(type_idx); - } - let res = self - .visitor - .visit(type_idx, &self.path, self.tg, self.as_input); + let type_node = &context.get_typegraph().types[type_idx as usize]; + let node = CurrentNode { + type_idx, + type_node, + path: &self.path, + }; + + self.visitor.visit(node, context) + }; + let type_node = &self.tg.types[type_idx as usize]; match res { VisitResult::Continue(deeper) if deeper => match type_node { - TypeNode::Optional { data, .. } => self.visit_optional(type_idx, data.item), - TypeNode::Object { data, .. } => self.visit_object(type_idx, &data.properties), - TypeNode::List { data, .. } => self.visit_array(type_idx, data.items), - TypeNode::Union { data, .. } => self.visit_union(type_idx, &data.any_of), - TypeNode::Either { data, .. } => self.visit_either(type_idx, &data.one_of), + TypeNode::Optional { data, .. } => { + self.visit_optional(type_idx, data.item, context) + } + TypeNode::Object { data, .. } => { + self.visit_object(type_idx, &data.properties, context) + } + TypeNode::List { data, .. } => self.visit_array(type_idx, data.items, context), + TypeNode::Union { data, .. } => self.visit_union(type_idx, &data.any_of, context), + TypeNode::Either { data, .. } => self.visit_either(type_idx, &data.one_of, context), TypeNode::Function { data, .. } => { - self.visit_function(type_idx, data.input, data.output) + self.visit_function(type_idx, data.input, data.output, context) } TypeNode::Boolean { .. } | TypeNode::Float { .. } @@ -81,25 +110,35 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { } } - fn visit_optional(&mut self, type_idx: u32, item_type_idx: u32) -> Option { + fn visit_optional( + &mut self, + type_idx: u32, + item_type_idx: u32, + context: &'a V::Context, + ) -> Option { self.visit_child( PathSegment { from: type_idx, edge: Edge::OptionalItem, }, item_type_idx, - false, + context, ) } - fn visit_array(&mut self, type_idx: u32, item_type_idx: u32) -> Option { + fn visit_array( + &mut self, + type_idx: u32, + item_type_idx: u32, + context: &'a V::Context, + ) -> Option { self.visit_child( PathSegment { from: type_idx, edge: Edge::ArrayItem, }, item_type_idx, - false, + context, ) } @@ -107,6 +146,7 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { &mut self, type_idx: u32, props: &'a IndexMap, + context: &'a V::Context, ) -> Option { for (prop_name, prop_type) in props.iter() { let res = self.visit_child( @@ -115,7 +155,7 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { edge: Edge::ObjectProp(prop_name), }, *prop_type, - false, + context, ); if let Some(res) = res { return Some(res); @@ -124,7 +164,12 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { None } - fn visit_union(&mut self, type_idx: u32, variants: &'a [u32]) -> Option { + fn visit_union( + &mut self, + type_idx: u32, + variants: &'a [u32], + context: &'a V::Context, + ) -> Option { for (i, variant_type) in variants.iter().enumerate() { let res = self.visit_child( PathSegment { @@ -132,7 +177,7 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { edge: Edge::UnionVariant(i), }, *variant_type, - false, + context, ); if let Some(ret) = res { return Some(ret); @@ -141,7 +186,12 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { None } - fn visit_either(&mut self, type_idx: u32, variants: &'a [u32]) -> Option { + fn visit_either( + &mut self, + type_idx: u32, + variants: &'a [u32], + context: &'a V::Context, + ) -> Option { variants.iter().enumerate().find_map(|(i, t)| { self.visit_child( PathSegment { @@ -149,47 +199,70 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { edge: Edge::EitherVariant(i), }, *t, - false, + context, ) }) } - fn visit_function(&mut self, type_idx: u32, input: u32, output: u32) -> Option { - [ - (Edge::FunctionInput, input, true), - (Edge::FunctionOutput, output, false), - ] - .into_iter() - .find_map(|(edge, t, as_input)| { - self.visit_child( - PathSegment { - from: type_idx, - edge, - }, - t, - as_input, - ) - }) + fn visit_function( + &mut self, + type_idx: u32, + input: u32, + output: u32, + context: &'a V::Context, + ) -> Option { + if self.as_input { + // TODO warning + return None; + } + + let last_path_seg = self.path.last().unwrap(); + match last_path_seg.edge { + Edge::ObjectProp(_) => {} + _ => { + return Some(V::Return::from_error( + Path(&self.path).to_string(), + "Function is only allowed as struct field (direct child)".to_string(), + )); + } + } + + self.as_input = true; + let res = self.visit_child( + PathSegment { + from: type_idx, + edge: Edge::FunctionInput, + }, + input, + context, + ); + self.as_input = false; + + if let Some(ret) = res { + return Some(ret); + } + + let res = self.visit_child( + PathSegment { + from: type_idx, + edge: Edge::FunctionOutput, + }, + output, + context, + ); + + res } fn visit_child( &mut self, segment: PathSegment<'a>, type_idx: u32, - as_input: bool, + context: &'a V::Context, ) -> Option { - let root_input = as_input && !self.as_input; - if root_input { - self.as_input = as_input; - } - self.path.push(segment); - let res = self.visit_type(type_idx); + let res = self.visit_type(type_idx, context); self.path.pop().unwrap(); - - if root_input { - self.as_input = false; - } res } } @@ -197,8 +270,8 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { #[derive(Debug)] pub struct PathSegment<'a> { #[allow(dead_code)] - from: u32, // typeIdx - edge: Edge<'a>, + pub from: u32, // typeIdx + pub edge: Edge<'a>, } impl<'a> Display for PathSegment<'a> { @@ -242,22 +315,44 @@ pub enum VisitResult { Return(T), } -pub trait TypeVisitor { - type Return: Sized; +#[derive(Clone, Copy)] +pub struct CurrentNode<'a> { + pub type_idx: u32, + pub type_node: &'a TypeNode, + pub path: &'a [PathSegment<'a>], +} + +pub trait TypeVisitorContext { + fn get_typegraph(&self) -> &Typegraph; +} + +pub trait TypeVisitor<'a> { + type Return: Sized + VisitorResult; + type Context: TypeVisitorContext + Clone; /// return true to continue the traversal on the subgraph fn visit( &mut self, - type_idx: u32, - path: &[PathSegment], - tg: &Typegraph, - as_input: bool, + current_node: CurrentNode<'_>, + context: &Self::Context, ) -> VisitResult; - fn get_result(self) -> Option + fn visit_input_type( + &mut self, + current_node: CurrentNode<'_>, + context: &Self::Context, + ) -> VisitResult { + self.visit(current_node, context) + } + + fn take_result(&mut self) -> Option where Self: Sized, { None } } + +pub trait VisitorResult { + fn from_error(path: String, message: String) -> Self; +} diff --git a/typegate/deno.lock b/typegate/deno.lock index 9da9ac94f..2a87c2194 100644 --- a/typegate/deno.lock +++ b/typegate/deno.lock @@ -6,6 +6,7 @@ "npm:@types/node": "npm:@types/node@18.16.19", "npm:chance@1.1.11": "npm:chance@1.1.11", "npm:graphql@16.8.1": "npm:graphql@16.8.1", + "npm:json-schema-faker@0.5.3": "npm:json-schema-faker@0.5.3", "npm:lodash": "npm:lodash@4.17.21", "npm:mathjs@11.11.1": "npm:mathjs@11.11.1", "npm:pg": "npm:pg@8.11.3", @@ -69,10 +70,20 @@ "debug": "debug@4.3.4" } }, + "argparse@1.0.10": { + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dependencies": { + "sprintf-js": "sprintf-js@1.0.3" + } + }, "buffer-writer@2.0.0": { "integrity": "sha512-a7ZpuTZU1TRtnwyCNW3I5dc0wWNC3VR9S++Ewyk2HHZdrO3CQJqSpd+95Us590V6AL7JqUAH2IwZ/398PmNFgw==", "dependencies": {} }, + "call-me-maybe@1.0.2": { + "integrity": "sha512-HpX65o1Hnr9HH25ojC1YGs7HCQLq0GCOibSaWER0eNpgJ/Z1MZv2mTc7+xh6WOPxbRVcmgbv4hGU+uSQ/2xFZQ==", + "dependencies": {} + }, "chance@1.1.11": { "integrity": "sha512-kqTg3WWywappJPqtgrdvbA380VoXO2eu9VCV895JgbyHsaErXdyHK9LOZ911OvAk6L0obK7kDk9CGs8+oBawVA==", "dependencies": {} @@ -99,6 +110,14 @@ "integrity": "sha512-nV5aVWW1K0wEiUIEdZ4erkGGH8mDxGyxSeqPzRNtWP7ataw+/olFObw7hujFWlVjNsaDFw5VZ5NzVSIqRgfTiw==", "dependencies": {} }, + "esprima@4.0.1": { + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dependencies": {} + }, + "format-util@1.0.5": { + "integrity": "sha512-varLbTj0e0yVyRpqQhuWV+8hlePAgaoFRhNFj50BNjEIrw1/DphHSObtqwskVCPWNgzwPoQrZAbfa/SBiicNeg==", + "dependencies": {} + }, "fraction.js@4.3.4": { "integrity": "sha512-pwiTgt0Q7t+GHZA4yaLjObx4vXmmdcS0iSJ19o8d/goUGgItX9UZWKWNnLHehxviD8wU2IWRsnR8cD5+yOJP2Q==", "dependencies": {} @@ -118,6 +137,32 @@ "integrity": "sha512-nO6jcEfZWQXDhOiBtG2KvKyEptz7RVbpGP4vTD2hLBdmNQSsCiicO2Ioinv6UI4y9ukqnBpy+XZ9H6uLNgJTlw==", "dependencies": {} }, + "js-yaml@3.14.1": { + "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "dependencies": { + "argparse": "argparse@1.0.10", + "esprima": "esprima@4.0.1" + } + }, + "json-schema-faker@0.5.3": { + "integrity": "sha512-BeIrR0+YSrTbAR9dOMnjbFl1MvHyXnq+Wpdw1FpWZDHWKLzK229hZ5huyPcmzFUfVq1ODwf40WdGVoE266UBUg==", + "dependencies": { + "json-schema-ref-parser": "json-schema-ref-parser@6.1.0", + "jsonpath-plus": "jsonpath-plus@7.2.0" + } + }, + "json-schema-ref-parser@6.1.0": { + "integrity": "sha512-pXe9H1m6IgIpXmE5JSb8epilNTGsmTb2iPohAXpOdhqGFbQjNeHHsZxU+C8w6T81GZxSPFLeUoqDJmzxx5IGuw==", + "dependencies": { + "call-me-maybe": "call-me-maybe@1.0.2", + "js-yaml": "js-yaml@3.14.1", + "ono": "ono@4.0.11" + } + }, + "jsonpath-plus@7.2.0": { + "integrity": "sha512-zBfiUPM5nD0YZSBT/o/fbCUlCcepMIdP0CJZxM1+KgA4f2T206f6VAg9e7mX35+KlMaIc5qXW34f3BnwJ3w+RA==", + "dependencies": {} + }, "lodash@4.17.21": { "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", "dependencies": {} @@ -144,6 +189,12 @@ "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", "dependencies": {} }, + "ono@4.0.11": { + "integrity": "sha512-jQ31cORBFE6td25deYeD80wxKBMj+zBmHTrVxnc6CKhx8gho6ipmWM5zj/oeoqioZ99yqBls9Z/9Nss7J26G2g==", + "dependencies": { + "format-util": "format-util@1.0.5" + } + }, "packet-reader@1.0.0": { "integrity": "sha512-HAKu/fG3HpHFO0AA8WE8q2g+gBJaZ9MG7fcKk+IJPLTGAD6Psw4443l+9DGRbOIh3/aXr7Phy0TjilYivJo5XQ==", "dependencies": {} @@ -229,6 +280,10 @@ "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==", "dependencies": {} }, + "sprintf-js@1.0.3": { + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==", + "dependencies": {} + }, "tiny-emitter@2.1.0": { "integrity": "sha512-NB6Dk1A9xgQPMoGqC5CVXn123gWyte215ONT5Pp5a0yt4nlEoO1ZWeCwpncaekPHXO60i47ihFnZPiRPjRMq4Q==", "dependencies": {} diff --git a/typegate/src/engine/planner/args.ts b/typegate/src/engine/planner/args.ts index 0e2706f1b..860483769 100644 --- a/typegate/src/engine/planner/args.ts +++ b/typegate/src/engine/planner/args.ts @@ -24,13 +24,21 @@ import { import { mapValues } from "std/collections/map_values.ts"; import { filterValues } from "std/collections/filter_values.ts"; -import { EffectType, EitherNode } from "../../typegraph/types.ts"; +import { + EffectType, + EitherNode, + FunctionParameterTransform, +} from "../../typegraph/types.ts"; import { getChildTypes, visitTypes } from "../../typegraph/visitor.ts"; import { generateValidator } from "../typecheck/input.ts"; import { getParentId } from "../stage_id.ts"; import { BadContext } from "../../errors.ts"; import { selectInjection } from "./injection_utils.ts"; +import { + compileParameterTransformer, + defaultParameterTransformer, +} from "./parameter_transformer.ts"; class MandatoryArgumentError extends Error { constructor(argDetails: string) { @@ -84,6 +92,7 @@ export function collectArgs( parentProps: Record, typeIdx: TypeIdx, astNodes: Record, + parameterTransform: FunctionParameterTransform | null, ): CollectedArgs { const collector = new ArgumentCollector( typegraph, @@ -108,6 +117,13 @@ export function collectArgs( } const validate = generateValidator(typegraph, typeIdx); + const parameterTransformer = parameterTransform == null + ? defaultParameterTransformer + : compileParameterTransformer( + typegraph, + parentProps, + parameterTransform.transform_root, + ); const policies = collector.policies; @@ -124,7 +140,10 @@ export function collectArgs( // typecheck validate(value); return { - compute: () => value, + compute: (c) => { + const { parent, context } = c; + return parameterTransformer({ args: value, parent, context }); + }, deps: [], policies, }; @@ -136,7 +155,8 @@ export function collectArgs( compute: (params) => { const value = mapValues(compute, (c) => c(params)); validate(value); - return value; + const { parent, context } = params; + return parameterTransformer({ args: value, parent, context }); }, deps: Array.from(collector.deps.parent).map((dep) => `${parentId}.${dep}`), policies, diff --git a/typegate/src/engine/planner/mod.ts b/typegate/src/engine/planner/mod.ts index ba28ee906..be5a39768 100644 --- a/typegate/src/engine/planner/mod.ts +++ b/typegate/src/engine/planner/mod.ts @@ -411,8 +411,13 @@ export class Planner { } const schema = this.tg.type(node.typeIdx, Type.FUNCTION); - const { input: inputIdx, output: outputIdx, rate_calls, rate_weight } = - schema; + const { + input: inputIdx, + output: outputIdx, + rate_calls, + rate_weight, + parameterTransform = null, + } = schema; const outputType = this.tg.type(outputIdx); const mat = this.tg.materializer(schema.materializer); @@ -440,6 +445,7 @@ export class Planner { parentProps, inputIdx, argNodes, + parameterTransform, ); deps.push(...collected.deps); diff --git a/typegate/src/engine/planner/parameter_transformer.ts b/typegate/src/engine/planner/parameter_transformer.ts new file mode 100644 index 000000000..988bc8ea3 --- /dev/null +++ b/typegate/src/engine/planner/parameter_transformer.ts @@ -0,0 +1,275 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +import { TypeGraph } from "../../typegraph/mod.ts"; +import { Type } from "../../typegraph/type_node.ts"; +import { ParameterTransformNode } from "../../typegraph/types.ts"; +import { generateBooleanValidator } from "../typecheck/inline_validators/boolean.ts"; +import { generateListValidator } from "../typecheck/inline_validators/list.ts"; +import { generateNumberValidator } from "../typecheck/inline_validators/number.ts"; +import { + generateObjectValidator, + getKeys, +} from "../typecheck/inline_validators/object.ts"; +import { generateStringValidator } from "../typecheck/inline_validators/string.ts"; + +export type TransformParamsInput = { + args: Record; + context: Record; + parent: Record; +}; + +export function defaultParameterTransformer(input: TransformParamsInput) { + return input.args; +} + +export type TransformParams = { + (input: TransformParamsInput): Record; +}; + +export function compileParameterTransformer( + typegraph: TypeGraph, + parentProps: Record, + transformerTreeRoot: ParameterTransformNode, +): TransformParams { + const ctx = new TransformerCompilationContext(typegraph, parentProps); + const fnBody = ctx.compile(transformerTreeRoot); + const fn = new Function("input", fnBody) as TransformParams; + return (input) => { + const res = fn(input); + return res; + }; +} + +class TransformerCompilationContext { + #tg: TypeGraph; + #parentProps: Record; + #path: string[] = []; + #latestVarIndex = 0; + #collector: string[] = []; + + constructor(typegraph: TypeGraph, parentProps: Record) { + this.#tg = typegraph; + this.#parentProps = parentProps; + } + + #reset() { + this.#collector = [ + "const { args, context, parent } = input;\n", + ]; + } + + compile(rootNode: ParameterTransformNode) { + this.#reset(); + const varName = this.#compileNode(rootNode); + this.#collector.push(`return ${varName};`); + return this.#collector.join("\n"); + } + + #compileNode(node: ParameterTransformNode) { + const { typeIdx, data: nodeData } = node; + if ("type" in nodeData) { + switch (nodeData.type) { + case "object": + return this.#compileObject(typeIdx, nodeData.fields); + case "array": + return this.#compileArray(typeIdx, nodeData.items); + default: + // unreachable + throw new Error( + `Unknown type: ${(nodeData as any).type} at ${this.#path}`, + ); + } + } else { + switch (nodeData.source) { + case "arg": + return this.#compileArgInjection(typeIdx, nodeData.name); + case "context": + return this.#compileContextInjection(typeIdx, nodeData.key); + case "secret": + return this.#compileSecretsInjection(typeIdx, nodeData.key); + case "parent": + return this.#compileParentInjection(typeIdx, nodeData.parentIdx); + default: + throw new Error( + `Unknown source: ${nodeData.source} at ${this.#path}`, + ); + } + } + } + + #compileObject( + typeIdx: number, + fields: Record, + ): string { + const varName = this.#createVarName(); + this.#collector.push(`const ${varName} = {};`); + + for (const [key, node] of Object.entries(fields)) { + const path = this.#path; + path.push(key); + const propVarName = this.#compileNode(node); + path.pop(); + this.#collector.push( + `${varName}[${JSON.stringify(key)}] = ${propVarName};`, + ); + } + + const typeNode = this.#tg.type(typeIdx, Type.OBJECT); + + this.#collector.push( + ...generateObjectValidator( + typeNode, + varName, + this.#path.join("."), + getKeys(typeNode, (idx) => this.#tg.type(idx)), + ), + ); + + return varName; + } + + #compileArray(typeIdx: number, items: ParameterTransformNode[]) { + const varName = this.#createVarName(); + this.#collector.push(`const ${varName} = [];`); + + for (let i = 0; i < items.length; i++) { + const path = this.#path; + path.push(i.toString()); + const propVarName = this.#compileNode(items[i]); + path.pop(); + this.#collector.push(`${varName}.push(${propVarName});`); + } + + const typeNode = this.#tg.type(typeIdx, Type.LIST); + + this.#collector.push( + ...generateListValidator(typeNode, varName, this.#path.join(".")), + ); + + return varName; + } + + #compileArgInjection(_typeIdx: number, name: string) { + // No validation is needed since the value is already validated in the planner + const varName = this.#createVarName(); + this.#collector.push(`const ${varName} = args[${JSON.stringify(name)}];`); + return varName; + } + + #compileContextInjection(typeIdx: number, key: string) { + const varName = this.#createVarName(); + let typeNode = this.#tg.type(typeIdx); + let optional = false; + if (typeNode.type === Type.OPTIONAL) { + typeNode = this.#tg.type(typeNode.item); + optional = true; + } + this.#collector.push(`const ${varName} = context[${JSON.stringify(key)}];`); + + const path = this.#path.join("."); + + this.#collector.push(`if (${varName} != null) {`); + + switch (typeNode.type) { + case Type.OPTIONAL: + throw new Error(`At "${path}": nested optional not supported`); + case Type.INTEGER: { + const parsedVar = this.#createVarName(); + this.#collector.push( + `const ${parsedVar} = parseInt(${varName}, 10);`, + ...generateNumberValidator(typeNode, parsedVar, path), + ); + break; + } + case Type.FLOAT: { + const parsedVar = this.#createVarName(); + this.#collector.push( + `const ${parsedVar} = parseFloat(${varName});`, + ...generateNumberValidator(typeNode, parsedVar, path), + ); + break; + } + case Type.STRING: + this.#collector.push( + ...generateStringValidator(typeNode, varName, path), + ); + break; + case Type.BOOLEAN: { + const parsedVar = this.#createVarName(); + + this.#collector.push( + `const ${varName} = Boolean(${varName});`, + ...generateBooleanValidator(typeNode, parsedVar, path), + ); + break; + } + + default: + throw new Error( + `At "${path}": Unsupported type "${typeNode.type}" for context injection`, + ); + } + + this.#collector.push("}"); + if (!optional) { + const keyStr = JSON.stringify(key); + this.#collector.push( + `else {`, + ` throw new Error(\`At "${path}": Context value is missing for "${keyStr}"\`);`, + `}`, + ); + } + + return varName; + } + + #compileSecretsInjection(typeIdx: number, key: string) { + const typeNode = this.#tg.type(typeIdx); + const secret = this.#tg.parseSecret(typeNode, key); + // TODO type validation ? -- only additional constraints + const varName = this.#createVarName(); + this.#collector.push(`const ${varName} = ${JSON.stringify(secret)};`); + + const path = this.#path.join("."); + + switch (typeNode.type) { + case Type.STRING: + this.#collector.push( + ...generateStringValidator(typeNode, varName, path), + ); + break; + case Type.INTEGER: + case Type.FLOAT: + this.#collector.push( + ...generateNumberValidator(typeNode, varName, path), + ); + break; + default: + // TODO optional?? + throw new Error( + `At "${path}": Unsupported type "${typeNode.type}" for secret injection`, + ); + } + + return varName; + } + + #compileParentInjection(_typeIdx: number, parentIdx: number) { + // VALIDATION + // - the source is validated in the arg computation step; + // - type inheritance is checked AOT with the typegraph + + // TODO what if the value is lazy (a function?) + + const [key] = Object.entries(this.#parentProps) + .find(([_key, idx]) => idx === parentIdx)!; + const varName = this.#createVarName(); + this.#collector.push(`const ${varName} = parent[${JSON.stringify(key)}];`); + return varName; + } + + #createVarName() { + return `var${++this.#latestVarIndex}`; + } +} diff --git a/typegate/src/engine/typecheck/inline_validators/boolean.ts b/typegate/src/engine/typecheck/inline_validators/boolean.ts new file mode 100644 index 000000000..ef50c7115 --- /dev/null +++ b/typegate/src/engine/typecheck/inline_validators/boolean.ts @@ -0,0 +1,15 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +import { BooleanNode } from "../../../typegraph/types.ts"; +import { check } from "./common.ts"; + +export function generateBooleanValidator( + _typeNode: BooleanNode, + varName: string, + path: string, +): string[] { + return [ + check(`typeof ${varName} === "boolean"`, `Expected boolean at ${path}`), + ]; +} diff --git a/typegate/src/engine/typecheck/inline_validators/common.ts b/typegate/src/engine/typecheck/inline_validators/common.ts new file mode 100644 index 000000000..edc360b35 --- /dev/null +++ b/typegate/src/engine/typecheck/inline_validators/common.ts @@ -0,0 +1,6 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +export function check(condition: string, message: string) { + return `if (!(${condition})) throw new Error(${message});`; +} diff --git a/typegate/src/engine/typecheck/inline_validators/constraints.ts b/typegate/src/engine/typecheck/inline_validators/constraints.ts new file mode 100644 index 000000000..f02d8e0f9 --- /dev/null +++ b/typegate/src/engine/typecheck/inline_validators/constraints.ts @@ -0,0 +1,61 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +import { TypeNode } from "../../../typegraph/type_node.ts"; +import { check } from "./common.ts"; + +// binary operator or function +export type ConstraintTest = + | string + | ((ref: string, constraintValue: unknown) => string); + +export type ConstraintSpec = { + name: N; + test: ConstraintTest; + description?: string; +}; + +export type ConstraintList = ConstraintSpec[]; + +export function getConstraintTest(op: string) { + return (ref: string, constraintValue: unknown) => + `${ref} ${op} ${JSON.stringify(constraintValue)}`; +} + +export function generateConstraintValidator( + constraint: ConstraintSpec, + constraintValue: unknown, + ref: string, + path: string, +) { + const { name, test, description } = constraint; + const c = description ?? name; + const testFn = typeof test === "string" ? getConstraintTest(test) : test; + const condition = testFn(ref, constraintValue); + const expected = JSON.stringify(constraintValue); + return check( + condition, + `\`At "${path}", expected ${c}: ${expected}; got \${${ref}}\``, + ); +} + +type ValidNode = L extends ConstraintList + ? TypeNode & Partial> + : never; + +export function generateConstraintValidatorsFor< + N extends string, + L = ConstraintList, +>( + constraints: ConstraintList, + typeNode: ValidNode, +): string[] { + const res: string[] = []; + for (const c of constraints) { + const constraintValue = typeNode[c.name]; + if (constraintValue != null) { + res.push(generateConstraintValidator(c, constraintValue, "value", "")); + } + } + return res; +} diff --git a/typegate/src/engine/typecheck/inline_validators/file.ts b/typegate/src/engine/typecheck/inline_validators/file.ts new file mode 100644 index 000000000..89f460809 --- /dev/null +++ b/typegate/src/engine/typecheck/inline_validators/file.ts @@ -0,0 +1,38 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +import { FileNode } from "../../../typegraph/types.ts"; +import { check } from "./common.ts"; +import { + ConstraintSpec, + generateConstraintValidatorsFor, +} from "./constraints.ts"; + +const fileConstraints = [ + { + name: "minSize", + test: (ref, c) => `${ref}.size < ${c}`, + description: "minimum size", + }, + { + name: "maxSize", + test: (ref, c) => `${ref}.size > ${c}`, + description: "maximum size", + }, + { + name: "mimeTypes", + test: (ref, c) => `${JSON.stringify(c)}.includes(${ref}.type)`, + description: "mime type", + }, +] as const satisfies ConstraintSpec[]; + +export function generateFileValidator( + typeNode: FileNode, + varName: string, + path: string, +): string[] { + return [ + check(`${varName} instanceof File`, `"At ${path}: expected File"`), + ...generateConstraintValidatorsFor(fileConstraints, typeNode), + ]; +} diff --git a/typegate/src/engine/typecheck/inline_validators/list.ts b/typegate/src/engine/typecheck/inline_validators/list.ts new file mode 100644 index 000000000..fbeb8d971 --- /dev/null +++ b/typegate/src/engine/typecheck/inline_validators/list.ts @@ -0,0 +1,33 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +import { ListNode } from "../../../typegraph/type_node.ts"; +import { check } from "./common.ts"; +import { + ConstraintSpec, + generateConstraintValidatorsFor, +} from "./constraints.ts"; + +const arrayConstraints = [ + { + name: "minItems", + test: (ref, c) => `${ref}.length < ${c}`, + description: "minimum items", + }, + { + name: "maxItems", + test: (ref, c) => `${ref}.length > ${c}`, + description: "maximum items", + }, +] as const satisfies ConstraintSpec[]; + +export function generateListValidator( + typeNode: ListNode, + varName: string, + path: string, +): string[] { + return [ + check(`Array.isArray(${varName})`, `"Expected array at ${path}"`), + ...generateConstraintValidatorsFor(arrayConstraints, typeNode), + ]; +} diff --git a/typegate/src/engine/typecheck/inline_validators/mod.ts b/typegate/src/engine/typecheck/inline_validators/mod.ts new file mode 100644 index 000000000..074471e15 --- /dev/null +++ b/typegate/src/engine/typecheck/inline_validators/mod.ts @@ -0,0 +1,6 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +/// These validators are used to generate validator code to be inlined into +/// the generated code. +/// Child nodes are not validated here. Their validators should be inlined. diff --git a/typegate/src/engine/typecheck/inline_validators/number.ts b/typegate/src/engine/typecheck/inline_validators/number.ts new file mode 100644 index 000000000..7ddfcb251 --- /dev/null +++ b/typegate/src/engine/typecheck/inline_validators/number.ts @@ -0,0 +1,30 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +import { FloatNode, IntegerNode } from "../../../typegraph/types.ts"; +import { check } from "./common.ts"; +import { + ConstraintSpec, + generateConstraintValidatorsFor, +} from "./constraints.ts"; + +const numberConstraints = [ + { name: "minimum", test: "<" }, + { name: "maximum", test: ">" }, + { name: "exclusiveMinimum", test: "<=", description: "exclusive minimum" }, + { name: "exclusiveMaximum", test: ">=", description: "exclusive maximum" }, +] as const satisfies ConstraintSpec[]; + +export function generateNumberValidator( + typeNode: IntegerNode | FloatNode, + varName: string, + path: string, +): string[] { + return [ + check( + `typeof ${varName} === "number && !isNan(${varName})"`, + `"Expected number at ${path}"`, + ), + ...generateConstraintValidatorsFor(numberConstraints, typeNode), + ]; +} diff --git a/typegate/src/engine/typecheck/inline_validators/object.ts b/typegate/src/engine/typecheck/inline_validators/object.ts new file mode 100644 index 000000000..a236b5ebb --- /dev/null +++ b/typegate/src/engine/typecheck/inline_validators/object.ts @@ -0,0 +1,56 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +import { ObjectNode, Type, TypeNode } from "../../../typegraph/type_node.ts"; +import { check } from "./common.ts"; + +export function generateObjectValidator( + _typeNode: ObjectNode, + varName: string, + path: string, + keys: { + required: string[]; + optional: string[]; + }, +): string[] { + const varRequired = `${varName}_required`; + const varOptional = `${varName}_optional`; + const varKeys = `${varName}_keys`; + + return [ + check(`typeof ${varName} === "object"`, `"Expected object at ${path}"`), + check(`${varName} != null`, `"Expected a non-null object at ${path}"`), + `const ${varRequired} = new Set(${JSON.stringify(keys.required)});`, + `const ${varOptional} = new Set(${JSON.stringify(keys.optional)});`, + `const ${varKeys} = Object.keys(${varName});`, + `for (const key of ${varKeys}) {`, + ` if (${varRequired}.has(key)) { ${varRequired}.delete(key); continue; }`, + ` if (${varOptional}.has(key)) { ${varOptional}.delete(key); continue; }`, + ` throw new Error(\`At "${path}": unexpected key: \${key}\`);`, + `}`, + check( + `${varRequired}.size === 0`, + `\`At "${path}": missing required keys: \${Array.from(${varRequired})}\``, + ), + ]; +} + +// TODO move +export function getKeys( + typeNode: ObjectNode, + resolve: (idx: number) => TypeNode, +) { + const required: string[] = []; + const optional: string[] = []; + + for (const [key, propIdx] of Object.entries(typeNode.properties)) { + const typeNode = resolve(propIdx); + if (typeNode.type === Type.OPTIONAL) { + optional.push(key); + } else { + required.push(key); + } + } + + return { required, optional }; +} diff --git a/typegate/src/engine/typecheck/inline_validators/string.ts b/typegate/src/engine/typecheck/inline_validators/string.ts new file mode 100644 index 000000000..4888071b9 --- /dev/null +++ b/typegate/src/engine/typecheck/inline_validators/string.ts @@ -0,0 +1,55 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +import { StringNode } from "../../../typegraph/type_node.ts"; +import { check } from "./common.ts"; +import { + ConstraintSpec, + generateConstraintValidatorsFor, +} from "./constraints.ts"; + +const stringLengthConstraints = [ + { + name: "minLength", + test: (ref, p) => `(${ref}).length < ${p}`, + description: "minimum length", + }, + { + name: "maxLength", + test: (ref, p) => `(${ref}).length > ${p}`, + description: "maximum length", + }, + { + name: "pattern", + test: (ref, p) => `new RegExp(${JSON.stringify(p)}).test(${ref})`, + }, +] as const satisfies ConstraintSpec[]; + +export function generateStringValidator( + typeNode: StringNode, + varName: string, + path: string, +): string[] { + const res = [ + check(`typeof ${varName} === "string"`, `"Expected string at ${path}"`), + ...generateConstraintValidatorsFor(stringLengthConstraints, typeNode), + ]; + + if (typeNode.format != null) { + const format = JSON.stringify(typeNode.format); + const validatorName = `${varName}_checkFormat`; + res.push( + `const ${validatorName} = context.formatValidators[${format}];`, + check( + `${varName} != null`, + `Unknown format: ${format}`, + ), + check( + `${validatorName}(${varName})`, + `\`At "${path}": expected to match format: ${format}, got \${${varName}}\``, + ), + ); + } + + return res; +} diff --git a/typegate/src/typegraph/types.ts b/typegate/src/typegraph/types.ts index 04ae4732c..9ba5fc7fc 100644 --- a/typegate/src/typegraph/types.ts +++ b/typegate/src/typegraph/types.ts @@ -147,6 +147,7 @@ export type FunctionNode = { }; as_id: boolean; input: number; + parameterTransform?: FunctionParameterTransform | null; output: number; materializer: number; rate_weight?: number | null; @@ -239,6 +240,34 @@ export type StringFormat = | "date" | "date-time" | "phone"; +export type ParameterTransformNodeData = + | ParameterTransformLeafNode + | ParameterTransformParentNode; +export type ParameterTransformLeafNode = { + source: "arg"; + name: string; +} | { + source: "static"; + valueJson: string; +} | { + source: "secret"; + key: string; +} | { + source: "context"; + key: string; +} | { + source: "parent"; + parentIdx: number; +}; +export type ParameterTransformParentNode = { + type: "object"; + fields: { + [k: string]: ParameterTransformNode; + }; +} | { + type: "array"; + items: ParameterTransformNode[]; +}; export type EffectType = "create" | "update" | "delete" | "read"; export type TGRuntime = KnownRuntime | UnknownRuntime; export type KnownRuntime = { @@ -362,6 +391,14 @@ export interface SingleValueFor_String { export interface SingleValueForUint32 { value: number; } +export interface FunctionParameterTransform { + resolver_input: number; + transform_root: ParameterTransformNode; +} +export interface ParameterTransformNode { + typeIdx: number; + data: ParameterTransformNodeData; +} export interface Materializer { name: string; runtime: number; diff --git a/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap b/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap index f820a3551..74d987ff8 100644 --- a/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap +++ b/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap @@ -8,19 +8,16 @@ snapshot[`typegraph validation 1`] = ` [ERROR] at validator:/test/[in]/e: Required field "a" not found in object '{}' [ERROR] at validator:/test/[in]/f: Required field "a" not found in object '{"b":1}' [ERROR] at validator:/test/[in]/g: Unexpected fields "b" in object "{\\\\"a\\\\":2,\\\\"b\\\\":1}" -[ERROR] at validator:/test/[out]/a: Expected number got '"1"' -[ERROR] at validator:/test/[out]/b: Expected a string, got '["h","e","l","l","o"]' -[ERROR] at validator:/test/[out]/c: Expected a minimum value of 2, got 0 -[ERROR] at validator:/test/[out]/d: Expected a maximun length of 4, got "hello" (len=5) -[ERROR] at validator:/test/[out]/e: Required field "a" not found in object '{}' -[ERROR] at validator:/test/[out]/f: Required field "a" not found in object '{"b":1}' -[ERROR] at validator:/test/[out]/g: Unexpected fields "b" in object "{\\\\"a\\\\":2,\\\\"b\\\\":1}" [ERROR] at validator:/testEnums/[in]/a: Expected a minimum length of 4, got "hi" (len=2) [ERROR] at validator:/testEnums/[in]/a: Expected a string, got '12' [ERROR] at validator:/testEnums/[in]/b: Expected float got '"13"' [ERROR] at validator:/testEnums/[out]/a: Expected a minimum length of 4, got "hi" (len=2) [ERROR] at validator:/testEnums/[out]/a: Expected a string, got '12' [ERROR] at validator:/testEnums/[out]/b: Expected float got '"13"' +[ERROR] at validator:/testFromParent/[out]/nested/[in]/a: from_parent injection: Type mismatch: integer to string +[ERROR] at validator:/testFromParent/[out]/nested/[in]/b: from_parent injection: minimum_length is not defined in the subtype +[ERROR] at validator:/testFromParent/[out]/nested/[in]/b: from_parent injection: maximum_length is greater than the maximum_length of the supertype +[ERROR] at validator:/testFromParent/[out]/nested/[in]/c: from_parent injection: property b is not defined in the supertype [ERROR] error while post processing typegraph validator from "validator.py": Typegraph validator failed validation \` `; diff --git a/typegate/tests/e2e/typegraph/validator.py b/typegate/tests/e2e/typegraph/validator.py index 03ec9fbfc..ba0ff058a 100644 --- a/typegate/tests/e2e/typegraph/validator.py +++ b/typegate/tests/e2e/typegraph/validator.py @@ -29,7 +29,34 @@ def validator(g: Graph): } ) + parents = t.struct( + { + "a": t.integer().rename("A"), + "b": t.string(max=20).rename("B"), + "c": t.struct({"a": t.integer(), "b": t.integer().optional()}).rename("C"), + "d": t.list(t.integer()).rename("D"), + } + ) + g.expose( test=deno.identity(injection), testEnums=deno.identity(enums), + testFromParent=deno.identity(parents).extend( + { + "nested": deno.func( + t.struct( + { + "a": t.string().from_parent("A"), + "b": t.string(min=12, max=16).from_parent("B"), + "c": t.struct( + {"a": t.integer(), "c": t.boolean().optional()} + ).from_parent("C"), + "d": t.list(t.integer()).from_parent("D"), + } + ), + t.struct(), + code="() => ({})", + ), + } + ), ) diff --git a/typegate/tests/injection/injection.py b/typegate/tests/injection/injection.py index 1e57e7ee3..fce54dc09 100644 --- a/typegate/tests/injection/injection.py +++ b/typegate/tests/injection/injection.py @@ -28,9 +28,11 @@ def injection(g: Graph): } ) + operation = t.enum(["insert", "modify", "remove", "read"]) + req2 = t.struct( { - "operation": t.enum(["insert", "modify", "remove", "read"]).set( + "operation": operation.set( { CREATE: "insert", UPDATE: "modify", @@ -40,6 +42,7 @@ def injection(g: Graph): ) } ) + res2 = t.struct({"operation": operation}) copy = t.struct({"a2": t.integer().from_parent("A")}) @@ -82,10 +85,10 @@ def injection(g: Graph): } ), effect_none=deno.identity(req2), - effect_create=deno.func(req2, req2, code="(x) => x", effect=effects.create()), - effect_delete=deno.func(req2, req2, code="(x) => x", effect=effects.delete()), - effect_update=deno.func(req2, req2, code="(x) => x", effect=effects.update()), - effect_upsert=deno.func(req2, req2, code="(x) => x", effect=effects.update()), + effect_create=deno.func(req2, res2, code="(x) => x", effect=effects.create()), + effect_delete=deno.func(req2, res2, code="(x) => x", effect=effects.delete()), + effect_update=deno.func(req2, res2, code="(x) => x", effect=effects.update()), + effect_upsert=deno.func(req2, res2, code="(x) => x", effect=effects.update()), user=gql.query( t.struct({"id": t.integer()}), user.extend( diff --git a/typegate/tests/injection/injection.ts b/typegate/tests/injection/injection.ts index 181da3dfd..9ac155afd 100644 --- a/typegate/tests/injection/injection.ts +++ b/typegate/tests/injection/injection.ts @@ -31,25 +31,6 @@ typegraph("injection", (g: any) => { const pub = Policy.public(); g.expose({ - test: deno.func( - t.struct({ input: tpe }), - t.struct({ - fromInput: tpe, - parent: t.integer({}, { name: "someName" }), - fromParent: deno.func( - t.struct({ - value: t.integer().fromParent({ - [READ]: "someName", - }), - }), - t.struct({ value: t.integer() }), - { code: "(value) => value" }, - ), - }), - { - code: - "({ input }) => { return { fromInput: input, parent: 1234567 }; }", - }, - ).withPolicy(pub), + test: deno.identity(t.struct({ input: tpe })).withPolicy(pub), }); }); diff --git a/typegate/tests/injection/injection_test.ts b/typegate/tests/injection/injection_test.ts index 6e0310b1c..48bcd56fa 100644 --- a/typegate/tests/injection/injection_test.ts +++ b/typegate/tests/injection/injection_test.ts @@ -263,7 +263,7 @@ Meta.test("Deno: value injection", async (t) => { await gql` query { test(input: {a: 12}) { - fromInput { + input { a context optional_context @@ -275,8 +275,6 @@ Meta.test("Deno: value injection", async (t) => { alt_context_opt_missing date } - parent - fromParent { value } } }` .withContext({ @@ -284,7 +282,7 @@ Meta.test("Deno: value injection", async (t) => { }) .expectData({ test: { - fromInput: { + input: { a: 12, context: "123", raw_int: 4, @@ -295,8 +293,6 @@ Meta.test("Deno: value injection", async (t) => { alt_context_opt_missing: "123", date: new Date().toISOString(), }, - parent: 1234567, - fromParent: { value: 1234567 }, }, }) .on(e); diff --git a/typegate/tests/params/apply.py b/typegate/tests/params/apply.py new file mode 100644 index 000000000..fefb732bc --- /dev/null +++ b/typegate/tests/params/apply.py @@ -0,0 +1,126 @@ +from typegraph import Graph, Policy, t, typegraph +from typegraph.runtimes.deno import DenoRuntime + + +@typegraph() +def test_apply(g: Graph): + deno = DenoRuntime() + public = Policy.public() + + g.expose( + public, + renamed=deno.identity(t.struct({"a": t.integer(), "b": t.integer()})).apply( + { + "a": g.as_arg("first"), + "b": g.as_arg("second"), + } + ), + flattened=deno.identity( + t.struct( + { + "a": t.struct( + { + "a1": t.integer(), + "a2": t.integer(), + } + ), + "b": t.struct( + { + "b1": t.struct( + { + "b11": t.integer(), + "b12": t.integer(), + } + ), + "b2": t.integer(), + } + ), + } + ) + ).apply( + { + "a": { + "a1": g.as_arg("a1"), + "a2": g.as_arg("a2"), + }, + "b": { + "b1": { + "b11": g.as_arg("b11"), + "b12": g.as_arg("b12"), + }, + "b2": g.as_arg("b2"), + }, + } + ), + withContext=deno.identity(t.struct({"a": t.integer(), "b": t.string()})).apply( + { + "a": g.as_arg("first"), + "b": g.from_context("context_key"), + }, + ), + withSecret=deno.identity(t.struct({"a": t.integer(), "b": t.string()})).apply( + { + "a": g.as_arg("first"), + "b": g.from_secret("MY_SECRET"), + } + ), + withParent=deno.func( + t.struct(), + t.struct( + { + "a": t.integer(name="A"), + "b": deno.identity( + t.struct({"b1": t.integer(), "b2": t.integer()}) + ).apply( + { + "b1": g.as_arg("b1"), + "b2": g.from_parent("A"), + } + ), + } + ), + code="""() => ({ a: 1 })""", + ), + withArray=deno.identity( + t.struct( + { + "a": t.list(t.integer()), + } + ) + ).apply( + { + "a": [ + g.as_arg("first"), + g.as_arg("second"), + ] + } + ), + withNestedArrays=deno.identity( + t.struct( + { + "a": t.list(t.list(t.integer())), + } + ) + ).apply( + { + "a": [ + [g.as_arg("first")], + g.as_arg("second"), + ] + } + ), + withArrayOfObjects=deno.identity( + t.struct( + { + "a": t.list(t.struct({"b": t.integer()})), + } + ) + ).apply( + { + "a": [ + {"b": g.as_arg("first")}, + g.as_arg("second"), + ] + } + ), + ) diff --git a/typegate/tests/params/apply_test.ts b/typegate/tests/params/apply_test.ts new file mode 100644 index 000000000..0bccbc3a7 --- /dev/null +++ b/typegate/tests/params/apply_test.ts @@ -0,0 +1,132 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +import { gql, Meta } from "../utils/mod.ts"; + +Meta.test("(python (sdk): apply)", async (t) => { + const e = await t.engine("params/apply.py", { + secrets: { + "MY_SECRET": "supersecret", + }, + }); + + await t.should("work with renamed params", async () => { + await gql` + query { + renamed(first: 1, second: 2) { + a b + } + } + ` + .expectData({ + renamed: { a: 1, b: 2 }, + }) + .on(e); + }); + + await t.should("work with renamed params", async () => { + await gql` + query { + flattened(a1: 1, a2: 2, b11: 3, b12: 4, b2: 5) { + a { a1 a2 } + b { b1 { b11 b12 } b2 } + } + } + ` + .expectData({ + flattened: { + a: { a1: 1, a2: 2 }, + b: { b1: { b11: 3, b12: 4 }, b2: 5 }, + }, + }) + .on(e); + }); + + await t.should("work with context", async () => { + await gql` + query { + withContext(first: 1) { + a + b + } + } + ` + .withContext({ context_key: "hum" }) + .expectData({ + withContext: { a: 1, b: "hum" }, + }) + .on(e); + }); + + await t.should("work with secret", async () => { + await gql` + query { + withSecret(first: 1) { + a + b + } + } + ` + .expectData({ + withSecret: { a: 1, b: "supersecret" }, + }) + .on(e); + }); + + await t.should("work with from_parent injection", async () => { + await gql` + query { + withParent { + a + b(b1: 2) { b1 b2 } + } + } + ` + .expectData({ + withParent: { a: 1, b: { b1: 2, b2: 1 } }, + }) + .on(e); + }); + + await t.should("work with list", async () => { + await gql` + query { + withArray(first: 1, second: 2) { + a + } + } + ` + .expectData({ + withArray: { a: [1, 2] }, + }) + .on(e); + }); + + await t.should("work with nested arrays", async () => { + await gql` + query { + withNestedArrays(first: 1, second: [2]) { + a + } + } + ` + .expectData({ + withNestedArrays: { a: [[1], [2]] }, + }) + .on(e); + }); + + await t.should("work with array of objects", async () => { + await gql` + query { + withArrayOfObjects(first: 1, second: { b: 12 }) { + a { b } + } + } + ` + .expectData({ + withArrayOfObjects: { a: [{ b: 1 }, { b: 12 }] }, + }) + .on(e); + }); +}); diff --git a/typegate/tests/planner/__snapshots__/planner_test.ts.snap b/typegate/tests/planner/__snapshots__/planner_test.ts.snap index 927afa7dc..fa3248d10 100644 --- a/typegate/tests/planner/__snapshots__/planner_test.ts.snap +++ b/typegate/tests/planner/__snapshots__/planner_test.ts.snap @@ -9,7 +9,7 @@ snapshot[`planner 1`] = ` "one", ], type: { - title: "func_78", + title: "func_75", type: "function", }, }, @@ -108,7 +108,7 @@ snapshot[`planner 2`] = ` rate_calls: false, rate_weight: null, runtime: 0, - title: "func_78", + title: "func_75", type: "function", }, referencedTypes: { @@ -158,7 +158,7 @@ snapshot[`planner 2`] = ` ], one: [ { - title: "func_78", + title: "func_75", type: "function", }, { @@ -166,7 +166,7 @@ snapshot[`planner 2`] = ` type: "object", }, { - title: "object_47", + title: "object_52", type: "object", }, ], @@ -203,79 +203,79 @@ snapshot[`planner 4`] = ` snapshot[`planner: dependencies 1`] = ` [ - "two two two object object_71 false", - "two.id id two/id integer integer_50 false", + "two two two object object_68 false", + "two.id id two/id integer integer_55 false", "two.email email two/email string UserEmail false", ] `; snapshot[`planner: dependencies 2`] = ` [ - "two two two object object_71 false", - "two.id id two/id integer integer_50 false", + "two two two object object_68 false", + "two.id id two/id integer integer_55 false", "two.email email two/email string UserEmail false", - "two.profile profile two/profile object object_60 false", - "two.profile.firstName firstName two/profile/firstName string string_57 false", - "two.profile.lastName lastName two/profile/lastName string string_58 false", - "two.profile.profilePic profilePic two/profile/profilePic string string_59 false", + "two.profile profile two/profile object object_51 false", + "two.profile.firstName firstName two/profile/firstName string string_48 false", + "two.profile.lastName lastName two/profile/lastName string string_49 false", + "two.profile.profilePic profilePic two/profile/profilePic string string_50 false", ] `; snapshot[`planner: dependencies 3`] = ` [ - "two two two object object_71 false", - "two.id id two/id integer integer_50 false", + "two two two object object_68 false", + "two.id id two/id integer integer_55 false", "two.email email two/email string UserEmail false", - "two.profile profile two/profile object object_60 false", - "two.profile.firstName firstName two/profile/firstName string string_57 false", - "two.profile.lastName lastName two/profile/lastName string string_58 false", - "two.profile.profilePic profilePic two/profile/profilePic string string_59 false", + "two.profile profile two/profile object object_51 false", + "two.profile.firstName firstName two/profile/firstName string string_48 false", + "two.profile.lastName lastName two/profile/lastName string string_49 false", + "two.profile.profilePic profilePic two/profile/profilePic string string_50 false", ] `; snapshot[`planner: dependencies 4`] = ` [ - "two two two object object_71 false", + "two two two object object_68 false", "two.email email two/email string UserEmail true", - "two.profile profile two/profile object object_60 false", - "two.profile.firstName firstName two/profile/firstName string string_57 false", - "two.profile.lastName lastName two/profile/lastName string string_58 false", - "two.profile.profilePic profilePic two/profile/profilePic string string_59 false", - "two.id id two/id integer integer_50 false", + "two.profile profile two/profile object object_51 false", + "two.profile.firstName firstName two/profile/firstName string string_48 false", + "two.profile.lastName lastName two/profile/lastName string string_49 false", + "two.profile.profilePic profilePic two/profile/profilePic string string_50 false", + "two.id id two/id integer integer_55 false", ] `; snapshot[`planner: dependencies 5`] = ` [ - "two two two object object_71 false", + "two two two object object_68 false", "two.email email two/email string UserEmail true", - "two.profile profile two/profile object object_60 false", - "two.profile.firstName firstName two/profile/firstName string string_57 false", - "two.profile.lastName lastName two/profile/lastName string string_58 false", - "two.profile.profilePic profilePic two/profile/profilePic string string_59 false", - "two.taggedPic taggedPic two/taggedPic string string_69 false", + "two.profile profile two/profile object object_51 false", + "two.profile.firstName firstName two/profile/firstName string string_48 false", + "two.profile.lastName lastName two/profile/lastName string string_49 false", + "two.profile.profilePic profilePic two/profile/profilePic string string_50 false", + "two.taggedPic taggedPic two/taggedPic string string_66 false", ] `; snapshot[`planner: dependencies 6`] = ` [ - "two two two object object_71 false", - "two.id id two/id integer integer_50 false", + "two two two object object_68 false", + "two.id id two/id integer integer_55 false", "two.email email two/email string UserEmail true", - "two.profile profile two/profile object object_60 true", - "two.profile.email email two/profile/email string string_56 false", - "two.profile.firstName firstName two/profile/firstName string string_57 false", - "two.profile.lastName lastName two/profile/lastName string string_58 false", - "two.profile.profilePic profilePic two/profile/profilePic string string_59 false", - "two.taggedPic taggedPic two/taggedPic string string_69 false", + "two.profile profile two/profile object object_51 true", + "two.profile.email email two/profile/email string string_47 false", + "two.profile.firstName firstName two/profile/firstName string string_48 false", + "two.profile.lastName lastName two/profile/lastName string string_49 false", + "two.profile.profilePic profilePic two/profile/profilePic string string_50 false", + "two.taggedPic taggedPic two/taggedPic string string_66 false", ] `; snapshot[`planner: dependencies in union/either 1`] = ` [ - "three three three object object_76 false", - "three.id id three/id integer integer_74 false", - "three.user user three/user either either_75 false", + "three three three object object_73 false", + "three.id id three/id integer integer_71 false", + "three.user user three/user either either_72 false", "three.user\$RegisteredUser.id id three/user\$RegisteredUser/id string string_33 false", "three.user\$RegisteredUser.email email three/user\$RegisteredUser/email string RegisteredUserEmail false", "three.user\$RegisteredUser.profile profile three/user\$RegisteredUser/profile object object_42 false", @@ -288,9 +288,9 @@ snapshot[`planner: dependencies in union/either 1`] = ` snapshot[`planner: dependencies in union/either 2`] = ` [ - "three three three object object_76 false", - "three.id id three/id integer integer_74 false", - "three.user user three/user either either_75 false", + "three three three object object_73 false", + "three.id id three/id integer integer_71 false", + "three.user user three/user either either_72 false", "three.user\$RegisteredUser.id id three/user\$RegisteredUser/id string string_33 false", "three.user\$RegisteredUser.email email three/user\$RegisteredUser/email string RegisteredUserEmail true", "three.user\$RegisteredUser.profile profile three/user\$RegisteredUser/profile object object_42 false", diff --git a/typegate/tests/planner/planner.py b/typegate/tests/planner/planner.py index d3413d09f..0f48abd65 100644 --- a/typegate/tests/planner/planner.py +++ b/typegate/tests/planner/planner.py @@ -75,6 +75,15 @@ def test(g: Graph): name="GuestUser", ) + profile = t.struct( + { + "email": t.email(), + "firstName": t.string(), + "lastName": t.string(), + "profilePic": t.string(), + } + ) + public = Policy.public() g.expose( @@ -92,24 +101,11 @@ def test(g: Graph): "email": t.email(name="UserEmail"), "profile": deno.func( t.struct({"email": t.email().from_parent("UserEmail")}), - t.struct( - { - "email": t.email(), - "firstName": t.string(), - "lastName": t.string(), - "profilePic": t.string(), - } - ), + profile, code=dummy_func, ).rename("UserProfile"), "taggedPic": deno.func( - t.struct( - { - "profile": t.struct( - {"email": t.email(), "profilePic": t.string()} - ).from_parent("UserProfile") - } - ), + t.struct({"profile": profile.from_parent("UserProfile")}), t.string(), code=dummy_func, ), diff --git a/typegate/tests/runtimes/typegate/__snapshots__/typegate_runtime_test.ts.snap b/typegate/tests/runtimes/typegate/__snapshots__/typegate_runtime_test.ts.snap index 93d1ce1d0..dfea0d656 100644 --- a/typegate/tests/runtimes/typegate/__snapshots__/typegate_runtime_test.ts.snap +++ b/typegate/tests/runtimes/typegate/__snapshots__/typegate_runtime_test.ts.snap @@ -88,7 +88,7 @@ snapshot[`typegate: find available operations 1`] = ` format: "date-time", optional: false, runtime: "prisma", - title: "string_6", + title: "string_69", type: "string", }, }, @@ -198,7 +198,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: false, runtime: "prisma", - title: "_103_recordWithNestedCount[]", + title: "_104_recordWithNestedCount[]", type: "list", }, outputItem: { @@ -267,7 +267,7 @@ snapshot[`typegate: find available operations 1`] = ` format: "date-time", optional: false, runtime: "prisma", - title: "string_6", + title: "string_69", type: "string", }, }, @@ -331,7 +331,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: false, runtime: "prisma", - title: "_279_user_identityWithNestedCount_excluding___rel_user_identity_users_1[]", + title: "_282_user_identityWithNestedCount_excluding___rel_user_identity_users_1[]", type: "list", }, }, @@ -379,7 +379,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: false, runtime: "prisma", - title: "_281_messagesWithNestedCount_excluding_messageSender[]", + title: "_284_messagesWithNestedCount_excluding_messageSender[]", type: "list", }, }, @@ -396,7 +396,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: true, runtime: "prisma", - title: "integer_282", + title: "integer_285", type: "integer", }, }, @@ -413,7 +413,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: true, runtime: "prisma", - title: "integer_282", + title: "integer_285", type: "integer", }, }, @@ -523,7 +523,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: false, runtime: "prisma", - title: "_314_messagesWithNestedCount[]", + title: "_317_messagesWithNestedCount[]", type: "list", }, outputItem: { diff --git a/typegate/tests/simple/__snapshots__/class_syntax_test.ts.snap b/typegate/tests/simple/__snapshots__/class_syntax_test.ts.snap index 5c4b45460..e0b968ba8 100644 --- a/typegate/tests/simple/__snapshots__/class_syntax_test.ts.snap +++ b/typegate/tests/simple/__snapshots__/class_syntax_test.ts.snap @@ -73,7 +73,7 @@ snapshot[`Class Syntax 1`] = ` }, ], kind: "OBJECT", - name: "object_22", + name: "object_23", }, { fields: [ @@ -85,12 +85,12 @@ snapshot[`Class Syntax 1`] = ` }, ], kind: "OBJECT", - name: "object_13", + name: "object_14", }, { fields: null, kind: "UNION", - name: "either_7Out", + name: "either_8Out", }, { fields: [ @@ -132,7 +132,7 @@ snapshot[`Class Syntax 1`] = ` }, ], kind: "OBJECT", - name: "object_19", + name: "object_20", }, { fields: [ @@ -144,17 +144,17 @@ snapshot[`Class Syntax 1`] = ` }, ], kind: "OBJECT", - name: "object_25", + name: "object_26", }, { fields: null, kind: "INPUT_OBJECT", - name: "object_13Inp", + name: "object_14Inp", }, { fields: null, kind: "SCALAR", - name: "either_7In", + name: "either_8In", }, { fields: null, @@ -169,7 +169,7 @@ snapshot[`Class Syntax 1`] = ` { fields: null, kind: "INPUT_OBJECT", - name: "object_19Inp", + name: "object_20Inp", }, { fields: null, diff --git a/typegate/tests/simple/class_syntax.py b/typegate/tests/simple/class_syntax.py index c0f0aa0fa..bd1cf673a 100644 --- a/typegate/tests/simple/class_syntax.py +++ b/typegate/tests/simple/class_syntax.py @@ -6,7 +6,7 @@ def class_syntax(g: Graph): # class Tag(t.struct): # # name = t.string() # reserved - tag = t.struct({"name": t.string()}, name="Tag") + tag = t.struct({"name": t.string()}) class TitledEntity(t.struct): title = t.string(min=2, max=20).optional() @@ -15,7 +15,7 @@ class TitledEntity(t.struct): class Info(TitledEntity): content = t.string() - metadata = t.either([tag, Info().rename("Info")]) + metadata = t.either([tag.rename("Tag"), Info().rename("Info")]) class Comment(TitledEntity): content = t.string() diff --git a/typegate/tests/typecheck/__snapshots__/typecheck_test.ts.snap b/typegate/tests/typecheck/__snapshots__/typecheck_test.ts.snap index 708191c9e..8df653597 100644 --- a/typegate/tests/typecheck/__snapshots__/typecheck_test.ts.snap +++ b/typegate/tests/typecheck/__snapshots__/typecheck_test.ts.snap @@ -1,7 +1,7 @@ export const snapshot = {}; snapshot[`typecheck 1`] = ` -"function validate_62_1(value, path, errors, context) { +"function validate_66_1(value, path, errors, context) { if (typeof value !== \\"object\\") { errors.push([path, \`expected an object, got \${typeof value}\`]); } else if (value == null) { @@ -112,7 +112,7 @@ function validate_4(value, path, errors, context) { } } } -return validate_62_1; +return validate_66_1; " `; diff --git a/typegraph/core/Cargo.toml b/typegraph/core/Cargo.toml index 10a78e539..a8825e56a 100644 --- a/typegraph/core/Cargo.toml +++ b/typegraph/core/Cargo.toml @@ -18,9 +18,10 @@ common = { path = "../../libs/common" } indoc = "2.0.4" graphql-parser = "0.4.0" sha2 = "0.10.8" +paste = "1.0.14" [dev-dependencies] insta = { version = "1.34.0", features = ["glob"] } pathdiff = "0.2.1" ptree = "0.4.0" -paste = "1.0.14" +indoc = "2.0.4" diff --git a/typegraph/core/src/conversion/mod.rs b/typegraph/core/src/conversion/mod.rs index 24762d8a9..cdb2565fc 100644 --- a/typegraph/core/src/conversion/mod.rs +++ b/typegraph/core/src/conversion/mod.rs @@ -1,6 +1,7 @@ // Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. // SPDX-License-Identifier: MPL-2.0 +pub mod parameter_transform; pub mod params; pub mod policies; pub mod runtimes; diff --git a/typegraph/core/src/conversion/parameter_transform.rs b/typegraph/core/src/conversion/parameter_transform.rs new file mode 100644 index 000000000..7dcb48a24 --- /dev/null +++ b/typegraph/core/src/conversion/parameter_transform.rs @@ -0,0 +1,125 @@ +// Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. +// SPDX-License-Identifier: MPL-2.0 + +use std::collections::HashMap; + +use crate::errors::Result; +use crate::errors::TgError; +use crate::t; +use crate::t::TypeBuilder; +use crate::types::TypeId; +use crate::{params::apply::*, typegraph::TypegraphContext}; +use common::typegraph::parameter_transform as cm; + +pub fn convert_tree( + ctx: &mut TypegraphContext, + root_fields: &ParameterTransformNode, + runtime_id: u32, +) -> Result { + let res = convert_node(ctx, root_fields, runtime_id)?; + if !matches!( + res.data, + cm::ParameterTransformNodeData::Parent(cm::ParameterTransformParentNode::Object { .. }) + ) { + return Err(TgError::from("Root node must be an object node")); + } + Ok(res) +} + +fn convert_node( + ctx: &mut TypegraphContext, + node: &ParameterTransformNode, + runtime_id: u32, +) -> Result { + let type_idx = ctx + .register_type(TypeId(node.type_id).resolve_ref()?.1, Some(runtime_id))? + .0; + match &node.data { + ParameterTransformNodeData::Leaf(leaf_node) => { + convert_leaf_node(ctx, leaf_node, runtime_id).map(|leaf_node| { + cm::ParameterTransformNode { + type_idx, + data: cm::ParameterTransformNodeData::Leaf(leaf_node), + } + }) + } + ParameterTransformNodeData::Parent(parent_node) => { + convert_parent_node(ctx, parent_node, runtime_id).map(|parent_node| { + cm::ParameterTransformNode { + type_idx, + data: cm::ParameterTransformNodeData::Parent(parent_node), + } + }) + } + } +} + +fn convert_leaf_node( + ctx: &mut TypegraphContext, + node: &ParameterTransformLeafNode, + runtime_id: u32, +) -> Result { + match node { + ParameterTransformLeafNode::Arg { name } => { + Ok(cm::ParameterTransformLeafNode::Arg { name: name.clone() }) + } + ParameterTransformLeafNode::Static { value_json } => { + Ok(cm::ParameterTransformLeafNode::Static { + value_json: value_json.clone(), + }) + } + ParameterTransformLeafNode::Secret { key } => { + Ok(cm::ParameterTransformLeafNode::Secret { key: key.clone() }) + } + ParameterTransformLeafNode::Context { key } => { + Ok(cm::ParameterTransformLeafNode::Context { key: key.clone() }) + } + ParameterTransformLeafNode::Parent { type_name } => { + let type_ref = t::ref_(type_name).build()?; + let (_, type_def) = type_ref.resolve_ref()?; + let parent_idx = ctx.register_type(type_def, Some(runtime_id))?.0; + Ok(cm::ParameterTransformLeafNode::Parent { parent_idx }) + } + } +} + +fn convert_parent_node( + ctx: &mut TypegraphContext, + node: &ParameterTransformParentNode, + runtime_id: u32, +) -> Result { + match node { + ParameterTransformParentNode::Object { fields } => { + convert_object_node(ctx, fields, runtime_id) + } + ParameterTransformParentNode::Array { items } => convert_array_node(ctx, items, runtime_id), + } +} + +fn convert_object_node( + ctx: &mut TypegraphContext, + fields: &HashMap, + runtime_id: u32, +) -> Result { + Ok(cm::ParameterTransformParentNode::Object { + fields: fields + .iter() + .try_fold(HashMap::new(), |mut acc, (key, node)| { + acc.insert(key.clone(), convert_node(ctx, node, runtime_id)?); + Ok::<_, TgError>(acc) + })?, + }) +} + +fn convert_array_node( + ctx: &mut TypegraphContext, + items: &[ParameterTransformNode], + runtime_id: u32, +) -> Result { + Ok(cm::ParameterTransformParentNode::Array { + items: items + .iter() + .map(|e| convert_node(ctx, e, runtime_id)) + .collect::>>()?, + }) +} diff --git a/typegraph/core/src/global_store.rs b/typegraph/core/src/global_store.rs index 5936db41e..bc13a818b 100644 --- a/typegraph/core/src/global_store.rs +++ b/typegraph/core/src/global_store.rs @@ -6,7 +6,7 @@ use crate::runtimes::{ DenoMaterializer, Materializer, MaterializerData, MaterializerDenoModule, Runtime, }; use crate::types::type_ref::TypeRef; -use crate::types::{Struct, Type, TypeDef, TypeDefExt, TypeId}; +use crate::types::{Type, TypeDef, TypeDefExt, TypeId}; use crate::wit::core::{Policy as CorePolicy, PolicyId, RuntimeId}; use crate::wit::utils::Auth as WitAuth; @@ -61,6 +61,8 @@ pub struct Store { auths: Vec, deploy_cwd_dir: Option, + + latest_alias_no: u32, } impl Store { @@ -193,6 +195,24 @@ impl Store { }) } + pub fn generate_alias() -> String { + with_store_mut(|s| { + s.latest_alias_no += 1; + format!("__alias_{}", s.latest_alias_no) + }) + } + + pub fn register_alias(name: impl Into, id: TypeId) -> Result<()> { + let name = name.into(); + with_store_mut(|s| { + if s.type_by_names.contains_key(&name) { + return Err(format!("type with name {:?} already exists", name).into()); + } + s.type_by_names.insert(name, id); + Ok(()) + }) + } + pub fn set_deploy_cwd(value: Option) { with_store_mut(|s| { s.deploy_cwd_dir = value.map(PathBuf::from); @@ -476,6 +496,31 @@ impl Store { } } +/// Generate a pub fn for asserting/unwrapping a Type as a specific TypeDef variant +/// e.g.: `as_variant!(Struct)` gives +/// ```rust +/// pub fn as_struct(&self) -> Result> { +/// match self.as_type()? { +/// Type::Def(TypeDef::Struct(inner)) => Ok(inner), +/// Type::Ref(type_ref) => type_ref.try_resolve()?.id().as_struct(), +/// _ => Err(errors::invalid_type("Struct", &self.repr()?)), +/// } +/// } +/// ``` +macro_rules! as_variant { + ($variant:ident) => { + paste::paste! { + pub fn [](&self) -> Result]>> { + match self.as_type()? { + Type::Def(TypeDef::$variant(inner)) => Ok(inner), + Type::Ref(type_ref) => type_ref.try_resolve()?.id().[](), + _ => Err(errors::invalid_type(stringify!($variant), &self.repr()?)), + } + } + } + }; +} + impl TypeId { pub fn as_type(&self) -> Result { with_store(|s| { @@ -486,13 +531,8 @@ impl TypeId { }) } - pub fn as_struct(&self) -> Result> { - match self.as_type()? { - Type::Def(TypeDef::Struct(inner)) => Ok(inner), - Type::Ref(type_ref) => type_ref.try_resolve()?.id().as_struct(), - _ => Err(errors::invalid_type("Struct", &self.repr()?)), - } - } + as_variant!(Struct); + as_variant!(List); pub fn is_func(&self) -> Result { Ok(matches!(self.as_type_def()?, Some(TypeDef::Func(_)))) @@ -506,4 +546,12 @@ impl TypeId { _ => Ok(type_id), } } + + pub fn resolve_optional(&self) -> Result { + let type_id = *self; + match type_id.as_type_def()? { + Some(TypeDef::Optional(o)) => Ok(o.data.of.into()), + _ => Ok(type_id), + } + } } diff --git a/typegraph/core/src/lib.rs b/typegraph/core/src/lib.rs index f6ca4f47f..e596070e0 100644 --- a/typegraph/core/src/lib.rs +++ b/typegraph/core/src/lib.rs @@ -4,6 +4,7 @@ mod conversion; mod errors; mod global_store; +mod params; mod runtimes; mod t; mod typedef; @@ -17,9 +18,10 @@ mod test_utils; use std::collections::HashSet; -use errors::Result; +use errors::{Result, TgError}; use global_store::{NameRegistration, Store}; use indoc::formatdoc; +use params::apply; use regex::Regex; use runtimes::{DenoMaterializer, Materializer}; use types::{ @@ -27,10 +29,11 @@ use types::{ TypeDef, TypeDefExt, TypeId, Union, }; +use utils::clear_name; use wit::core::{ - ContextCheck, Policy, PolicyId, PolicySpec, TypeBase, TypeEither, TypeFile, TypeFloat, - TypeFunc, TypeId as CoreTypeId, TypeInteger, TypeList, TypeOptional, TypeString, TypeStruct, - TypeUnion, TypegraphFinalizeMode, TypegraphInitParams, + ContextCheck, Policy, PolicyId, PolicySpec, TransformData, TypeBase, TypeEither, TypeFile, + TypeFloat, TypeFunc, TypeId as CoreTypeId, TypeInteger, TypeList, TypeOptional, TypeString, + TypeStruct, TypeUnion, TypegraphFinalizeMode, TypegraphInitParams, }; use wit::runtimes::{Guest, MaterializerDenoFunc}; @@ -315,11 +318,40 @@ impl wit::core::Guest for Lib { .into()) } + fn extend_struct( + type_id: CoreTypeId, + new_props: Vec<(String, CoreTypeId)>, + ) -> Result { + let type_def = TypeId(type_id).as_struct()?; + let mut props = type_def.data.props.clone(); + props.extend(new_props); + + Ok(Store::register_type_def( + |id| { + TypeDef::Struct( + Struct { + id, + base: clear_name(&type_def.base), + extended_base: type_def.extended_base.clone(), + data: TypeStruct { + props, + ..type_def.data.clone() + }, + } + .into(), + ) + }, + NameRegistration(false), + )? + .into()) + } + fn funcb(data: TypeFunc) -> Result { let wrapper_type = TypeId(data.inp); if !matches!(TypeDef::try_from(wrapper_type)?, TypeDef::Struct(_)) { return Err(errors::invalid_input_type(&wrapper_type.repr()?)); } + let base = TypeBase::default(); Ok(Store::register_type_def( |id| { @@ -338,6 +370,18 @@ impl wit::core::Guest for Lib { .into()) } + fn get_transform_data( + resolver_input: CoreTypeId, + transform_tree: String, + ) -> Result { + apply::build_transform_data( + resolver_input.into(), + &serde_json::from_str(&transform_tree).map_err(|e| -> TgError { + format!("Error while parsing transform tree: {e:?}").into() + })?, + ) + } + fn with_injection(type_id: CoreTypeId, injection: String) -> Result { // TODO try to resolve proxy? let type_def = TypeId(type_id).as_type_def()?; diff --git a/typegraph/core/src/params/apply.rs b/typegraph/core/src/params/apply.rs new file mode 100644 index 000000000..064a8a5dd --- /dev/null +++ b/typegraph/core/src/params/apply.rs @@ -0,0 +1,519 @@ +// Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. +// SPDX-License-Identifier: MPL-2.0 + +use crate::errors::{ErrorContext, Result, TgError}; +use crate::t::{self, TypeBuilder}; +use crate::types::{Type, TypeDef, TypeId}; +use crate::wit::core::{ParameterTransform, TransformData}; +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use std::fmt::Write; + +pub mod raw_tree { + use serde::Deserialize; + use std::collections::HashMap; + + #[derive(Debug, Clone, Deserialize)] + #[serde(tag = "source", rename_all = "lowercase")] + pub enum ParameterTransformLeafNode { + Arg { name: Option }, + Static { value_json: String }, + Secret { key: String }, + Context { key: String }, + Parent { type_name: String }, + } + + #[derive(Debug, Clone, Deserialize)] + #[serde(tag = "type", rename_all = "lowercase")] + pub enum ParameterTransformParentNode { + Object { + fields: HashMap, + }, + Array { + items: Vec, + }, + } + + #[derive(Debug, Clone, Deserialize)] + #[serde(untagged, rename_all = "lowercase")] + pub enum ParameterTransformNode { + Leaf(ParameterTransformLeafNode), + Parent(ParameterTransformParentNode), + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "source", rename_all = "lowercase")] +pub enum ParameterTransformLeafNode { + Arg { name: String }, + Static { value_json: String }, + Secret { key: String }, + Context { key: String }, + Parent { type_name: String }, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", rename_all = "lowercase")] +pub enum ParameterTransformParentNode { + Object { + fields: HashMap, + }, + Array { + items: Vec, + }, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum ParameterTransformNodeData { + Leaf(ParameterTransformLeafNode), + Parent(ParameterTransformParentNode), +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ParameterTransformNode { + pub type_id: u32, + pub data: ParameterTransformNodeData, +} + +struct QueryParam { + path: Vec, + type_id: TypeId, +} + +#[derive(Clone, Debug)] +enum PathSeg { + Field(String), + Index(usize), +} + +impl ToString for PathSeg { + fn to_string(&self) -> String { + match self { + PathSeg::Field(s) => s.clone(), + PathSeg::Index(i) => format!("[{i}]"), + } + } +} + +fn stringify_path(path: &[PathSeg]) -> Result { + let mut buf = String::new(); + if let Some(seg) = path.first() { + match seg { + PathSeg::Field(s) => write!(&mut buf, "{s}"), + PathSeg::Index(i) => write!(&mut buf, "[{i}]"), + } + .map_err(|e| -> TgError { format!("Error while writing path segment: {e:?}").into() })?; + + for seg in path[1..].iter() { + match seg { + PathSeg::Field(s) => write!(&mut buf, ".{s}"), + PathSeg::Index(i) => write!(&mut buf, ".[{i}]"), + } + .map_err(|e| -> TgError { + format!("Error while writing path segment: {e:?}").into() + })?; + } + } + Ok(buf) +} + +impl TryFrom for PathSeg { + type Error = crate::errors::TgError; + + fn try_from(s: String) -> Result { + if s.starts_with('[') && s.ends_with(']') { + if let Ok(index) = s[1..s.len() - 1].parse::() { + Ok(PathSeg::Index(index)) + } else { + Err("invalid index".into()) + } + } else { + Ok(PathSeg::Field(s)) + } + } +} + +pub fn build_transform_data( + resolver_input: TypeId, + root_fields: &HashMap, +) -> Result { + let mut context = TransformDataBuildContext::new(); + let new_tree = context.check_object_node(resolver_input, root_fields)?; + + let mut query_input_type = t::struct_(); + for (name, param) in context.query_params.into_iter() { + query_input_type.prop(name, param.type_id); + } + + Ok(TransformData { + query_input: query_input_type.build()?.0, + parameter_transform: ParameterTransform { + resolver_input: resolver_input.0, + transform_tree: serde_json::to_string(&new_tree) + .map_err(|e| TgError::from(format!("Failed to serialize transform_root: {}", e)))?, + }, + }) +} + +pub struct TransformDataBuildContext { + query_params: HashMap, + path: Vec, +} + +impl TransformDataBuildContext { + pub fn new() -> Self { + Self { + query_params: HashMap::new(), + path: vec![], + } + } + + fn get_param_name(&self, provided: Option<&str>) -> Result { + if let Some(provided) = provided { + Ok(provided.to_string()) + } else { + let seg = self + .path + .last() + .ok_or_else(|| TgError::from("Cannot get param name from empty path"))?; + match seg { + PathSeg::Field(name) => Ok(name.clone()), + PathSeg::Index(_) => Err(format!( + "Cannot get param name from array item at {}. Please provide an explicit name", + stringify_path(&self.path).unwrap() + ) + .into()), + } + } + } + + fn check_leaf_node( + &mut self, + type_id: TypeId, + leaf: &raw_tree::ParameterTransformLeafNode, + ) -> Result { + use raw_tree::ParameterTransformLeafNode as N; + match leaf { + N::Arg { name } => { + let param_name = self.get_param_name(name.as_deref())?; + let old_param = self.query_params.insert( + param_name.clone(), + QueryParam { + path: self.path.iter().map(|seg| seg.to_string()).collect(), + type_id, + }, + ); + if let Some(param) = old_param { + let path1 = stringify_path(&self.path)?; + let path2 = param.path.join("."); + Err( + format!("Duplicate parameter {param_name:?} at {path1:?} and {path2:?}") + .into(), + ) + } else { + Ok(ParameterTransformNode { + type_id: type_id.0, + data: ParameterTransformNodeData::Leaf(ParameterTransformLeafNode::Arg { + name: param_name, + }), + }) + } + } + N::Static { value_json } => { + // TODO validate value type + Ok(ParameterTransformNode { + type_id: type_id.0, + data: ParameterTransformNodeData::Leaf(ParameterTransformLeafNode::Static { + value_json: value_json.clone(), + }), + }) + } + N::Secret { key } => Ok(ParameterTransformNode { + type_id: type_id.0, + data: ParameterTransformNodeData::Leaf(ParameterTransformLeafNode::Secret { + key: key.clone(), + }), + }), + N::Context { key } => Ok(ParameterTransformNode { + type_id: type_id.0, + data: ParameterTransformNodeData::Leaf(ParameterTransformLeafNode::Context { + key: key.clone(), + }), + }), + N::Parent { type_name } => Ok(ParameterTransformNode { + type_id: type_id.0, + data: ParameterTransformNodeData::Leaf(ParameterTransformLeafNode::Parent { + type_name: type_name.clone(), + }), + }), + } + } + + fn check_object_node( + &mut self, + type_id: TypeId, + fields: &HashMap, + ) -> Result { + let mut new_fields = HashMap::new(); + let type_id = type_id.resolve_optional()?; + let ty = type_id.as_struct().with_context(|| { + format!( + "Expected a (optional) struct for an object node at {path:?}", + path = stringify_path(&self.path).unwrap() + ) + })?; + let mut available_fields = ty + .data + .props + .iter() + .map(|(k, v)| (k.as_str(), *v)) + .collect::>(); + for (field, node) in fields { + let prop_type_id = available_fields.remove(field.as_str()).ok_or_else(|| { + format!( + "Field {field:?} not found in type {repr:?} at {path:?}", + field = field, + repr = type_id.repr().unwrap(), + path = stringify_path(&self.path).unwrap() + ) + })?; + + self.path.push(PathSeg::Field(field.clone())); + let extended_node = self.check_node(prop_type_id.into(), node)?; + self.path.pop(); + new_fields.insert(field.clone(), extended_node); + } + + let non_optional_fields = available_fields + .iter() + .filter_map(|(&k, &type_id)| { + TypeId(type_id) + .as_type() + .map(|ty| { + if !matches!(ty, Type::Def(TypeDef::Optional(_))) { + Some(k) + } else { + None + } + }) + .with_context(|| { + format!( + "Error while resolving type #{type_id} at the field {k:?} at {path:?}", + path = stringify_path(&self.path).unwrap() + ) + }) + .transpose() + }) + .collect::>>()?; + + if !non_optional_fields.is_empty() { + Err(format!( + "Missing non-optional fields {non_optional_fields:?} at {path:?}", + path = stringify_path(&self.path).unwrap() + ) + .into()) + } else { + Ok(ParameterTransformNode { + type_id: type_id.0, + data: ParameterTransformNodeData::Parent(ParameterTransformParentNode::Object { + fields: new_fields, + }), + }) + } + } + + fn check_array_node( + &mut self, + type_id: TypeId, + items: &[raw_tree::ParameterTransformNode], + ) -> Result { + let mut new_items = vec![]; + let type_id = type_id.resolve_optional()?; + let ty = type_id.as_list().with_context(|| { + format!( + "Expected a (optional) list for an array node at {path:?}", + path = stringify_path(&self.path).unwrap() + ) + })?; + + let item_type_id = TypeId(ty.data.of); + + for (index, node) in items.iter().enumerate() { + self.path.push(PathSeg::Index(index)); + let extended_node = self.check_node(item_type_id, node)?; + self.path.pop(); + new_items.push(extended_node); + } + Ok(ParameterTransformNode { + type_id: type_id.0, + data: ParameterTransformNodeData::Parent(ParameterTransformParentNode::Array { + items: new_items, + }), + }) + } + + fn check_node( + &mut self, + type_id: TypeId, + node: &raw_tree::ParameterTransformNode, + ) -> Result { + use raw_tree::ParameterTransformNode as N; + use raw_tree::ParameterTransformParentNode as P; + match node { + N::Leaf(leaf) => self.check_leaf_node(type_id, leaf), + N::Parent(parent) => match parent { + P::Object { fields } => self.check_object_node(type_id, fields), + P::Array { items } => self.check_array_node(type_id, items), + }, + } + } +} + +#[cfg(test)] +mod test { + use super::*; + use crate::test_utils::tree; + use raw_tree::{ + ParameterTransformLeafNode, ParameterTransformNode, ParameterTransformParentNode, + }; + + #[test] + fn identity() -> Result<()> { + let input = t::struct_() + .propx("a", t::string())? + .propx("b", t::string())? + .build()?; + let root_fields = { + let mut map = HashMap::new(); + map.insert( + "a".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { name: None }), + ); + map.insert( + "b".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { name: None }), + ); + map + }; + + let transform_data = build_transform_data(input, &root_fields)?; + + let print_options = tree::PrintOptions::new().no_indent_lines(); + assert_eq!( + print_options.print(transform_data.query_input.into()), + indoc::indoc! {" + root: struct #3 + [a]: string #0 + [b]: string #1 + "} + ); + Ok(()) + } + + #[test] + fn identity_named() -> Result<()> { + let input = t::struct_() + .propx("a", t::string())? + .propx("b", t::string())? + .build()?; + let root = vec![ + ( + "a".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { + name: Some("first".to_string()), + }), + ), + ( + "b".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { + name: Some("second".to_string()), + }), + ), + ] + .into_iter() + .collect(); + + let transform_data = build_transform_data(input, &root)?; + + let print_options = tree::PrintOptions::new().no_indent_lines(); + assert_eq!( + print_options.print(transform_data.query_input.into()), + indoc::indoc! {" + root: struct #3 + [first]: string #0 + [second]: string #1 + "} + ); + Ok(()) + } + + #[test] + fn array_items() -> Result<()> { + let input = t::struct_() + .propx("a", t::string())? + .propx("b", t::listx(t::string())?)? + .build()?; + let root = vec![ + ( + "a".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { name: None }), + ), + ( + "b".to_string(), + ParameterTransformNode::Parent(ParameterTransformParentNode::Array { + items: vec![ + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { + name: None, + }), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { + name: None, + }), + ], + }), + ), + ] + .into_iter() + .collect(); + + let transform_data = build_transform_data(input, &root); + assert!(transform_data.is_err()); + let err = transform_data.unwrap_err().to_string(); + // eprintln!("{}", err); + assert!(err.contains("Cannot get param name from array item at b.[0]")); + + let root = vec![ + ( + "a".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { name: None }), + ), + ( + "b".to_string(), + ParameterTransformNode::Parent(ParameterTransformParentNode::Array { + items: vec![ + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { + name: Some("first".to_string()), + }), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { + name: Some("second".to_string()), + }), + ], + }), + ), + ] + .into_iter() + .collect(); + + let transform_data = build_transform_data(input, &root)?; + let print_options = tree::PrintOptions::new().no_indent_lines(); + assert_eq!( + print_options.print(transform_data.query_input.into()), + indoc::indoc! {" + root: struct #4 + [a]: string #0 + [first]: string #1 + [second]: string #1 + "} + ); + Ok(()) + } +} diff --git a/typegraph/core/src/params/mod.rs b/typegraph/core/src/params/mod.rs new file mode 100644 index 000000000..80adfdc41 --- /dev/null +++ b/typegraph/core/src/params/mod.rs @@ -0,0 +1,4 @@ +// Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. +// SPDX-License-Identifier: MPL-2.0 + +pub mod apply; diff --git a/typegraph/core/src/runtimes/prisma/type_generation/mod.rs b/typegraph/core/src/runtimes/prisma/type_generation/mod.rs index d692c8d52..29c608aec 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/mod.rs +++ b/typegraph/core/src/runtimes/prisma/type_generation/mod.rs @@ -409,18 +409,19 @@ mod test { let record = models::simple_record()?; context.manage(record)?; + let tp = tree::PrintOptions::new().indent_size(3); if $test_inp { let inp = $op_name.generate_input_type(&context, record)?; insta::assert_snapshot!( paste! { concat!(stringify!([<$op_name:snake>]), " Record inp") }, - tree::print(inp) + tp.print(inp) ); } if $test_out { let out = $op_name.generate_output_type(&context, record)?; insta::assert_snapshot!( paste! { concat!(stringify!([<$op_name:snake>]), " Record out") }, - tree::print(out) + tp.print(out) ); } @@ -431,7 +432,7 @@ mod test { let inp = $op_name.generate_input_type(&context, user)?; insta::assert_snapshot!( paste! { concat!(stringify!([<$op_name:snake>]), " User inp") }, - tree::print(inp) + tp.print(inp) ); } @@ -439,7 +440,7 @@ mod test { let out = $op_name.generate_output_type(&context, user)?; insta::assert_snapshot!( paste! { concat!(stringify!([<$op_name:snake>]), " User out") }, - tree::print(out) + tp.print(out) ); } @@ -447,14 +448,14 @@ mod test { let inp = $op_name.generate_input_type(&context, post)?; insta::assert_snapshot!( paste! { concat!(stringify!([<$op_name:snake>]), " Post inp") }, - tree::print(inp) + tp.print(inp) ); } if $test_out { let out = $op_name.generate_output_type(&context, post)?; insta::assert_snapshot!( paste! { concat!(stringify!([<$op_name:snake>]), " Post out") }, - tree::print(out) + tp.print(out) ); } diff --git a/typegraph/core/src/runtimes/prisma/type_generation/out_type.rs b/typegraph/core/src/runtimes/prisma/type_generation/out_type.rs index 6106e73da..9b340dd7c 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/out_type.rs +++ b/typegraph/core/src/runtimes/prisma/type_generation/out_type.rs @@ -7,6 +7,7 @@ use crate::runtimes::prisma::errors; use crate::runtimes::prisma::model::Property; use crate::t::{self, ConcreteTypeBuilder, TypeBuilder}; use crate::types::TypeId; +use crate::utils::remove_injection; use super::{Cardinality, TypeGen}; @@ -62,7 +63,7 @@ impl TypeGen for OutType { builder.prop(key, out_type); } Property::Scalar(prop) => { - builder.prop(key, prop.wrapper_type_id); + builder.prop(key, remove_injection(prop.wrapper_type_id)?); } Property::Unmanaged(type_id) => { // just forward the original type diff --git a/typegraph/core/src/runtimes/prisma/type_generation/query_where_expr.rs b/typegraph/core/src/runtimes/prisma/type_generation/query_where_expr.rs index 5a5e753e5..389a8ac8e 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/query_where_expr.rs +++ b/typegraph/core/src/runtimes/prisma/type_generation/query_where_expr.rs @@ -20,7 +20,6 @@ impl QueryWhereExpr { } } - #[allow(dead_code)] pub fn unique(mut self) -> Self { self.unique = true; self diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__query_where_expr__tests__Post__QueryWhereExpr.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__query_where_expr__tests__Post__QueryWhereExpr.snap index e9261b24d..eac647918 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__query_where_expr__tests__Post__QueryWhereExpr.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__query_where_expr__tests__Post__QueryWhereExpr.snap @@ -3,217 +3,217 @@ source: typegraph/core/src/runtimes/prisma/type_generation/query_where_expr.rs expression: "tree::print(post_where_expr)" --- root: struct 'QueryPostWhereInput' #78 -├─ [id]: optional '_58__integer_filter_c?' #58 -│ └─ item: optional '_integer_filter_c' #20 -│ └─ item: union #19 -│ ├─ variant_0: either '_integer_filter' #17 -│ │ ├─ variant_0: integer #9 -│ │ ├─ variant_1: struct #12 -│ │ │ └─ [equals]: integer #9 -│ │ ├─ variant_2: struct #13 -│ │ │ └─ [not]: integer #9 -│ │ ├─ variant_3: struct #14 -│ │ │ ├─ [lt]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ [gt]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ [lte]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ └─ [gte]: optional #10 -│ │ │ └─ item: integer #9 -│ │ ├─ variant_4: struct #15 -│ │ │ └─ [in]: list #11 -│ │ │ └─ item: integer #9 -│ │ └─ variant_5: struct #16 -│ │ └─ [notIn]: list #11 -│ │ └─ item: integer #9 -│ └─ variant_1: struct #18 -│ └─ [not]: either '_integer_filter' #17 -│ ├─ variant_0: integer #9 -│ ├─ variant_1: struct #12 -│ │ └─ [equals]: integer #9 -│ ├─ variant_2: struct #13 -│ │ └─ [not]: integer #9 -│ ├─ variant_3: struct #14 -│ │ ├─ [lt]: optional #10 -│ │ │ └─ item: integer #9 -│ │ ├─ [gt]: optional #10 -│ │ │ └─ item: integer #9 -│ │ ├─ [lte]: optional #10 -│ │ │ └─ item: integer #9 -│ │ └─ [gte]: optional #10 -│ │ └─ item: integer #9 -│ ├─ variant_4: struct #15 -│ │ └─ [in]: list #11 -│ │ └─ item: integer #9 -│ └─ variant_5: struct #16 -│ └─ [notIn]: list #11 -│ └─ item: integer #9 -├─ [title]: optional '_59__string_filter_c?' #59 -│ └─ item: optional '_string_filter_c' #37 -│ └─ item: union #36 -│ ├─ variant_0: union '_string_filter' #34 -│ │ ├─ variant_0: string #22 -│ │ ├─ variant_1: struct #25 -│ │ │ └─ [equals]: string #22 -│ │ ├─ variant_2: struct #26 -│ │ │ └─ [not]: string #22 -│ │ ├─ variant_3: struct #27 -│ │ │ └─ [in]: list #24 -│ │ │ └─ item: string #22 -│ │ ├─ variant_4: struct #28 -│ │ │ └─ [notIn]: list #24 -│ │ │ └─ item: string #22 -│ │ ├─ variant_5: struct #31 -│ │ │ ├─ [contains]: string #22 -│ │ │ └─ [mode]: optional #30 -│ │ │ └─ item: string #29 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #32 -│ │ │ └─ [search]: string #22 -│ │ └─ variant_7: struct #33 -│ │ ├─ [startsWith]: optional #23 -│ │ │ └─ item: string #22 -│ │ └─ [endsWith]: optional #23 -│ │ └─ item: string #22 -│ └─ variant_1: struct #35 -│ └─ [not]: union '_string_filter' #34 -│ ├─ variant_0: string #22 -│ ├─ variant_1: struct #25 -│ │ └─ [equals]: string #22 -│ ├─ variant_2: struct #26 -│ │ └─ [not]: string #22 -│ ├─ variant_3: struct #27 -│ │ └─ [in]: list #24 -│ │ └─ item: string #22 -│ ├─ variant_4: struct #28 -│ │ └─ [notIn]: list #24 -│ │ └─ item: string #22 -│ ├─ variant_5: struct #31 -│ │ ├─ [contains]: string #22 -│ │ └─ [mode]: optional #30 -│ │ └─ item: string #29 enum{ '"insensitive"' } -│ ├─ variant_6: struct #32 -│ │ └─ [search]: string #22 -│ └─ variant_7: struct #33 -│ ├─ [startsWith]: optional #23 -│ │ └─ item: string #22 -│ └─ [endsWith]: optional #23 -│ └─ item: string #22 -├─ [author]: optional '_72_UserWhere__skip_8_PostWhere?' #72 -│ └─ item: struct 'UserWhere__skip_8_PostWhere' #71 -│ ├─ [id]: optional '_60__integer_filter_c?' #60 -│ │ └─ item: optional '_integer_filter_c' #20 -│ │ └─ item: union #19 -│ │ ├─ variant_0: either '_integer_filter' #17 -│ │ │ ├─ variant_0: integer #9 -│ │ │ ├─ variant_1: struct #12 -│ │ │ │ └─ [equals]: integer #9 -│ │ │ ├─ variant_2: struct #13 -│ │ │ │ └─ [not]: integer #9 -│ │ │ ├─ variant_3: struct #14 -│ │ │ │ ├─ [lt]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ ├─ [gt]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ ├─ [lte]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ └─ [gte]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ variant_4: struct #15 -│ │ │ │ └─ [in]: list #11 -│ │ │ │ └─ item: integer #9 -│ │ │ └─ variant_5: struct #16 -│ │ │ └─ [notIn]: list #11 -│ │ │ └─ item: integer #9 -│ │ └─ variant_1: struct #18 -│ │ └─ [not]: either '_integer_filter' #17 -│ │ ├─ variant_0: integer #9 -│ │ ├─ variant_1: struct #12 -│ │ │ └─ [equals]: integer #9 -│ │ ├─ variant_2: struct #13 -│ │ │ └─ [not]: integer #9 -│ │ ├─ variant_3: struct #14 -│ │ │ ├─ [lt]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ [gt]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ [lte]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ └─ [gte]: optional #10 -│ │ │ └─ item: integer #9 -│ │ ├─ variant_4: struct #15 -│ │ │ └─ [in]: list #11 -│ │ │ └─ item: integer #9 -│ │ └─ variant_5: struct #16 -│ │ └─ [notIn]: list #11 -│ │ └─ item: integer #9 -│ ├─ [name]: optional '_61__string_filter_c?' #61 -│ │ └─ item: optional '_string_filter_c' #37 -│ │ └─ item: union #36 -│ │ ├─ variant_0: union '_string_filter' #34 -│ │ │ ├─ variant_0: string #22 -│ │ │ ├─ variant_1: struct #25 -│ │ │ │ └─ [equals]: string #22 -│ │ │ ├─ variant_2: struct #26 -│ │ │ │ └─ [not]: string #22 -│ │ │ ├─ variant_3: struct #27 -│ │ │ │ └─ [in]: list #24 -│ │ │ │ └─ item: string #22 -│ │ │ ├─ variant_4: struct #28 -│ │ │ │ └─ [notIn]: list #24 -│ │ │ │ └─ item: string #22 -│ │ │ ├─ variant_5: struct #31 -│ │ │ │ ├─ [contains]: string #22 -│ │ │ │ └─ [mode]: optional #30 -│ │ │ │ └─ item: string #29 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #32 -│ │ │ │ └─ [search]: string #22 -│ │ │ └─ variant_7: struct #33 -│ │ │ ├─ [startsWith]: optional #23 -│ │ │ │ └─ item: string #22 -│ │ │ └─ [endsWith]: optional #23 -│ │ │ └─ item: string #22 -│ │ └─ variant_1: struct #35 -│ │ └─ [not]: union '_string_filter' #34 -│ │ ├─ variant_0: string #22 -│ │ ├─ variant_1: struct #25 -│ │ │ └─ [equals]: string #22 -│ │ ├─ variant_2: struct #26 -│ │ │ └─ [not]: string #22 -│ │ ├─ variant_3: struct #27 -│ │ │ └─ [in]: list #24 -│ │ │ └─ item: string #22 -│ │ ├─ variant_4: struct #28 -│ │ │ └─ [notIn]: list #24 -│ │ │ └─ item: string #22 -│ │ ├─ variant_5: struct #31 -│ │ │ ├─ [contains]: string #22 -│ │ │ └─ [mode]: optional #30 -│ │ │ └─ item: string #29 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #32 -│ │ │ └─ [search]: string #22 -│ │ └─ variant_7: struct #33 -│ │ ├─ [startsWith]: optional #23 -│ │ │ └─ item: string #22 -│ │ └─ [endsWith]: optional #23 -│ │ └─ item: string #22 -│ └─ [posts]: optional #70 -│ └─ item: union #69 -│ ├─ variant_0: struct #64 -│ │ └─ [every]: optional '_63_PostWhere?' #63 -│ │ └─ item: &PostWhere #62 -│ ├─ variant_1: struct #66 -│ │ └─ [some]: optional '_65_PostWhere?' #65 -│ │ └─ item: &PostWhere #62 -│ └─ variant_2: struct #68 -│ └─ [none]: optional '_67_PostWhere?' #67 -│ └─ item: &PostWhere #62 -├─ [AND]: optional '_76__75_QueryPostWhereInput[]?' #76 -│ └─ item: list '_75_QueryPostWhereInput[]' #75 -│ └─ item: &QueryPostWhereInput #74 -├─ [OR]: optional '_76__75_QueryPostWhereInput[]?' #76 -│ └─ item: list '_75_QueryPostWhereInput[]' #75 -│ └─ item: &QueryPostWhereInput #74 -└─ [NOT]: optional '_77_QueryPostWhereInput?' #77 - └─ item: &QueryPostWhereInput #74 +├── [AND]: optional '_76__75_QueryPostWhereInput[]?' #76 +│ └── item: list '_75_QueryPostWhereInput[]' #75 +│ └── item: &QueryPostWhereInput #74 +├── [NOT]: optional '_77_QueryPostWhereInput?' #77 +│ └── item: &QueryPostWhereInput #74 +├── [OR]: optional '_76__75_QueryPostWhereInput[]?' #76 +│ └── item: list '_75_QueryPostWhereInput[]' #75 +│ └── item: &QueryPostWhereInput #74 +├── [author]: optional '_72_UserWhere__skip_8_PostWhere?' #72 +│ └── item: struct 'UserWhere__skip_8_PostWhere' #71 +│ ├── [id]: optional '_60__integer_filter_c?' #60 +│ │ └── item: optional '_integer_filter_c' #20 +│ │ └── item: union #19 +│ │ ├── variant_0: either '_integer_filter' #17 +│ │ │ ├── variant_0: integer #9 +│ │ │ ├── variant_1: struct #12 +│ │ │ │ └── [equals]: integer #9 +│ │ │ ├── variant_2: struct #13 +│ │ │ │ └── [not]: integer #9 +│ │ │ ├── variant_3: struct #14 +│ │ │ │ ├── [gt]: optional #10 +│ │ │ │ │ └── item: integer #9 +│ │ │ │ ├── [gte]: optional #10 +│ │ │ │ │ └── item: integer #9 +│ │ │ │ ├── [lt]: optional #10 +│ │ │ │ │ └── item: integer #9 +│ │ │ │ └── [lte]: optional #10 +│ │ │ │ └── item: integer #9 +│ │ │ ├── variant_4: struct #15 +│ │ │ │ └── [in]: list #11 +│ │ │ │ └── item: integer #9 +│ │ │ └── variant_5: struct #16 +│ │ │ └── [notIn]: list #11 +│ │ │ └── item: integer #9 +│ │ └── variant_1: struct #18 +│ │ └── [not]: either '_integer_filter' #17 +│ │ ├── variant_0: integer #9 +│ │ ├── variant_1: struct #12 +│ │ │ └── [equals]: integer #9 +│ │ ├── variant_2: struct #13 +│ │ │ └── [not]: integer #9 +│ │ ├── variant_3: struct #14 +│ │ │ ├── [gt]: optional #10 +│ │ │ │ └── item: integer #9 +│ │ │ ├── [gte]: optional #10 +│ │ │ │ └── item: integer #9 +│ │ │ ├── [lt]: optional #10 +│ │ │ │ └── item: integer #9 +│ │ │ └── [lte]: optional #10 +│ │ │ └── item: integer #9 +│ │ ├── variant_4: struct #15 +│ │ │ └── [in]: list #11 +│ │ │ └── item: integer #9 +│ │ └── variant_5: struct #16 +│ │ └── [notIn]: list #11 +│ │ └── item: integer #9 +│ ├── [name]: optional '_61__string_filter_c?' #61 +│ │ └── item: optional '_string_filter_c' #37 +│ │ └── item: union #36 +│ │ ├── variant_0: union '_string_filter' #34 +│ │ │ ├── variant_0: string #22 +│ │ │ ├── variant_1: struct #25 +│ │ │ │ └── [equals]: string #22 +│ │ │ ├── variant_2: struct #26 +│ │ │ │ └── [not]: string #22 +│ │ │ ├── variant_3: struct #27 +│ │ │ │ └── [in]: list #24 +│ │ │ │ └── item: string #22 +│ │ │ ├── variant_4: struct #28 +│ │ │ │ └── [notIn]: list #24 +│ │ │ │ └── item: string #22 +│ │ │ ├── variant_5: struct #31 +│ │ │ │ ├── [contains]: string #22 +│ │ │ │ └── [mode]: optional #30 +│ │ │ │ └── item: string #29 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #32 +│ │ │ │ └── [search]: string #22 +│ │ │ └── variant_7: struct #33 +│ │ │ ├── [endsWith]: optional #23 +│ │ │ │ └── item: string #22 +│ │ │ └── [startsWith]: optional #23 +│ │ │ └── item: string #22 +│ │ └── variant_1: struct #35 +│ │ └── [not]: union '_string_filter' #34 +│ │ ├── variant_0: string #22 +│ │ ├── variant_1: struct #25 +│ │ │ └── [equals]: string #22 +│ │ ├── variant_2: struct #26 +│ │ │ └── [not]: string #22 +│ │ ├── variant_3: struct #27 +│ │ │ └── [in]: list #24 +│ │ │ └── item: string #22 +│ │ ├── variant_4: struct #28 +│ │ │ └── [notIn]: list #24 +│ │ │ └── item: string #22 +│ │ ├── variant_5: struct #31 +│ │ │ ├── [contains]: string #22 +│ │ │ └── [mode]: optional #30 +│ │ │ └── item: string #29 enum{ '"insensitive"' } +│ │ ├── variant_6: struct #32 +│ │ │ └── [search]: string #22 +│ │ └── variant_7: struct #33 +│ │ ├── [endsWith]: optional #23 +│ │ │ └── item: string #22 +│ │ └── [startsWith]: optional #23 +│ │ └── item: string #22 +│ └── [posts]: optional #70 +│ └── item: union #69 +│ ├── variant_0: struct #64 +│ │ └── [every]: optional '_63_PostWhere?' #63 +│ │ └── item: &PostWhere #62 +│ ├── variant_1: struct #66 +│ │ └── [some]: optional '_65_PostWhere?' #65 +│ │ └── item: &PostWhere #62 +│ └── variant_2: struct #68 +│ └── [none]: optional '_67_PostWhere?' #67 +│ └── item: &PostWhere #62 +├── [id]: optional '_58__integer_filter_c?' #58 +│ └── item: optional '_integer_filter_c' #20 +│ └── item: union #19 +│ ├── variant_0: either '_integer_filter' #17 +│ │ ├── variant_0: integer #9 +│ │ ├── variant_1: struct #12 +│ │ │ └── [equals]: integer #9 +│ │ ├── variant_2: struct #13 +│ │ │ └── [not]: integer #9 +│ │ ├── variant_3: struct #14 +│ │ │ ├── [gt]: optional #10 +│ │ │ │ └── item: integer #9 +│ │ │ ├── [gte]: optional #10 +│ │ │ │ └── item: integer #9 +│ │ │ ├── [lt]: optional #10 +│ │ │ │ └── item: integer #9 +│ │ │ └── [lte]: optional #10 +│ │ │ └── item: integer #9 +│ │ ├── variant_4: struct #15 +│ │ │ └── [in]: list #11 +│ │ │ └── item: integer #9 +│ │ └── variant_5: struct #16 +│ │ └── [notIn]: list #11 +│ │ └── item: integer #9 +│ └── variant_1: struct #18 +│ └── [not]: either '_integer_filter' #17 +│ ├── variant_0: integer #9 +│ ├── variant_1: struct #12 +│ │ └── [equals]: integer #9 +│ ├── variant_2: struct #13 +│ │ └── [not]: integer #9 +│ ├── variant_3: struct #14 +│ │ ├── [gt]: optional #10 +│ │ │ └── item: integer #9 +│ │ ├── [gte]: optional #10 +│ │ │ └── item: integer #9 +│ │ ├── [lt]: optional #10 +│ │ │ └── item: integer #9 +│ │ └── [lte]: optional #10 +│ │ └── item: integer #9 +│ ├── variant_4: struct #15 +│ │ └── [in]: list #11 +│ │ └── item: integer #9 +│ └── variant_5: struct #16 +│ └── [notIn]: list #11 +│ └── item: integer #9 +└── [title]: optional '_59__string_filter_c?' #59 + └── item: optional '_string_filter_c' #37 + └── item: union #36 + ├── variant_0: union '_string_filter' #34 + │ ├── variant_0: string #22 + │ ├── variant_1: struct #25 + │ │ └── [equals]: string #22 + │ ├── variant_2: struct #26 + │ │ └── [not]: string #22 + │ ├── variant_3: struct #27 + │ │ └── [in]: list #24 + │ │ └── item: string #22 + │ ├── variant_4: struct #28 + │ │ └── [notIn]: list #24 + │ │ └── item: string #22 + │ ├── variant_5: struct #31 + │ │ ├── [contains]: string #22 + │ │ └── [mode]: optional #30 + │ │ └── item: string #29 enum{ '"insensitive"' } + │ ├── variant_6: struct #32 + │ │ └── [search]: string #22 + │ └── variant_7: struct #33 + │ ├── [endsWith]: optional #23 + │ │ └── item: string #22 + │ └── [startsWith]: optional #23 + │ └── item: string #22 + └── variant_1: struct #35 + └── [not]: union '_string_filter' #34 + ├── variant_0: string #22 + ├── variant_1: struct #25 + │ └── [equals]: string #22 + ├── variant_2: struct #26 + │ └── [not]: string #22 + ├── variant_3: struct #27 + │ └── [in]: list #24 + │ └── item: string #22 + ├── variant_4: struct #28 + │ └── [notIn]: list #24 + │ └── item: string #22 + ├── variant_5: struct #31 + │ ├── [contains]: string #22 + │ └── [mode]: optional #30 + │ └── item: string #29 enum{ '"insensitive"' } + ├── variant_6: struct #32 + │ └── [search]: string #22 + └── variant_7: struct #33 + ├── [endsWith]: optional #23 + │ └── item: string #22 + └── [startsWith]: optional #23 + └── item: string #22 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__query_where_expr__tests__User__QueryWhereExpr.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__query_where_expr__tests__User__QueryWhereExpr.snap index 56ad04346..8f3d5a6fd 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__query_where_expr__tests__User__QueryWhereExpr.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__query_where_expr__tests__User__QueryWhereExpr.snap @@ -3,413 +3,413 @@ source: typegraph/core/src/runtimes/prisma/type_generation/query_where_expr.rs expression: "tree::print(user_where_expr)" --- root: struct 'QueryUserWhereInput' #57 -├─ [id]: optional '_21__integer_filter_c?' #21 -│ └─ item: optional '_integer_filter_c' #20 -│ └─ item: union #19 -│ ├─ variant_0: either '_integer_filter' #17 -│ │ ├─ variant_0: integer #9 -│ │ ├─ variant_1: struct #12 -│ │ │ └─ [equals]: integer #9 -│ │ ├─ variant_2: struct #13 -│ │ │ └─ [not]: integer #9 -│ │ ├─ variant_3: struct #14 -│ │ │ ├─ [lt]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ [gt]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ [lte]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ └─ [gte]: optional #10 -│ │ │ └─ item: integer #9 -│ │ ├─ variant_4: struct #15 -│ │ │ └─ [in]: list #11 -│ │ │ └─ item: integer #9 -│ │ └─ variant_5: struct #16 -│ │ └─ [notIn]: list #11 -│ │ └─ item: integer #9 -│ └─ variant_1: struct #18 -│ └─ [not]: either '_integer_filter' #17 -│ ├─ variant_0: integer #9 -│ ├─ variant_1: struct #12 -│ │ └─ [equals]: integer #9 -│ ├─ variant_2: struct #13 -│ │ └─ [not]: integer #9 -│ ├─ variant_3: struct #14 -│ │ ├─ [lt]: optional #10 -│ │ │ └─ item: integer #9 -│ │ ├─ [gt]: optional #10 -│ │ │ └─ item: integer #9 -│ │ ├─ [lte]: optional #10 -│ │ │ └─ item: integer #9 -│ │ └─ [gte]: optional #10 -│ │ └─ item: integer #9 -│ ├─ variant_4: struct #15 -│ │ └─ [in]: list #11 -│ │ └─ item: integer #9 -│ └─ variant_5: struct #16 -│ └─ [notIn]: list #11 -│ └─ item: integer #9 -├─ [name]: optional '_38__string_filter_c?' #38 -│ └─ item: optional '_string_filter_c' #37 -│ └─ item: union #36 -│ ├─ variant_0: union '_string_filter' #34 -│ │ ├─ variant_0: string #22 -│ │ ├─ variant_1: struct #25 -│ │ │ └─ [equals]: string #22 -│ │ ├─ variant_2: struct #26 -│ │ │ └─ [not]: string #22 -│ │ ├─ variant_3: struct #27 -│ │ │ └─ [in]: list #24 -│ │ │ └─ item: string #22 -│ │ ├─ variant_4: struct #28 -│ │ │ └─ [notIn]: list #24 -│ │ │ └─ item: string #22 -│ │ ├─ variant_5: struct #31 -│ │ │ ├─ [contains]: string #22 -│ │ │ └─ [mode]: optional #30 -│ │ │ └─ item: string #29 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #32 -│ │ │ └─ [search]: string #22 -│ │ └─ variant_7: struct #33 -│ │ ├─ [startsWith]: optional #23 -│ │ │ └─ item: string #22 -│ │ └─ [endsWith]: optional #23 -│ │ └─ item: string #22 -│ └─ variant_1: struct #35 -│ └─ [not]: union '_string_filter' #34 -│ ├─ variant_0: string #22 -│ ├─ variant_1: struct #25 -│ │ └─ [equals]: string #22 -│ ├─ variant_2: struct #26 -│ │ └─ [not]: string #22 -│ ├─ variant_3: struct #27 -│ │ └─ [in]: list #24 -│ │ └─ item: string #22 -│ ├─ variant_4: struct #28 -│ │ └─ [notIn]: list #24 -│ │ └─ item: string #22 -│ ├─ variant_5: struct #31 -│ │ ├─ [contains]: string #22 -│ │ └─ [mode]: optional #30 -│ │ └─ item: string #29 enum{ '"insensitive"' } -│ ├─ variant_6: struct #32 -│ │ └─ [search]: string #22 -│ └─ variant_7: struct #33 -│ ├─ [startsWith]: optional #23 -│ │ └─ item: string #22 -│ └─ [endsWith]: optional #23 -│ └─ item: string #22 -├─ [posts]: optional #51 -│ └─ item: union #50 -│ ├─ variant_0: struct #45 -│ │ └─ [every]: optional '_44_PostWhere__skip_4_UserWhere?' #44 -│ │ └─ item: struct 'PostWhere__skip_4_UserWhere' #43 -│ │ ├─ [id]: optional '_39__integer_filter_c?' #39 -│ │ │ └─ item: optional '_integer_filter_c' #20 -│ │ │ └─ item: union #19 -│ │ │ ├─ variant_0: either '_integer_filter' #17 -│ │ │ │ ├─ variant_0: integer #9 -│ │ │ │ ├─ variant_1: struct #12 -│ │ │ │ │ └─ [equals]: integer #9 -│ │ │ │ ├─ variant_2: struct #13 -│ │ │ │ │ └─ [not]: integer #9 -│ │ │ │ ├─ variant_3: struct #14 -│ │ │ │ │ ├─ [lt]: optional #10 -│ │ │ │ │ │ └─ item: integer #9 -│ │ │ │ │ ├─ [gt]: optional #10 -│ │ │ │ │ │ └─ item: integer #9 -│ │ │ │ │ ├─ [lte]: optional #10 -│ │ │ │ │ │ └─ item: integer #9 -│ │ │ │ │ └─ [gte]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ ├─ variant_4: struct #15 -│ │ │ │ │ └─ [in]: list #11 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ └─ variant_5: struct #16 -│ │ │ │ └─ [notIn]: list #11 -│ │ │ │ └─ item: integer #9 -│ │ │ └─ variant_1: struct #18 -│ │ │ └─ [not]: either '_integer_filter' #17 -│ │ │ ├─ variant_0: integer #9 -│ │ │ ├─ variant_1: struct #12 -│ │ │ │ └─ [equals]: integer #9 -│ │ │ ├─ variant_2: struct #13 -│ │ │ │ └─ [not]: integer #9 -│ │ │ ├─ variant_3: struct #14 -│ │ │ │ ├─ [lt]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ ├─ [gt]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ ├─ [lte]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ └─ [gte]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ variant_4: struct #15 -│ │ │ │ └─ [in]: list #11 -│ │ │ │ └─ item: integer #9 -│ │ │ └─ variant_5: struct #16 -│ │ │ └─ [notIn]: list #11 -│ │ │ └─ item: integer #9 -│ │ ├─ [title]: optional '_40__string_filter_c?' #40 -│ │ │ └─ item: optional '_string_filter_c' #37 -│ │ │ └─ item: union #36 -│ │ │ ├─ variant_0: union '_string_filter' #34 -│ │ │ │ ├─ variant_0: string #22 -│ │ │ │ ├─ variant_1: struct #25 -│ │ │ │ │ └─ [equals]: string #22 -│ │ │ │ ├─ variant_2: struct #26 -│ │ │ │ │ └─ [not]: string #22 -│ │ │ │ ├─ variant_3: struct #27 -│ │ │ │ │ └─ [in]: list #24 -│ │ │ │ │ └─ item: string #22 -│ │ │ │ ├─ variant_4: struct #28 -│ │ │ │ │ └─ [notIn]: list #24 -│ │ │ │ │ └─ item: string #22 -│ │ │ │ ├─ variant_5: struct #31 -│ │ │ │ │ ├─ [contains]: string #22 -│ │ │ │ │ └─ [mode]: optional #30 -│ │ │ │ │ └─ item: string #29 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #32 -│ │ │ │ │ └─ [search]: string #22 -│ │ │ │ └─ variant_7: struct #33 -│ │ │ │ ├─ [startsWith]: optional #23 -│ │ │ │ │ └─ item: string #22 -│ │ │ │ └─ [endsWith]: optional #23 -│ │ │ │ └─ item: string #22 -│ │ │ └─ variant_1: struct #35 -│ │ │ └─ [not]: union '_string_filter' #34 -│ │ │ ├─ variant_0: string #22 -│ │ │ ├─ variant_1: struct #25 -│ │ │ │ └─ [equals]: string #22 -│ │ │ ├─ variant_2: struct #26 -│ │ │ │ └─ [not]: string #22 -│ │ │ ├─ variant_3: struct #27 -│ │ │ │ └─ [in]: list #24 -│ │ │ │ └─ item: string #22 -│ │ │ ├─ variant_4: struct #28 -│ │ │ │ └─ [notIn]: list #24 -│ │ │ │ └─ item: string #22 -│ │ │ ├─ variant_5: struct #31 -│ │ │ │ ├─ [contains]: string #22 -│ │ │ │ └─ [mode]: optional #30 -│ │ │ │ └─ item: string #29 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #32 -│ │ │ │ └─ [search]: string #22 -│ │ │ └─ variant_7: struct #33 -│ │ │ ├─ [startsWith]: optional #23 -│ │ │ │ └─ item: string #22 -│ │ │ └─ [endsWith]: optional #23 -│ │ │ └─ item: string #22 -│ │ └─ [author]: optional '_42_UserWhere?' #42 -│ │ └─ item: &UserWhere #41 -│ ├─ variant_1: struct #47 -│ │ └─ [some]: optional '_46_PostWhere__skip_4_UserWhere?' #46 -│ │ └─ item: struct 'PostWhere__skip_4_UserWhere' #43 -│ │ ├─ [id]: optional '_39__integer_filter_c?' #39 -│ │ │ └─ item: optional '_integer_filter_c' #20 -│ │ │ └─ item: union #19 -│ │ │ ├─ variant_0: either '_integer_filter' #17 -│ │ │ │ ├─ variant_0: integer #9 -│ │ │ │ ├─ variant_1: struct #12 -│ │ │ │ │ └─ [equals]: integer #9 -│ │ │ │ ├─ variant_2: struct #13 -│ │ │ │ │ └─ [not]: integer #9 -│ │ │ │ ├─ variant_3: struct #14 -│ │ │ │ │ ├─ [lt]: optional #10 -│ │ │ │ │ │ └─ item: integer #9 -│ │ │ │ │ ├─ [gt]: optional #10 -│ │ │ │ │ │ └─ item: integer #9 -│ │ │ │ │ ├─ [lte]: optional #10 -│ │ │ │ │ │ └─ item: integer #9 -│ │ │ │ │ └─ [gte]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ ├─ variant_4: struct #15 -│ │ │ │ │ └─ [in]: list #11 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ └─ variant_5: struct #16 -│ │ │ │ └─ [notIn]: list #11 -│ │ │ │ └─ item: integer #9 -│ │ │ └─ variant_1: struct #18 -│ │ │ └─ [not]: either '_integer_filter' #17 -│ │ │ ├─ variant_0: integer #9 -│ │ │ ├─ variant_1: struct #12 -│ │ │ │ └─ [equals]: integer #9 -│ │ │ ├─ variant_2: struct #13 -│ │ │ │ └─ [not]: integer #9 -│ │ │ ├─ variant_3: struct #14 -│ │ │ │ ├─ [lt]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ ├─ [gt]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ ├─ [lte]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ └─ [gte]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ variant_4: struct #15 -│ │ │ │ └─ [in]: list #11 -│ │ │ │ └─ item: integer #9 -│ │ │ └─ variant_5: struct #16 -│ │ │ └─ [notIn]: list #11 -│ │ │ └─ item: integer #9 -│ │ ├─ [title]: optional '_40__string_filter_c?' #40 -│ │ │ └─ item: optional '_string_filter_c' #37 -│ │ │ └─ item: union #36 -│ │ │ ├─ variant_0: union '_string_filter' #34 -│ │ │ │ ├─ variant_0: string #22 -│ │ │ │ ├─ variant_1: struct #25 -│ │ │ │ │ └─ [equals]: string #22 -│ │ │ │ ├─ variant_2: struct #26 -│ │ │ │ │ └─ [not]: string #22 -│ │ │ │ ├─ variant_3: struct #27 -│ │ │ │ │ └─ [in]: list #24 -│ │ │ │ │ └─ item: string #22 -│ │ │ │ ├─ variant_4: struct #28 -│ │ │ │ │ └─ [notIn]: list #24 -│ │ │ │ │ └─ item: string #22 -│ │ │ │ ├─ variant_5: struct #31 -│ │ │ │ │ ├─ [contains]: string #22 -│ │ │ │ │ └─ [mode]: optional #30 -│ │ │ │ │ └─ item: string #29 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #32 -│ │ │ │ │ └─ [search]: string #22 -│ │ │ │ └─ variant_7: struct #33 -│ │ │ │ ├─ [startsWith]: optional #23 -│ │ │ │ │ └─ item: string #22 -│ │ │ │ └─ [endsWith]: optional #23 -│ │ │ │ └─ item: string #22 -│ │ │ └─ variant_1: struct #35 -│ │ │ └─ [not]: union '_string_filter' #34 -│ │ │ ├─ variant_0: string #22 -│ │ │ ├─ variant_1: struct #25 -│ │ │ │ └─ [equals]: string #22 -│ │ │ ├─ variant_2: struct #26 -│ │ │ │ └─ [not]: string #22 -│ │ │ ├─ variant_3: struct #27 -│ │ │ │ └─ [in]: list #24 -│ │ │ │ └─ item: string #22 -│ │ │ ├─ variant_4: struct #28 -│ │ │ │ └─ [notIn]: list #24 -│ │ │ │ └─ item: string #22 -│ │ │ ├─ variant_5: struct #31 -│ │ │ │ ├─ [contains]: string #22 -│ │ │ │ └─ [mode]: optional #30 -│ │ │ │ └─ item: string #29 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #32 -│ │ │ │ └─ [search]: string #22 -│ │ │ └─ variant_7: struct #33 -│ │ │ ├─ [startsWith]: optional #23 -│ │ │ │ └─ item: string #22 -│ │ │ └─ [endsWith]: optional #23 -│ │ │ └─ item: string #22 -│ │ └─ [author]: optional '_42_UserWhere?' #42 -│ │ └─ item: &UserWhere #41 -│ └─ variant_2: struct #49 -│ └─ [none]: optional '_48_PostWhere__skip_4_UserWhere?' #48 -│ └─ item: struct 'PostWhere__skip_4_UserWhere' #43 -│ ├─ [id]: optional '_39__integer_filter_c?' #39 -│ │ └─ item: optional '_integer_filter_c' #20 -│ │ └─ item: union #19 -│ │ ├─ variant_0: either '_integer_filter' #17 -│ │ │ ├─ variant_0: integer #9 -│ │ │ ├─ variant_1: struct #12 -│ │ │ │ └─ [equals]: integer #9 -│ │ │ ├─ variant_2: struct #13 -│ │ │ │ └─ [not]: integer #9 -│ │ │ ├─ variant_3: struct #14 -│ │ │ │ ├─ [lt]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ ├─ [gt]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ ├─ [lte]: optional #10 -│ │ │ │ │ └─ item: integer #9 -│ │ │ │ └─ [gte]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ variant_4: struct #15 -│ │ │ │ └─ [in]: list #11 -│ │ │ │ └─ item: integer #9 -│ │ │ └─ variant_5: struct #16 -│ │ │ └─ [notIn]: list #11 -│ │ │ └─ item: integer #9 -│ │ └─ variant_1: struct #18 -│ │ └─ [not]: either '_integer_filter' #17 -│ │ ├─ variant_0: integer #9 -│ │ ├─ variant_1: struct #12 -│ │ │ └─ [equals]: integer #9 -│ │ ├─ variant_2: struct #13 -│ │ │ └─ [not]: integer #9 -│ │ ├─ variant_3: struct #14 -│ │ │ ├─ [lt]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ [gt]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ ├─ [lte]: optional #10 -│ │ │ │ └─ item: integer #9 -│ │ │ └─ [gte]: optional #10 -│ │ │ └─ item: integer #9 -│ │ ├─ variant_4: struct #15 -│ │ │ └─ [in]: list #11 -│ │ │ └─ item: integer #9 -│ │ └─ variant_5: struct #16 -│ │ └─ [notIn]: list #11 -│ │ └─ item: integer #9 -│ ├─ [title]: optional '_40__string_filter_c?' #40 -│ │ └─ item: optional '_string_filter_c' #37 -│ │ └─ item: union #36 -│ │ ├─ variant_0: union '_string_filter' #34 -│ │ │ ├─ variant_0: string #22 -│ │ │ ├─ variant_1: struct #25 -│ │ │ │ └─ [equals]: string #22 -│ │ │ ├─ variant_2: struct #26 -│ │ │ │ └─ [not]: string #22 -│ │ │ ├─ variant_3: struct #27 -│ │ │ │ └─ [in]: list #24 -│ │ │ │ └─ item: string #22 -│ │ │ ├─ variant_4: struct #28 -│ │ │ │ └─ [notIn]: list #24 -│ │ │ │ └─ item: string #22 -│ │ │ ├─ variant_5: struct #31 -│ │ │ │ ├─ [contains]: string #22 -│ │ │ │ └─ [mode]: optional #30 -│ │ │ │ └─ item: string #29 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #32 -│ │ │ │ └─ [search]: string #22 -│ │ │ └─ variant_7: struct #33 -│ │ │ ├─ [startsWith]: optional #23 -│ │ │ │ └─ item: string #22 -│ │ │ └─ [endsWith]: optional #23 -│ │ │ └─ item: string #22 -│ │ └─ variant_1: struct #35 -│ │ └─ [not]: union '_string_filter' #34 -│ │ ├─ variant_0: string #22 -│ │ ├─ variant_1: struct #25 -│ │ │ └─ [equals]: string #22 -│ │ ├─ variant_2: struct #26 -│ │ │ └─ [not]: string #22 -│ │ ├─ variant_3: struct #27 -│ │ │ └─ [in]: list #24 -│ │ │ └─ item: string #22 -│ │ ├─ variant_4: struct #28 -│ │ │ └─ [notIn]: list #24 -│ │ │ └─ item: string #22 -│ │ ├─ variant_5: struct #31 -│ │ │ ├─ [contains]: string #22 -│ │ │ └─ [mode]: optional #30 -│ │ │ └─ item: string #29 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #32 -│ │ │ └─ [search]: string #22 -│ │ └─ variant_7: struct #33 -│ │ ├─ [startsWith]: optional #23 -│ │ │ └─ item: string #22 -│ │ └─ [endsWith]: optional #23 -│ │ └─ item: string #22 -│ └─ [author]: optional '_42_UserWhere?' #42 -│ └─ item: &UserWhere #41 -├─ [AND]: optional '_55__54_QueryUserWhereInput[]?' #55 -│ └─ item: list '_54_QueryUserWhereInput[]' #54 -│ └─ item: &QueryUserWhereInput #53 -├─ [OR]: optional '_55__54_QueryUserWhereInput[]?' #55 -│ └─ item: list '_54_QueryUserWhereInput[]' #54 -│ └─ item: &QueryUserWhereInput #53 -└─ [NOT]: optional '_56_QueryUserWhereInput?' #56 - └─ item: &QueryUserWhereInput #53 +├── [AND]: optional '_55__54_QueryUserWhereInput[]?' #55 +│ └── item: list '_54_QueryUserWhereInput[]' #54 +│ └── item: &QueryUserWhereInput #53 +├── [NOT]: optional '_56_QueryUserWhereInput?' #56 +│ └── item: &QueryUserWhereInput #53 +├── [OR]: optional '_55__54_QueryUserWhereInput[]?' #55 +│ └── item: list '_54_QueryUserWhereInput[]' #54 +│ └── item: &QueryUserWhereInput #53 +├── [id]: optional '_21__integer_filter_c?' #21 +│ └── item: optional '_integer_filter_c' #20 +│ └── item: union #19 +│ ├── variant_0: either '_integer_filter' #17 +│ │ ├── variant_0: integer #9 +│ │ ├── variant_1: struct #12 +│ │ │ └── [equals]: integer #9 +│ │ ├── variant_2: struct #13 +│ │ │ └── [not]: integer #9 +│ │ ├── variant_3: struct #14 +│ │ │ ├── [gt]: optional #10 +│ │ │ │ └── item: integer #9 +│ │ │ ├── [gte]: optional #10 +│ │ │ │ └── item: integer #9 +│ │ │ ├── [lt]: optional #10 +│ │ │ │ └── item: integer #9 +│ │ │ └── [lte]: optional #10 +│ │ │ └── item: integer #9 +│ │ ├── variant_4: struct #15 +│ │ │ └── [in]: list #11 +│ │ │ └── item: integer #9 +│ │ └── variant_5: struct #16 +│ │ └── [notIn]: list #11 +│ │ └── item: integer #9 +│ └── variant_1: struct #18 +│ └── [not]: either '_integer_filter' #17 +│ ├── variant_0: integer #9 +│ ├── variant_1: struct #12 +│ │ └── [equals]: integer #9 +│ ├── variant_2: struct #13 +│ │ └── [not]: integer #9 +│ ├── variant_3: struct #14 +│ │ ├── [gt]: optional #10 +│ │ │ └── item: integer #9 +│ │ ├── [gte]: optional #10 +│ │ │ └── item: integer #9 +│ │ ├── [lt]: optional #10 +│ │ │ └── item: integer #9 +│ │ └── [lte]: optional #10 +│ │ └── item: integer #9 +│ ├── variant_4: struct #15 +│ │ └── [in]: list #11 +│ │ └── item: integer #9 +│ └── variant_5: struct #16 +│ └── [notIn]: list #11 +│ └── item: integer #9 +├── [name]: optional '_38__string_filter_c?' #38 +│ └── item: optional '_string_filter_c' #37 +│ └── item: union #36 +│ ├── variant_0: union '_string_filter' #34 +│ │ ├── variant_0: string #22 +│ │ ├── variant_1: struct #25 +│ │ │ └── [equals]: string #22 +│ │ ├── variant_2: struct #26 +│ │ │ └── [not]: string #22 +│ │ ├── variant_3: struct #27 +│ │ │ └── [in]: list #24 +│ │ │ └── item: string #22 +│ │ ├── variant_4: struct #28 +│ │ │ └── [notIn]: list #24 +│ │ │ └── item: string #22 +│ │ ├── variant_5: struct #31 +│ │ │ ├── [contains]: string #22 +│ │ │ └── [mode]: optional #30 +│ │ │ └── item: string #29 enum{ '"insensitive"' } +│ │ ├── variant_6: struct #32 +│ │ │ └── [search]: string #22 +│ │ └── variant_7: struct #33 +│ │ ├── [endsWith]: optional #23 +│ │ │ └── item: string #22 +│ │ └── [startsWith]: optional #23 +│ │ └── item: string #22 +│ └── variant_1: struct #35 +│ └── [not]: union '_string_filter' #34 +│ ├── variant_0: string #22 +│ ├── variant_1: struct #25 +│ │ └── [equals]: string #22 +│ ├── variant_2: struct #26 +│ │ └── [not]: string #22 +│ ├── variant_3: struct #27 +│ │ └── [in]: list #24 +│ │ └── item: string #22 +│ ├── variant_4: struct #28 +│ │ └── [notIn]: list #24 +│ │ └── item: string #22 +│ ├── variant_5: struct #31 +│ │ ├── [contains]: string #22 +│ │ └── [mode]: optional #30 +│ │ └── item: string #29 enum{ '"insensitive"' } +│ ├── variant_6: struct #32 +│ │ └── [search]: string #22 +│ └── variant_7: struct #33 +│ ├── [endsWith]: optional #23 +│ │ └── item: string #22 +│ └── [startsWith]: optional #23 +│ └── item: string #22 +└── [posts]: optional #51 + └── item: union #50 + ├── variant_0: struct #45 + │ └── [every]: optional '_44_PostWhere__skip_4_UserWhere?' #44 + │ └── item: struct 'PostWhere__skip_4_UserWhere' #43 + │ ├── [author]: optional '_42_UserWhere?' #42 + │ │ └── item: &UserWhere #41 + │ ├── [id]: optional '_39__integer_filter_c?' #39 + │ │ └── item: optional '_integer_filter_c' #20 + │ │ └── item: union #19 + │ │ ├── variant_0: either '_integer_filter' #17 + │ │ │ ├── variant_0: integer #9 + │ │ │ ├── variant_1: struct #12 + │ │ │ │ └── [equals]: integer #9 + │ │ │ ├── variant_2: struct #13 + │ │ │ │ └── [not]: integer #9 + │ │ │ ├── variant_3: struct #14 + │ │ │ │ ├── [gt]: optional #10 + │ │ │ │ │ └── item: integer #9 + │ │ │ │ ├── [gte]: optional #10 + │ │ │ │ │ └── item: integer #9 + │ │ │ │ ├── [lt]: optional #10 + │ │ │ │ │ └── item: integer #9 + │ │ │ │ └── [lte]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ ├── variant_4: struct #15 + │ │ │ │ └── [in]: list #11 + │ │ │ │ └── item: integer #9 + │ │ │ └── variant_5: struct #16 + │ │ │ └── [notIn]: list #11 + │ │ │ └── item: integer #9 + │ │ └── variant_1: struct #18 + │ │ └── [not]: either '_integer_filter' #17 + │ │ ├── variant_0: integer #9 + │ │ ├── variant_1: struct #12 + │ │ │ └── [equals]: integer #9 + │ │ ├── variant_2: struct #13 + │ │ │ └── [not]: integer #9 + │ │ ├── variant_3: struct #14 + │ │ │ ├── [gt]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ ├── [gte]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ ├── [lt]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ └── [lte]: optional #10 + │ │ │ └── item: integer #9 + │ │ ├── variant_4: struct #15 + │ │ │ └── [in]: list #11 + │ │ │ └── item: integer #9 + │ │ └── variant_5: struct #16 + │ │ └── [notIn]: list #11 + │ │ └── item: integer #9 + │ └── [title]: optional '_40__string_filter_c?' #40 + │ └── item: optional '_string_filter_c' #37 + │ └── item: union #36 + │ ├── variant_0: union '_string_filter' #34 + │ │ ├── variant_0: string #22 + │ │ ├── variant_1: struct #25 + │ │ │ └── [equals]: string #22 + │ │ ├── variant_2: struct #26 + │ │ │ └── [not]: string #22 + │ │ ├── variant_3: struct #27 + │ │ │ └── [in]: list #24 + │ │ │ └── item: string #22 + │ │ ├── variant_4: struct #28 + │ │ │ └── [notIn]: list #24 + │ │ │ └── item: string #22 + │ │ ├── variant_5: struct #31 + │ │ │ ├── [contains]: string #22 + │ │ │ └── [mode]: optional #30 + │ │ │ └── item: string #29 enum{ '"insensitive"' } + │ │ ├── variant_6: struct #32 + │ │ │ └── [search]: string #22 + │ │ └── variant_7: struct #33 + │ │ ├── [endsWith]: optional #23 + │ │ │ └── item: string #22 + │ │ └── [startsWith]: optional #23 + │ │ └── item: string #22 + │ └── variant_1: struct #35 + │ └── [not]: union '_string_filter' #34 + │ ├── variant_0: string #22 + │ ├── variant_1: struct #25 + │ │ └── [equals]: string #22 + │ ├── variant_2: struct #26 + │ │ └── [not]: string #22 + │ ├── variant_3: struct #27 + │ │ └── [in]: list #24 + │ │ └── item: string #22 + │ ├── variant_4: struct #28 + │ │ └── [notIn]: list #24 + │ │ └── item: string #22 + │ ├── variant_5: struct #31 + │ │ ├── [contains]: string #22 + │ │ └── [mode]: optional #30 + │ │ └── item: string #29 enum{ '"insensitive"' } + │ ├── variant_6: struct #32 + │ │ └── [search]: string #22 + │ └── variant_7: struct #33 + │ ├── [endsWith]: optional #23 + │ │ └── item: string #22 + │ └── [startsWith]: optional #23 + │ └── item: string #22 + ├── variant_1: struct #47 + │ └── [some]: optional '_46_PostWhere__skip_4_UserWhere?' #46 + │ └── item: struct 'PostWhere__skip_4_UserWhere' #43 + │ ├── [author]: optional '_42_UserWhere?' #42 + │ │ └── item: &UserWhere #41 + │ ├── [id]: optional '_39__integer_filter_c?' #39 + │ │ └── item: optional '_integer_filter_c' #20 + │ │ └── item: union #19 + │ │ ├── variant_0: either '_integer_filter' #17 + │ │ │ ├── variant_0: integer #9 + │ │ │ ├── variant_1: struct #12 + │ │ │ │ └── [equals]: integer #9 + │ │ │ ├── variant_2: struct #13 + │ │ │ │ └── [not]: integer #9 + │ │ │ ├── variant_3: struct #14 + │ │ │ │ ├── [gt]: optional #10 + │ │ │ │ │ └── item: integer #9 + │ │ │ │ ├── [gte]: optional #10 + │ │ │ │ │ └── item: integer #9 + │ │ │ │ ├── [lt]: optional #10 + │ │ │ │ │ └── item: integer #9 + │ │ │ │ └── [lte]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ ├── variant_4: struct #15 + │ │ │ │ └── [in]: list #11 + │ │ │ │ └── item: integer #9 + │ │ │ └── variant_5: struct #16 + │ │ │ └── [notIn]: list #11 + │ │ │ └── item: integer #9 + │ │ └── variant_1: struct #18 + │ │ └── [not]: either '_integer_filter' #17 + │ │ ├── variant_0: integer #9 + │ │ ├── variant_1: struct #12 + │ │ │ └── [equals]: integer #9 + │ │ ├── variant_2: struct #13 + │ │ │ └── [not]: integer #9 + │ │ ├── variant_3: struct #14 + │ │ │ ├── [gt]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ ├── [gte]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ ├── [lt]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ └── [lte]: optional #10 + │ │ │ └── item: integer #9 + │ │ ├── variant_4: struct #15 + │ │ │ └── [in]: list #11 + │ │ │ └── item: integer #9 + │ │ └── variant_5: struct #16 + │ │ └── [notIn]: list #11 + │ │ └── item: integer #9 + │ └── [title]: optional '_40__string_filter_c?' #40 + │ └── item: optional '_string_filter_c' #37 + │ └── item: union #36 + │ ├── variant_0: union '_string_filter' #34 + │ │ ├── variant_0: string #22 + │ │ ├── variant_1: struct #25 + │ │ │ └── [equals]: string #22 + │ │ ├── variant_2: struct #26 + │ │ │ └── [not]: string #22 + │ │ ├── variant_3: struct #27 + │ │ │ └── [in]: list #24 + │ │ │ └── item: string #22 + │ │ ├── variant_4: struct #28 + │ │ │ └── [notIn]: list #24 + │ │ │ └── item: string #22 + │ │ ├── variant_5: struct #31 + │ │ │ ├── [contains]: string #22 + │ │ │ └── [mode]: optional #30 + │ │ │ └── item: string #29 enum{ '"insensitive"' } + │ │ ├── variant_6: struct #32 + │ │ │ └── [search]: string #22 + │ │ └── variant_7: struct #33 + │ │ ├── [endsWith]: optional #23 + │ │ │ └── item: string #22 + │ │ └── [startsWith]: optional #23 + │ │ └── item: string #22 + │ └── variant_1: struct #35 + │ └── [not]: union '_string_filter' #34 + │ ├── variant_0: string #22 + │ ├── variant_1: struct #25 + │ │ └── [equals]: string #22 + │ ├── variant_2: struct #26 + │ │ └── [not]: string #22 + │ ├── variant_3: struct #27 + │ │ └── [in]: list #24 + │ │ └── item: string #22 + │ ├── variant_4: struct #28 + │ │ └── [notIn]: list #24 + │ │ └── item: string #22 + │ ├── variant_5: struct #31 + │ │ ├── [contains]: string #22 + │ │ └── [mode]: optional #30 + │ │ └── item: string #29 enum{ '"insensitive"' } + │ ├── variant_6: struct #32 + │ │ └── [search]: string #22 + │ └── variant_7: struct #33 + │ ├── [endsWith]: optional #23 + │ │ └── item: string #22 + │ └── [startsWith]: optional #23 + │ └── item: string #22 + └── variant_2: struct #49 + └── [none]: optional '_48_PostWhere__skip_4_UserWhere?' #48 + └── item: struct 'PostWhere__skip_4_UserWhere' #43 + ├── [author]: optional '_42_UserWhere?' #42 + │ └── item: &UserWhere #41 + ├── [id]: optional '_39__integer_filter_c?' #39 + │ └── item: optional '_integer_filter_c' #20 + │ └── item: union #19 + │ ├── variant_0: either '_integer_filter' #17 + │ │ ├── variant_0: integer #9 + │ │ ├── variant_1: struct #12 + │ │ │ └── [equals]: integer #9 + │ │ ├── variant_2: struct #13 + │ │ │ └── [not]: integer #9 + │ │ ├── variant_3: struct #14 + │ │ │ ├── [gt]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ ├── [gte]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ ├── [lt]: optional #10 + │ │ │ │ └── item: integer #9 + │ │ │ └── [lte]: optional #10 + │ │ │ └── item: integer #9 + │ │ ├── variant_4: struct #15 + │ │ │ └── [in]: list #11 + │ │ │ └── item: integer #9 + │ │ └── variant_5: struct #16 + │ │ └── [notIn]: list #11 + │ │ └── item: integer #9 + │ └── variant_1: struct #18 + │ └── [not]: either '_integer_filter' #17 + │ ├── variant_0: integer #9 + │ ├── variant_1: struct #12 + │ │ └── [equals]: integer #9 + │ ├── variant_2: struct #13 + │ │ └── [not]: integer #9 + │ ├── variant_3: struct #14 + │ │ ├── [gt]: optional #10 + │ │ │ └── item: integer #9 + │ │ ├── [gte]: optional #10 + │ │ │ └── item: integer #9 + │ │ ├── [lt]: optional #10 + │ │ │ └── item: integer #9 + │ │ └── [lte]: optional #10 + │ │ └── item: integer #9 + │ ├── variant_4: struct #15 + │ │ └── [in]: list #11 + │ │ └── item: integer #9 + │ └── variant_5: struct #16 + │ └── [notIn]: list #11 + │ └── item: integer #9 + └── [title]: optional '_40__string_filter_c?' #40 + └── item: optional '_string_filter_c' #37 + └── item: union #36 + ├── variant_0: union '_string_filter' #34 + │ ├── variant_0: string #22 + │ ├── variant_1: struct #25 + │ │ └── [equals]: string #22 + │ ├── variant_2: struct #26 + │ │ └── [not]: string #22 + │ ├── variant_3: struct #27 + │ │ └── [in]: list #24 + │ │ └── item: string #22 + │ ├── variant_4: struct #28 + │ │ └── [notIn]: list #24 + │ │ └── item: string #22 + │ ├── variant_5: struct #31 + │ │ ├── [contains]: string #22 + │ │ └── [mode]: optional #30 + │ │ └── item: string #29 enum{ '"insensitive"' } + │ ├── variant_6: struct #32 + │ │ └── [search]: string #22 + │ └── variant_7: struct #33 + │ ├── [endsWith]: optional #23 + │ │ └── item: string #22 + │ └── [startsWith]: optional #23 + │ └── item: string #22 + └── variant_1: struct #35 + └── [not]: union '_string_filter' #34 + ├── variant_0: string #22 + ├── variant_1: struct #25 + │ └── [equals]: string #22 + ├── variant_2: struct #26 + │ └── [not]: string #22 + ├── variant_3: struct #27 + │ └── [in]: list #24 + │ └── item: string #22 + ├── variant_4: struct #28 + │ └── [notIn]: list #24 + │ └── item: string #22 + ├── variant_5: struct #31 + │ ├── [contains]: string #22 + │ └── [mode]: optional #30 + │ └── item: string #29 enum{ '"insensitive"' } + ├── variant_6: struct #32 + │ └── [search]: string #22 + └── variant_7: struct #33 + ├── [endsWith]: optional #23 + │ └── item: string #22 + └── [startsWith]: optional #23 + └── item: string #22 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate Post out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate Post out.snap index c5b866843..7b3e2703d 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate Post out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate Post out.snap @@ -1,27 +1,27 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: struct #49 +├─ [_avg]: struct '_Post_NumberAgg_avg' #43 +│ └─ [id]: optional #42 +│ └─ item: float #41 ├─ [_count]: struct '_Post_AggrCount' #40 │ ├─ [_all]: optional #39 │ │ └─ item: integer #38 -│ ├─ [id]: optional #39 +│ ├─ [author]: optional #39 │ │ └─ item: integer #38 -│ ├─ [title]: optional #39 +│ ├─ [id]: optional #39 │ │ └─ item: integer #38 -│ └─ [author]: optional #39 +│ └─ [title]: optional #39 │ └─ item: integer #38 -├─ [_avg]: struct '_Post_NumberAgg_avg' #43 -│ └─ [id]: optional #42 -│ └─ item: float #41 -├─ [_sum]: struct '_Post_NumberAgg' #48 +├─ [_max]: struct '_Post_NumberAgg' #48 │ └─ [id]: optional #47 │ └─ item: integer #46 ├─ [_min]: struct '_Post_NumberAgg' #48 │ └─ [id]: optional #47 │ └─ item: integer #46 -└─ [_max]: struct '_Post_NumberAgg' #48 +└─ [_sum]: struct '_Post_NumberAgg' #48 └─ [id]: optional #47 └─ item: integer #46 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate Record out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate Record out.snap index 2570926df..c2d550c6b 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate Record out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate Record out.snap @@ -1,27 +1,27 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: "tree::PrintOptions::new().indent_size(3).print(out)" --- root: struct #16 +├─ [_avg]: struct '_Record_NumberAgg_avg' #10 +│ └─ [age]: optional #9 +│ └─ item: float #8 ├─ [_count]: struct '_Record_AggrCount' #7 │ ├─ [_all]: optional #6 │ │ └─ item: integer #5 -│ ├─ [id]: optional #6 +│ ├─ [age]: optional #6 │ │ └─ item: integer #5 -│ ├─ [name]: optional #6 +│ ├─ [id]: optional #6 │ │ └─ item: integer #5 -│ └─ [age]: optional #6 +│ └─ [name]: optional #6 │ └─ item: integer #5 -├─ [_avg]: struct '_Record_NumberAgg_avg' #10 -│ └─ [age]: optional #9 -│ └─ item: float #8 -├─ [_sum]: struct '_Record_NumberAgg' #15 +├─ [_max]: struct '_Record_NumberAgg' #15 │ └─ [age]: optional #14 │ └─ item: integer #13 ├─ [_min]: struct '_Record_NumberAgg' #15 │ └─ [age]: optional #14 │ └─ item: integer #13 -└─ [_max]: struct '_Record_NumberAgg' #15 +└─ [_sum]: struct '_Record_NumberAgg' #15 └─ [age]: optional #14 └─ item: integer #13 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate User out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate User out.snap index 82f656b38..08e5f5826 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate User out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__aggregate User out.snap @@ -1,8 +1,11 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: struct #37 +├─ [_avg]: struct '_User_NumberAgg_avg' #31 +│ └─ [id]: optional #30 +│ └─ item: float #29 ├─ [_count]: struct '_User_AggrCount' #28 │ ├─ [_all]: optional #27 │ │ └─ item: integer #26 @@ -12,16 +15,13 @@ root: struct #37 │ │ └─ item: integer #26 │ └─ [posts]: optional #27 │ └─ item: integer #26 -├─ [_avg]: struct '_User_NumberAgg_avg' #31 -│ └─ [id]: optional #30 -│ └─ item: float #29 -├─ [_sum]: struct '_User_NumberAgg' #36 +├─ [_max]: struct '_User_NumberAgg' #36 │ └─ [id]: optional #35 │ └─ item: integer #34 ├─ [_min]: struct '_User_NumberAgg' #36 │ └─ [id]: optional #35 │ └─ item: integer #34 -└─ [_max]: struct '_User_NumberAgg' #36 +└─ [_sum]: struct '_User_NumberAgg' #36 └─ [id]: optional #35 └─ item: integer #34 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Post inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Post inp.snap index d47d77b70..707413a35 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Post inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Post inp.snap @@ -1,826 +1,826 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #110 └─ [data]: list '_109__Post_CreateInput[]' #109 └─ item: struct '_Post_CreateInput' #108 + ├─ [author]: union #107 + │ ├─ variant_0: struct #104 + │ │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #86 + │ │ ├─ [id]: integer #11 + │ │ └─ [name]: string #12 + │ ├─ variant_1: struct #105 + │ │ └─ [connect]: struct 'UserWhere' #102 + │ │ ├─ [id]: optional '_87__integer_filter_c?' #87 + │ │ │ └─ item: optional '_integer_filter_c' #35 + │ │ │ └─ item: union #34 + │ │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_1: struct #33 + │ │ │ └─ [not]: either '_integer_filter' #32 + │ │ │ ├─ variant_0: integer #24 + │ │ │ ├─ variant_1: struct #27 + │ │ │ │ └─ [equals]: integer #24 + │ │ │ ├─ variant_2: struct #28 + │ │ │ │ └─ [not]: integer #24 + │ │ │ ├─ variant_3: struct #29 + │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ variant_4: struct #30 + │ │ │ │ └─ [in]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_5: struct #31 + │ │ │ └─ [notIn]: list #26 + │ │ │ └─ item: integer #24 + │ │ ├─ [name]: optional '_88__string_filter_c?' #88 + │ │ │ └─ item: optional '_string_filter_c' #52 + │ │ │ └─ item: union #51 + │ │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ │ ├─ variant_0: string #37 + │ │ │ │ ├─ variant_1: struct #40 + │ │ │ │ │ └─ [equals]: string #37 + │ │ │ │ ├─ variant_2: struct #41 + │ │ │ │ │ └─ [not]: string #37 + │ │ │ │ ├─ variant_3: struct #42 + │ │ │ │ │ └─ [in]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_4: struct #43 + │ │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_5: struct #46 + │ │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #47 + │ │ │ │ │ └─ [search]: string #37 + │ │ │ │ └─ variant_7: struct #48 + │ │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ └─ [startsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ variant_1: struct #50 + │ │ │ └─ [not]: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [posts]: optional #101 + │ │ └─ item: union #100 + │ │ ├─ variant_0: struct #95 + │ │ │ └─ [every]: optional '_94_PostWhere__skip_15_UserWhere?' #94 + │ │ │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 + │ │ │ ├─ [author]: optional '_92_UserWhere?' #92 + │ │ │ │ └─ item: &UserWhere #91 + │ │ │ ├─ [id]: optional '_89__integer_filter_c?' #89 + │ │ │ │ └─ item: optional '_integer_filter_c' #35 + │ │ │ │ └─ item: union #34 + │ │ │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_1: struct #33 + │ │ │ │ └─ [not]: either '_integer_filter' #32 + │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ [title]: optional '_90__string_filter_c?' #90 + │ │ │ └─ item: optional '_string_filter_c' #52 + │ │ │ └─ item: union #51 + │ │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ │ ├─ variant_0: string #37 + │ │ │ │ ├─ variant_1: struct #40 + │ │ │ │ │ └─ [equals]: string #37 + │ │ │ │ ├─ variant_2: struct #41 + │ │ │ │ │ └─ [not]: string #37 + │ │ │ │ ├─ variant_3: struct #42 + │ │ │ │ │ └─ [in]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_4: struct #43 + │ │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_5: struct #46 + │ │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #47 + │ │ │ │ │ └─ [search]: string #37 + │ │ │ │ └─ variant_7: struct #48 + │ │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ └─ [startsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ variant_1: struct #50 + │ │ │ └─ [not]: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ ├─ variant_1: struct #97 + │ │ │ └─ [some]: optional '_96_PostWhere__skip_15_UserWhere?' #96 + │ │ │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 + │ │ │ ├─ [author]: optional '_92_UserWhere?' #92 + │ │ │ │ └─ item: &UserWhere #91 + │ │ │ ├─ [id]: optional '_89__integer_filter_c?' #89 + │ │ │ │ └─ item: optional '_integer_filter_c' #35 + │ │ │ │ └─ item: union #34 + │ │ │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_1: struct #33 + │ │ │ │ └─ [not]: either '_integer_filter' #32 + │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ [title]: optional '_90__string_filter_c?' #90 + │ │ │ └─ item: optional '_string_filter_c' #52 + │ │ │ └─ item: union #51 + │ │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ │ ├─ variant_0: string #37 + │ │ │ │ ├─ variant_1: struct #40 + │ │ │ │ │ └─ [equals]: string #37 + │ │ │ │ ├─ variant_2: struct #41 + │ │ │ │ │ └─ [not]: string #37 + │ │ │ │ ├─ variant_3: struct #42 + │ │ │ │ │ └─ [in]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_4: struct #43 + │ │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_5: struct #46 + │ │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #47 + │ │ │ │ │ └─ [search]: string #37 + │ │ │ │ └─ variant_7: struct #48 + │ │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ └─ [startsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ variant_1: struct #50 + │ │ │ └─ [not]: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ variant_2: struct #99 + │ │ └─ [none]: optional '_98_PostWhere__skip_15_UserWhere?' #98 + │ │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 + │ │ ├─ [author]: optional '_92_UserWhere?' #92 + │ │ │ └─ item: &UserWhere #91 + │ │ ├─ [id]: optional '_89__integer_filter_c?' #89 + │ │ │ └─ item: optional '_integer_filter_c' #35 + │ │ │ └─ item: union #34 + │ │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_1: struct #33 + │ │ │ └─ [not]: either '_integer_filter' #32 + │ │ │ ├─ variant_0: integer #24 + │ │ │ ├─ variant_1: struct #27 + │ │ │ │ └─ [equals]: integer #24 + │ │ │ ├─ variant_2: struct #28 + │ │ │ │ └─ [not]: integer #24 + │ │ │ ├─ variant_3: struct #29 + │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ variant_4: struct #30 + │ │ │ │ └─ [in]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_5: struct #31 + │ │ │ └─ [notIn]: list #26 + │ │ │ └─ item: integer #24 + │ │ └─ [title]: optional '_90__string_filter_c?' #90 + │ │ └─ item: optional '_string_filter_c' #52 + │ │ └─ item: union #51 + │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ variant_1: struct #50 + │ │ └─ [not]: union '_string_filter' #49 + │ │ ├─ variant_0: string #37 + │ │ ├─ variant_1: struct #40 + │ │ │ └─ [equals]: string #37 + │ │ ├─ variant_2: struct #41 + │ │ │ └─ [not]: string #37 + │ │ ├─ variant_3: struct #42 + │ │ │ └─ [in]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_4: struct #43 + │ │ │ └─ [notIn]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_5: struct #46 + │ │ │ ├─ [contains]: string #37 + │ │ │ └─ [mode]: optional #45 + │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #47 + │ │ │ └─ [search]: string #37 + │ │ └─ variant_7: struct #48 + │ │ ├─ [endsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [startsWith]: optional #38 + │ │ └─ item: string #37 + │ └─ variant_2: struct #106 + │ └─ [connectOrCreate]: struct #103 + │ ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #86 + │ │ ├─ [id]: integer #11 + │ │ └─ [name]: string #12 + │ └─ [where]: struct 'UserWhere' #102 + │ ├─ [id]: optional '_87__integer_filter_c?' #87 + │ │ └─ item: optional '_integer_filter_c' #35 + │ │ └─ item: union #34 + │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ ├─ variant_0: integer #24 + │ │ │ ├─ variant_1: struct #27 + │ │ │ │ └─ [equals]: integer #24 + │ │ │ ├─ variant_2: struct #28 + │ │ │ │ └─ [not]: integer #24 + │ │ │ ├─ variant_3: struct #29 + │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ variant_4: struct #30 + │ │ │ │ └─ [in]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_5: struct #31 + │ │ │ └─ [notIn]: list #26 + │ │ │ └─ item: integer #24 + │ │ └─ variant_1: struct #33 + │ │ └─ [not]: either '_integer_filter' #32 + │ │ ├─ variant_0: integer #24 + │ │ ├─ variant_1: struct #27 + │ │ │ └─ [equals]: integer #24 + │ │ ├─ variant_2: struct #28 + │ │ │ └─ [not]: integer #24 + │ │ ├─ variant_3: struct #29 + │ │ │ ├─ [gt]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ [gte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ [lt]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ [lte]: optional #25 + │ │ │ └─ item: integer #24 + │ │ ├─ variant_4: struct #30 + │ │ │ └─ [in]: list #26 + │ │ │ └─ item: integer #24 + │ │ └─ variant_5: struct #31 + │ │ └─ [notIn]: list #26 + │ │ └─ item: integer #24 + │ ├─ [name]: optional '_88__string_filter_c?' #88 + │ │ └─ item: optional '_string_filter_c' #52 + │ │ └─ item: union #51 + │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ variant_1: struct #50 + │ │ └─ [not]: union '_string_filter' #49 + │ │ ├─ variant_0: string #37 + │ │ ├─ variant_1: struct #40 + │ │ │ └─ [equals]: string #37 + │ │ ├─ variant_2: struct #41 + │ │ │ └─ [not]: string #37 + │ │ ├─ variant_3: struct #42 + │ │ │ └─ [in]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_4: struct #43 + │ │ │ └─ [notIn]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_5: struct #46 + │ │ │ ├─ [contains]: string #37 + │ │ │ └─ [mode]: optional #45 + │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #47 + │ │ │ └─ [search]: string #37 + │ │ └─ variant_7: struct #48 + │ │ ├─ [endsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [startsWith]: optional #38 + │ │ └─ item: string #37 + │ └─ [posts]: optional #101 + │ └─ item: union #100 + │ ├─ variant_0: struct #95 + │ │ └─ [every]: optional '_94_PostWhere__skip_15_UserWhere?' #94 + │ │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 + │ │ ├─ [author]: optional '_92_UserWhere?' #92 + │ │ │ └─ item: &UserWhere #91 + │ │ ├─ [id]: optional '_89__integer_filter_c?' #89 + │ │ │ └─ item: optional '_integer_filter_c' #35 + │ │ │ └─ item: union #34 + │ │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_1: struct #33 + │ │ │ └─ [not]: either '_integer_filter' #32 + │ │ │ ├─ variant_0: integer #24 + │ │ │ ├─ variant_1: struct #27 + │ │ │ │ └─ [equals]: integer #24 + │ │ │ ├─ variant_2: struct #28 + │ │ │ │ └─ [not]: integer #24 + │ │ │ ├─ variant_3: struct #29 + │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ variant_4: struct #30 + │ │ │ │ └─ [in]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_5: struct #31 + │ │ │ └─ [notIn]: list #26 + │ │ │ └─ item: integer #24 + │ │ └─ [title]: optional '_90__string_filter_c?' #90 + │ │ └─ item: optional '_string_filter_c' #52 + │ │ └─ item: union #51 + │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ variant_1: struct #50 + │ │ └─ [not]: union '_string_filter' #49 + │ │ ├─ variant_0: string #37 + │ │ ├─ variant_1: struct #40 + │ │ │ └─ [equals]: string #37 + │ │ ├─ variant_2: struct #41 + │ │ │ └─ [not]: string #37 + │ │ ├─ variant_3: struct #42 + │ │ │ └─ [in]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_4: struct #43 + │ │ │ └─ [notIn]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_5: struct #46 + │ │ │ ├─ [contains]: string #37 + │ │ │ └─ [mode]: optional #45 + │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #47 + │ │ │ └─ [search]: string #37 + │ │ └─ variant_7: struct #48 + │ │ ├─ [endsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [startsWith]: optional #38 + │ │ └─ item: string #37 + │ ├─ variant_1: struct #97 + │ │ └─ [some]: optional '_96_PostWhere__skip_15_UserWhere?' #96 + │ │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 + │ │ ├─ [author]: optional '_92_UserWhere?' #92 + │ │ │ └─ item: &UserWhere #91 + │ │ ├─ [id]: optional '_89__integer_filter_c?' #89 + │ │ │ └─ item: optional '_integer_filter_c' #35 + │ │ │ └─ item: union #34 + │ │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_1: struct #33 + │ │ │ └─ [not]: either '_integer_filter' #32 + │ │ │ ├─ variant_0: integer #24 + │ │ │ ├─ variant_1: struct #27 + │ │ │ │ └─ [equals]: integer #24 + │ │ │ ├─ variant_2: struct #28 + │ │ │ │ └─ [not]: integer #24 + │ │ │ ├─ variant_3: struct #29 + │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ variant_4: struct #30 + │ │ │ │ └─ [in]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_5: struct #31 + │ │ │ └─ [notIn]: list #26 + │ │ │ └─ item: integer #24 + │ │ └─ [title]: optional '_90__string_filter_c?' #90 + │ │ └─ item: optional '_string_filter_c' #52 + │ │ └─ item: union #51 + │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ variant_1: struct #50 + │ │ └─ [not]: union '_string_filter' #49 + │ │ ├─ variant_0: string #37 + │ │ ├─ variant_1: struct #40 + │ │ │ └─ [equals]: string #37 + │ │ ├─ variant_2: struct #41 + │ │ │ └─ [not]: string #37 + │ │ ├─ variant_3: struct #42 + │ │ │ └─ [in]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_4: struct #43 + │ │ │ └─ [notIn]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_5: struct #46 + │ │ │ ├─ [contains]: string #37 + │ │ │ └─ [mode]: optional #45 + │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #47 + │ │ │ └─ [search]: string #37 + │ │ └─ variant_7: struct #48 + │ │ ├─ [endsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [startsWith]: optional #38 + │ │ └─ item: string #37 + │ └─ variant_2: struct #99 + │ └─ [none]: optional '_98_PostWhere__skip_15_UserWhere?' #98 + │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 + │ ├─ [author]: optional '_92_UserWhere?' #92 + │ │ └─ item: &UserWhere #91 + │ ├─ [id]: optional '_89__integer_filter_c?' #89 + │ │ └─ item: optional '_integer_filter_c' #35 + │ │ └─ item: union #34 + │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ ├─ variant_0: integer #24 + │ │ │ ├─ variant_1: struct #27 + │ │ │ │ └─ [equals]: integer #24 + │ │ │ ├─ variant_2: struct #28 + │ │ │ │ └─ [not]: integer #24 + │ │ │ ├─ variant_3: struct #29 + │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ variant_4: struct #30 + │ │ │ │ └─ [in]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_5: struct #31 + │ │ │ └─ [notIn]: list #26 + │ │ │ └─ item: integer #24 + │ │ └─ variant_1: struct #33 + │ │ └─ [not]: either '_integer_filter' #32 + │ │ ├─ variant_0: integer #24 + │ │ ├─ variant_1: struct #27 + │ │ │ └─ [equals]: integer #24 + │ │ ├─ variant_2: struct #28 + │ │ │ └─ [not]: integer #24 + │ │ ├─ variant_3: struct #29 + │ │ │ ├─ [gt]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ [gte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ [lt]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ [lte]: optional #25 + │ │ │ └─ item: integer #24 + │ │ ├─ variant_4: struct #30 + │ │ │ └─ [in]: list #26 + │ │ │ └─ item: integer #24 + │ │ └─ variant_5: struct #31 + │ │ └─ [notIn]: list #26 + │ │ └─ item: integer #24 + │ └─ [title]: optional '_90__string_filter_c?' #90 + │ └─ item: optional '_string_filter_c' #52 + │ └─ item: union #51 + │ ├─ variant_0: union '_string_filter' #49 + │ │ ├─ variant_0: string #37 + │ │ ├─ variant_1: struct #40 + │ │ │ └─ [equals]: string #37 + │ │ ├─ variant_2: struct #41 + │ │ │ └─ [not]: string #37 + │ │ ├─ variant_3: struct #42 + │ │ │ └─ [in]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_4: struct #43 + │ │ │ └─ [notIn]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_5: struct #46 + │ │ │ ├─ [contains]: string #37 + │ │ │ └─ [mode]: optional #45 + │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #47 + │ │ │ └─ [search]: string #37 + │ │ └─ variant_7: struct #48 + │ │ ├─ [endsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [startsWith]: optional #38 + │ │ └─ item: string #37 + │ └─ variant_1: struct #50 + │ └─ [not]: union '_string_filter' #49 + │ ├─ variant_0: string #37 + │ ├─ variant_1: struct #40 + │ │ └─ [equals]: string #37 + │ ├─ variant_2: struct #41 + │ │ └─ [not]: string #37 + │ ├─ variant_3: struct #42 + │ │ └─ [in]: list #39 + │ │ └─ item: string #37 + │ ├─ variant_4: struct #43 + │ │ └─ [notIn]: list #39 + │ │ └─ item: string #37 + │ ├─ variant_5: struct #46 + │ │ ├─ [contains]: string #37 + │ │ └─ [mode]: optional #45 + │ │ └─ item: string #44 enum{ '"insensitive"' } + │ ├─ variant_6: struct #47 + │ │ └─ [search]: string #37 + │ └─ variant_7: struct #48 + │ ├─ [endsWith]: optional #38 + │ │ └─ item: string #37 + │ └─ [startsWith]: optional #38 + │ └─ item: string #37 ├─ [id]: optional #85 │ └─ item: integer #16 - ├─ [title]: string #17 - └─ [author]: union #107 - ├─ variant_0: struct #104 - │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #86 - │ ├─ [id]: integer #11 - │ └─ [name]: string #12 - ├─ variant_1: struct #105 - │ └─ [connect]: struct 'UserWhere' #102 - │ ├─ [id]: optional '_87__integer_filter_c?' #87 - │ │ └─ item: optional '_integer_filter_c' #35 - │ │ └─ item: union #34 - │ │ ├─ variant_0: either '_integer_filter' #32 - │ │ │ ├─ variant_0: integer #24 - │ │ │ ├─ variant_1: struct #27 - │ │ │ │ └─ [equals]: integer #24 - │ │ │ ├─ variant_2: struct #28 - │ │ │ │ └─ [not]: integer #24 - │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ variant_4: struct #30 - │ │ │ │ └─ [in]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_5: struct #31 - │ │ │ └─ [notIn]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_1: struct #33 - │ │ └─ [not]: either '_integer_filter' #32 - │ │ ├─ variant_0: integer #24 - │ │ ├─ variant_1: struct #27 - │ │ │ └─ [equals]: integer #24 - │ │ ├─ variant_2: struct #28 - │ │ │ └─ [not]: integer #24 - │ │ ├─ variant_3: struct #29 - │ │ │ ├─ [lt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [gt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [lte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ [gte]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ variant_4: struct #30 - │ │ │ └─ [in]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_5: struct #31 - │ │ └─ [notIn]: list #26 - │ │ └─ item: integer #24 - │ ├─ [name]: optional '_88__string_filter_c?' #88 - │ │ └─ item: optional '_string_filter_c' #52 - │ │ └─ item: union #51 - │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ variant_1: struct #50 - │ │ └─ [not]: union '_string_filter' #49 - │ │ ├─ variant_0: string #37 - │ │ ├─ variant_1: struct #40 - │ │ │ └─ [equals]: string #37 - │ │ ├─ variant_2: struct #41 - │ │ │ └─ [not]: string #37 - │ │ ├─ variant_3: struct #42 - │ │ │ └─ [in]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_4: struct #43 - │ │ │ └─ [notIn]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_5: struct #46 - │ │ │ ├─ [contains]: string #37 - │ │ │ └─ [mode]: optional #45 - │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #47 - │ │ │ └─ [search]: string #37 - │ │ └─ variant_7: struct #48 - │ │ ├─ [startsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [endsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ [posts]: optional #101 - │ └─ item: union #100 - │ ├─ variant_0: struct #95 - │ │ └─ [every]: optional '_94_PostWhere__skip_15_UserWhere?' #94 - │ │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 - │ │ ├─ [id]: optional '_89__integer_filter_c?' #89 - │ │ │ └─ item: optional '_integer_filter_c' #35 - │ │ │ └─ item: union #34 - │ │ │ ├─ variant_0: either '_integer_filter' #32 - │ │ │ │ ├─ variant_0: integer #24 - │ │ │ │ ├─ variant_1: struct #27 - │ │ │ │ │ └─ [equals]: integer #24 - │ │ │ │ ├─ variant_2: struct #28 - │ │ │ │ │ └─ [not]: integer #24 - │ │ │ │ ├─ variant_3: struct #29 - │ │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ variant_4: struct #30 - │ │ │ │ │ └─ [in]: list #26 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ variant_5: struct #31 - │ │ │ │ └─ [notIn]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_1: struct #33 - │ │ │ └─ [not]: either '_integer_filter' #32 - │ │ │ ├─ variant_0: integer #24 - │ │ │ ├─ variant_1: struct #27 - │ │ │ │ └─ [equals]: integer #24 - │ │ │ ├─ variant_2: struct #28 - │ │ │ │ └─ [not]: integer #24 - │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ variant_4: struct #30 - │ │ │ │ └─ [in]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_5: struct #31 - │ │ │ └─ [notIn]: list #26 - │ │ │ └─ item: integer #24 - │ │ ├─ [title]: optional '_90__string_filter_c?' #90 - │ │ │ └─ item: optional '_string_filter_c' #52 - │ │ │ └─ item: union #51 - │ │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ │ ├─ variant_0: string #37 - │ │ │ │ ├─ variant_1: struct #40 - │ │ │ │ │ └─ [equals]: string #37 - │ │ │ │ ├─ variant_2: struct #41 - │ │ │ │ │ └─ [not]: string #37 - │ │ │ │ ├─ variant_3: struct #42 - │ │ │ │ │ └─ [in]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_4: struct #43 - │ │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_5: struct #46 - │ │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #47 - │ │ │ │ │ └─ [search]: string #37 - │ │ │ │ └─ variant_7: struct #48 - │ │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ └─ [endsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ variant_1: struct #50 - │ │ │ └─ [not]: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [author]: optional '_92_UserWhere?' #92 - │ │ └─ item: &UserWhere #91 - │ ├─ variant_1: struct #97 - │ │ └─ [some]: optional '_96_PostWhere__skip_15_UserWhere?' #96 - │ │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 - │ │ ├─ [id]: optional '_89__integer_filter_c?' #89 - │ │ │ └─ item: optional '_integer_filter_c' #35 - │ │ │ └─ item: union #34 - │ │ │ ├─ variant_0: either '_integer_filter' #32 - │ │ │ │ ├─ variant_0: integer #24 - │ │ │ │ ├─ variant_1: struct #27 - │ │ │ │ │ └─ [equals]: integer #24 - │ │ │ │ ├─ variant_2: struct #28 - │ │ │ │ │ └─ [not]: integer #24 - │ │ │ │ ├─ variant_3: struct #29 - │ │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ variant_4: struct #30 - │ │ │ │ │ └─ [in]: list #26 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ variant_5: struct #31 - │ │ │ │ └─ [notIn]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_1: struct #33 - │ │ │ └─ [not]: either '_integer_filter' #32 - │ │ │ ├─ variant_0: integer #24 - │ │ │ ├─ variant_1: struct #27 - │ │ │ │ └─ [equals]: integer #24 - │ │ │ ├─ variant_2: struct #28 - │ │ │ │ └─ [not]: integer #24 - │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ variant_4: struct #30 - │ │ │ │ └─ [in]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_5: struct #31 - │ │ │ └─ [notIn]: list #26 - │ │ │ └─ item: integer #24 - │ │ ├─ [title]: optional '_90__string_filter_c?' #90 - │ │ │ └─ item: optional '_string_filter_c' #52 - │ │ │ └─ item: union #51 - │ │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ │ ├─ variant_0: string #37 - │ │ │ │ ├─ variant_1: struct #40 - │ │ │ │ │ └─ [equals]: string #37 - │ │ │ │ ├─ variant_2: struct #41 - │ │ │ │ │ └─ [not]: string #37 - │ │ │ │ ├─ variant_3: struct #42 - │ │ │ │ │ └─ [in]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_4: struct #43 - │ │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_5: struct #46 - │ │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #47 - │ │ │ │ │ └─ [search]: string #37 - │ │ │ │ └─ variant_7: struct #48 - │ │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ └─ [endsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ variant_1: struct #50 - │ │ │ └─ [not]: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [author]: optional '_92_UserWhere?' #92 - │ │ └─ item: &UserWhere #91 - │ └─ variant_2: struct #99 - │ └─ [none]: optional '_98_PostWhere__skip_15_UserWhere?' #98 - │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 - │ ├─ [id]: optional '_89__integer_filter_c?' #89 - │ │ └─ item: optional '_integer_filter_c' #35 - │ │ └─ item: union #34 - │ │ ├─ variant_0: either '_integer_filter' #32 - │ │ │ ├─ variant_0: integer #24 - │ │ │ ├─ variant_1: struct #27 - │ │ │ │ └─ [equals]: integer #24 - │ │ │ ├─ variant_2: struct #28 - │ │ │ │ └─ [not]: integer #24 - │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ variant_4: struct #30 - │ │ │ │ └─ [in]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_5: struct #31 - │ │ │ └─ [notIn]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_1: struct #33 - │ │ └─ [not]: either '_integer_filter' #32 - │ │ ├─ variant_0: integer #24 - │ │ ├─ variant_1: struct #27 - │ │ │ └─ [equals]: integer #24 - │ │ ├─ variant_2: struct #28 - │ │ │ └─ [not]: integer #24 - │ │ ├─ variant_3: struct #29 - │ │ │ ├─ [lt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [gt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [lte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ [gte]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ variant_4: struct #30 - │ │ │ └─ [in]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_5: struct #31 - │ │ └─ [notIn]: list #26 - │ │ └─ item: integer #24 - │ ├─ [title]: optional '_90__string_filter_c?' #90 - │ │ └─ item: optional '_string_filter_c' #52 - │ │ └─ item: union #51 - │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ variant_1: struct #50 - │ │ └─ [not]: union '_string_filter' #49 - │ │ ├─ variant_0: string #37 - │ │ ├─ variant_1: struct #40 - │ │ │ └─ [equals]: string #37 - │ │ ├─ variant_2: struct #41 - │ │ │ └─ [not]: string #37 - │ │ ├─ variant_3: struct #42 - │ │ │ └─ [in]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_4: struct #43 - │ │ │ └─ [notIn]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_5: struct #46 - │ │ │ ├─ [contains]: string #37 - │ │ │ └─ [mode]: optional #45 - │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #47 - │ │ │ └─ [search]: string #37 - │ │ └─ variant_7: struct #48 - │ │ ├─ [startsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [endsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ [author]: optional '_92_UserWhere?' #92 - │ └─ item: &UserWhere #91 - └─ variant_2: struct #106 - └─ [connectOrCreate]: struct #103 - ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #86 - │ ├─ [id]: integer #11 - │ └─ [name]: string #12 - └─ [where]: struct 'UserWhere' #102 - ├─ [id]: optional '_87__integer_filter_c?' #87 - │ └─ item: optional '_integer_filter_c' #35 - │ └─ item: union #34 - │ ├─ variant_0: either '_integer_filter' #32 - │ │ ├─ variant_0: integer #24 - │ │ ├─ variant_1: struct #27 - │ │ │ └─ [equals]: integer #24 - │ │ ├─ variant_2: struct #28 - │ │ │ └─ [not]: integer #24 - │ │ ├─ variant_3: struct #29 - │ │ │ ├─ [lt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [gt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [lte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ [gte]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ variant_4: struct #30 - │ │ │ └─ [in]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_5: struct #31 - │ │ └─ [notIn]: list #26 - │ │ └─ item: integer #24 - │ └─ variant_1: struct #33 - │ └─ [not]: either '_integer_filter' #32 - │ ├─ variant_0: integer #24 - │ ├─ variant_1: struct #27 - │ │ └─ [equals]: integer #24 - │ ├─ variant_2: struct #28 - │ │ └─ [not]: integer #24 - │ ├─ variant_3: struct #29 - │ │ ├─ [lt]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ [gt]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ [lte]: optional #25 - │ │ │ └─ item: integer #24 - │ │ └─ [gte]: optional #25 - │ │ └─ item: integer #24 - │ ├─ variant_4: struct #30 - │ │ └─ [in]: list #26 - │ │ └─ item: integer #24 - │ └─ variant_5: struct #31 - │ └─ [notIn]: list #26 - │ └─ item: integer #24 - ├─ [name]: optional '_88__string_filter_c?' #88 - │ └─ item: optional '_string_filter_c' #52 - │ └─ item: union #51 - │ ├─ variant_0: union '_string_filter' #49 - │ │ ├─ variant_0: string #37 - │ │ ├─ variant_1: struct #40 - │ │ │ └─ [equals]: string #37 - │ │ ├─ variant_2: struct #41 - │ │ │ └─ [not]: string #37 - │ │ ├─ variant_3: struct #42 - │ │ │ └─ [in]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_4: struct #43 - │ │ │ └─ [notIn]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_5: struct #46 - │ │ │ ├─ [contains]: string #37 - │ │ │ └─ [mode]: optional #45 - │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #47 - │ │ │ └─ [search]: string #37 - │ │ └─ variant_7: struct #48 - │ │ ├─ [startsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [endsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ variant_1: struct #50 - │ └─ [not]: union '_string_filter' #49 - │ ├─ variant_0: string #37 - │ ├─ variant_1: struct #40 - │ │ └─ [equals]: string #37 - │ ├─ variant_2: struct #41 - │ │ └─ [not]: string #37 - │ ├─ variant_3: struct #42 - │ │ └─ [in]: list #39 - │ │ └─ item: string #37 - │ ├─ variant_4: struct #43 - │ │ └─ [notIn]: list #39 - │ │ └─ item: string #37 - │ ├─ variant_5: struct #46 - │ │ ├─ [contains]: string #37 - │ │ └─ [mode]: optional #45 - │ │ └─ item: string #44 enum{ '"insensitive"' } - │ ├─ variant_6: struct #47 - │ │ └─ [search]: string #37 - │ └─ variant_7: struct #48 - │ ├─ [startsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ [endsWith]: optional #38 - │ └─ item: string #37 - └─ [posts]: optional #101 - └─ item: union #100 - ├─ variant_0: struct #95 - │ └─ [every]: optional '_94_PostWhere__skip_15_UserWhere?' #94 - │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 - │ ├─ [id]: optional '_89__integer_filter_c?' #89 - │ │ └─ item: optional '_integer_filter_c' #35 - │ │ └─ item: union #34 - │ │ ├─ variant_0: either '_integer_filter' #32 - │ │ │ ├─ variant_0: integer #24 - │ │ │ ├─ variant_1: struct #27 - │ │ │ │ └─ [equals]: integer #24 - │ │ │ ├─ variant_2: struct #28 - │ │ │ │ └─ [not]: integer #24 - │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ variant_4: struct #30 - │ │ │ │ └─ [in]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_5: struct #31 - │ │ │ └─ [notIn]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_1: struct #33 - │ │ └─ [not]: either '_integer_filter' #32 - │ │ ├─ variant_0: integer #24 - │ │ ├─ variant_1: struct #27 - │ │ │ └─ [equals]: integer #24 - │ │ ├─ variant_2: struct #28 - │ │ │ └─ [not]: integer #24 - │ │ ├─ variant_3: struct #29 - │ │ │ ├─ [lt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [gt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [lte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ [gte]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ variant_4: struct #30 - │ │ │ └─ [in]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_5: struct #31 - │ │ └─ [notIn]: list #26 - │ │ └─ item: integer #24 - │ ├─ [title]: optional '_90__string_filter_c?' #90 - │ │ └─ item: optional '_string_filter_c' #52 - │ │ └─ item: union #51 - │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ variant_1: struct #50 - │ │ └─ [not]: union '_string_filter' #49 - │ │ ├─ variant_0: string #37 - │ │ ├─ variant_1: struct #40 - │ │ │ └─ [equals]: string #37 - │ │ ├─ variant_2: struct #41 - │ │ │ └─ [not]: string #37 - │ │ ├─ variant_3: struct #42 - │ │ │ └─ [in]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_4: struct #43 - │ │ │ └─ [notIn]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_5: struct #46 - │ │ │ ├─ [contains]: string #37 - │ │ │ └─ [mode]: optional #45 - │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #47 - │ │ │ └─ [search]: string #37 - │ │ └─ variant_7: struct #48 - │ │ ├─ [startsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [endsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ [author]: optional '_92_UserWhere?' #92 - │ └─ item: &UserWhere #91 - ├─ variant_1: struct #97 - │ └─ [some]: optional '_96_PostWhere__skip_15_UserWhere?' #96 - │ └─ item: struct 'PostWhere__skip_15_UserWhere' #93 - │ ├─ [id]: optional '_89__integer_filter_c?' #89 - │ │ └─ item: optional '_integer_filter_c' #35 - │ │ └─ item: union #34 - │ │ ├─ variant_0: either '_integer_filter' #32 - │ │ │ ├─ variant_0: integer #24 - │ │ │ ├─ variant_1: struct #27 - │ │ │ │ └─ [equals]: integer #24 - │ │ │ ├─ variant_2: struct #28 - │ │ │ │ └─ [not]: integer #24 - │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ variant_4: struct #30 - │ │ │ │ └─ [in]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_5: struct #31 - │ │ │ └─ [notIn]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_1: struct #33 - │ │ └─ [not]: either '_integer_filter' #32 - │ │ ├─ variant_0: integer #24 - │ │ ├─ variant_1: struct #27 - │ │ │ └─ [equals]: integer #24 - │ │ ├─ variant_2: struct #28 - │ │ │ └─ [not]: integer #24 - │ │ ├─ variant_3: struct #29 - │ │ │ ├─ [lt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [gt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [lte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ [gte]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ variant_4: struct #30 - │ │ │ └─ [in]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_5: struct #31 - │ │ └─ [notIn]: list #26 - │ │ └─ item: integer #24 - │ ├─ [title]: optional '_90__string_filter_c?' #90 - │ │ └─ item: optional '_string_filter_c' #52 - │ │ └─ item: union #51 - │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ variant_1: struct #50 - │ │ └─ [not]: union '_string_filter' #49 - │ │ ├─ variant_0: string #37 - │ │ ├─ variant_1: struct #40 - │ │ │ └─ [equals]: string #37 - │ │ ├─ variant_2: struct #41 - │ │ │ └─ [not]: string #37 - │ │ ├─ variant_3: struct #42 - │ │ │ └─ [in]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_4: struct #43 - │ │ │ └─ [notIn]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_5: struct #46 - │ │ │ ├─ [contains]: string #37 - │ │ │ └─ [mode]: optional #45 - │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #47 - │ │ │ └─ [search]: string #37 - │ │ └─ variant_7: struct #48 - │ │ ├─ [startsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [endsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ [author]: optional '_92_UserWhere?' #92 - │ └─ item: &UserWhere #91 - └─ variant_2: struct #99 - └─ [none]: optional '_98_PostWhere__skip_15_UserWhere?' #98 - └─ item: struct 'PostWhere__skip_15_UserWhere' #93 - ├─ [id]: optional '_89__integer_filter_c?' #89 - │ └─ item: optional '_integer_filter_c' #35 - │ └─ item: union #34 - │ ├─ variant_0: either '_integer_filter' #32 - │ │ ├─ variant_0: integer #24 - │ │ ├─ variant_1: struct #27 - │ │ │ └─ [equals]: integer #24 - │ │ ├─ variant_2: struct #28 - │ │ │ └─ [not]: integer #24 - │ │ ├─ variant_3: struct #29 - │ │ │ ├─ [lt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [gt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [lte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ [gte]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ variant_4: struct #30 - │ │ │ └─ [in]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_5: struct #31 - │ │ └─ [notIn]: list #26 - │ │ └─ item: integer #24 - │ └─ variant_1: struct #33 - │ └─ [not]: either '_integer_filter' #32 - │ ├─ variant_0: integer #24 - │ ├─ variant_1: struct #27 - │ │ └─ [equals]: integer #24 - │ ├─ variant_2: struct #28 - │ │ └─ [not]: integer #24 - │ ├─ variant_3: struct #29 - │ │ ├─ [lt]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ [gt]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ [lte]: optional #25 - │ │ │ └─ item: integer #24 - │ │ └─ [gte]: optional #25 - │ │ └─ item: integer #24 - │ ├─ variant_4: struct #30 - │ │ └─ [in]: list #26 - │ │ └─ item: integer #24 - │ └─ variant_5: struct #31 - │ └─ [notIn]: list #26 - │ └─ item: integer #24 - ├─ [title]: optional '_90__string_filter_c?' #90 - │ └─ item: optional '_string_filter_c' #52 - │ └─ item: union #51 - │ ├─ variant_0: union '_string_filter' #49 - │ │ ├─ variant_0: string #37 - │ │ ├─ variant_1: struct #40 - │ │ │ └─ [equals]: string #37 - │ │ ├─ variant_2: struct #41 - │ │ │ └─ [not]: string #37 - │ │ ├─ variant_3: struct #42 - │ │ │ └─ [in]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_4: struct #43 - │ │ │ └─ [notIn]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_5: struct #46 - │ │ │ ├─ [contains]: string #37 - │ │ │ └─ [mode]: optional #45 - │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #47 - │ │ │ └─ [search]: string #37 - │ │ └─ variant_7: struct #48 - │ │ ├─ [startsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [endsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ variant_1: struct #50 - │ └─ [not]: union '_string_filter' #49 - │ ├─ variant_0: string #37 - │ ├─ variant_1: struct #40 - │ │ └─ [equals]: string #37 - │ ├─ variant_2: struct #41 - │ │ └─ [not]: string #37 - │ ├─ variant_3: struct #42 - │ │ └─ [in]: list #39 - │ │ └─ item: string #37 - │ ├─ variant_4: struct #43 - │ │ └─ [notIn]: list #39 - │ │ └─ item: string #37 - │ ├─ variant_5: struct #46 - │ │ ├─ [contains]: string #37 - │ │ └─ [mode]: optional #45 - │ │ └─ item: string #44 enum{ '"insensitive"' } - │ ├─ variant_6: struct #47 - │ │ └─ [search]: string #37 - │ └─ variant_7: struct #48 - │ ├─ [startsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ [endsWith]: optional #38 - │ └─ item: string #37 - └─ [author]: optional '_92_UserWhere?' #92 - └─ item: &UserWhere #91 + └─ [title]: string #17 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Post out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Post out.snap index a0c8c6017..7022caca4 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Post out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Post out.snap @@ -1,6 +1,6 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: struct #112 └─ [count]: integer #111 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Record inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Record inp.snap index 02743d433..7625656cb 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Record inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Record inp.snap @@ -1,13 +1,13 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #8 └─ [data]: list '_7__Record_CreateInput[]' #7 └─ item: struct '_Record_CreateInput' #6 + ├─ [age]: optional #3 + │ └─ item: integer #2 ├─ [id]: optional #5 │ └─ item: string #0 - ├─ [name]: string #1 - └─ [age]: optional #3 - └─ item: integer #2 + └─ [name]: string #1 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Record out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Record out.snap index 6a3208c7f..b998899ed 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Record out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many Record out.snap @@ -1,6 +1,6 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: "tree::PrintOptions::new().indent_size(3).print(out)" --- root: struct #10 └─ [count]: integer #9 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many User inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many User inp.snap index fe4ca9318..dc20a81ea 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many User inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many User inp.snap @@ -1,6 +1,6 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #82 └─ [data]: list '_81__User_CreateInput[]' #81 @@ -23,6 +23,115 @@ root: struct #82 ├─ variant_1: struct #72 │ └─ [connect]: union #69 │ ├─ variant_0: struct 'PostWhere' #67 + │ │ ├─ [author]: optional '_66_UserWhere__skip_19_PostWhere?' #66 + │ │ │ └─ item: struct 'UserWhere__skip_19_PostWhere' #65 + │ │ │ ├─ [id]: optional '_54__integer_filter_c?' #54 + │ │ │ │ └─ item: optional '_integer_filter_c' #35 + │ │ │ │ └─ item: union #34 + │ │ │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_1: struct #33 + │ │ │ │ └─ [not]: either '_integer_filter' #32 + │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ [name]: optional '_55__string_filter_c?' #55 + │ │ │ │ └─ item: optional '_string_filter_c' #52 + │ │ │ │ └─ item: union #51 + │ │ │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ │ │ ├─ variant_0: string #37 + │ │ │ │ │ ├─ variant_1: struct #40 + │ │ │ │ │ │ └─ [equals]: string #37 + │ │ │ │ │ ├─ variant_2: struct #41 + │ │ │ │ │ │ └─ [not]: string #37 + │ │ │ │ │ ├─ variant_3: struct #42 + │ │ │ │ │ │ └─ [in]: list #39 + │ │ │ │ │ │ └─ item: string #37 + │ │ │ │ │ ├─ variant_4: struct #43 + │ │ │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ │ │ └─ item: string #37 + │ │ │ │ │ ├─ variant_5: struct #46 + │ │ │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ │ │ ├─ variant_6: struct #47 + │ │ │ │ │ │ └─ [search]: string #37 + │ │ │ │ │ └─ variant_7: struct #48 + │ │ │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ │ │ └─ item: string #37 + │ │ │ │ │ └─ [startsWith]: optional #38 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ └─ variant_1: struct #50 + │ │ │ │ └─ [not]: union '_string_filter' #49 + │ │ │ │ ├─ variant_0: string #37 + │ │ │ │ ├─ variant_1: struct #40 + │ │ │ │ │ └─ [equals]: string #37 + │ │ │ │ ├─ variant_2: struct #41 + │ │ │ │ │ └─ [not]: string #37 + │ │ │ │ ├─ variant_3: struct #42 + │ │ │ │ │ └─ [in]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_4: struct #43 + │ │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_5: struct #46 + │ │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #47 + │ │ │ │ │ └─ [search]: string #37 + │ │ │ │ └─ variant_7: struct #48 + │ │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ └─ [startsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [posts]: optional #64 + │ │ │ └─ item: union #63 + │ │ │ ├─ variant_0: struct #58 + │ │ │ │ └─ [every]: optional '_57_PostWhere?' #57 + │ │ │ │ └─ item: &PostWhere #56 + │ │ │ ├─ variant_1: struct #60 + │ │ │ │ └─ [some]: optional '_59_PostWhere?' #59 + │ │ │ │ └─ item: &PostWhere #56 + │ │ │ └─ variant_2: struct #62 + │ │ │ └─ [none]: optional '_61_PostWhere?' #61 + │ │ │ └─ item: &PostWhere #56 │ │ ├─ [id]: optional '_36__integer_filter_c?' #36 │ │ │ └─ item: optional '_integer_filter_c' #35 │ │ │ └─ item: union #34 @@ -33,13 +142,13 @@ root: struct #82 │ │ │ │ ├─ variant_2: struct #28 │ │ │ │ │ └─ [not]: integer #24 │ │ │ │ ├─ variant_3: struct #29 - │ │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 │ │ │ │ │ ├─ [gt]: optional #25 │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ ├─ [lte]: optional #25 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ └─ [gte]: optional #25 + │ │ │ │ │ └─ [lte]: optional #25 │ │ │ │ │ └─ item: integer #24 │ │ │ │ ├─ variant_4: struct #30 │ │ │ │ │ └─ [in]: list #26 @@ -55,13 +164,13 @@ root: struct #82 │ │ │ ├─ variant_2: struct #28 │ │ │ │ └─ [not]: integer #24 │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 │ │ │ │ ├─ [gt]: optional #25 │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 + │ │ │ │ └─ [lte]: optional #25 │ │ │ │ └─ item: integer #24 │ │ │ ├─ variant_4: struct #30 │ │ │ │ └─ [in]: list #26 @@ -69,167 +178,167 @@ root: struct #82 │ │ │ └─ variant_5: struct #31 │ │ │ └─ [notIn]: list #26 │ │ │ └─ item: integer #24 - │ │ ├─ [title]: optional '_53__string_filter_c?' #53 - │ │ │ └─ item: optional '_string_filter_c' #52 - │ │ │ └─ item: union #51 - │ │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ │ ├─ variant_0: string #37 - │ │ │ │ ├─ variant_1: struct #40 - │ │ │ │ │ └─ [equals]: string #37 - │ │ │ │ ├─ variant_2: struct #41 - │ │ │ │ │ └─ [not]: string #37 - │ │ │ │ ├─ variant_3: struct #42 - │ │ │ │ │ └─ [in]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_4: struct #43 - │ │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_5: struct #46 - │ │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #47 - │ │ │ │ │ └─ [search]: string #37 - │ │ │ │ └─ variant_7: struct #48 - │ │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ └─ [endsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ variant_1: struct #50 - │ │ │ └─ [not]: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [author]: optional '_66_UserWhere__skip_19_PostWhere?' #66 - │ │ └─ item: struct 'UserWhere__skip_19_PostWhere' #65 - │ │ ├─ [id]: optional '_54__integer_filter_c?' #54 - │ │ │ └─ item: optional '_integer_filter_c' #35 - │ │ │ └─ item: union #34 - │ │ │ ├─ variant_0: either '_integer_filter' #32 - │ │ │ │ ├─ variant_0: integer #24 - │ │ │ │ ├─ variant_1: struct #27 - │ │ │ │ │ └─ [equals]: integer #24 - │ │ │ │ ├─ variant_2: struct #28 - │ │ │ │ │ └─ [not]: integer #24 - │ │ │ │ ├─ variant_3: struct #29 - │ │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ variant_4: struct #30 - │ │ │ │ │ └─ [in]: list #26 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ variant_5: struct #31 - │ │ │ │ └─ [notIn]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_1: struct #33 - │ │ │ └─ [not]: either '_integer_filter' #32 - │ │ │ ├─ variant_0: integer #24 - │ │ │ ├─ variant_1: struct #27 - │ │ │ │ └─ [equals]: integer #24 - │ │ │ ├─ variant_2: struct #28 - │ │ │ │ └─ [not]: integer #24 - │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ variant_4: struct #30 - │ │ │ │ └─ [in]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_5: struct #31 - │ │ │ └─ [notIn]: list #26 - │ │ │ └─ item: integer #24 - │ │ ├─ [name]: optional '_55__string_filter_c?' #55 - │ │ │ └─ item: optional '_string_filter_c' #52 - │ │ │ └─ item: union #51 - │ │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ │ ├─ variant_0: string #37 - │ │ │ │ ├─ variant_1: struct #40 - │ │ │ │ │ └─ [equals]: string #37 - │ │ │ │ ├─ variant_2: struct #41 - │ │ │ │ │ └─ [not]: string #37 - │ │ │ │ ├─ variant_3: struct #42 - │ │ │ │ │ └─ [in]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_4: struct #43 - │ │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_5: struct #46 - │ │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #47 - │ │ │ │ │ └─ [search]: string #37 - │ │ │ │ └─ variant_7: struct #48 - │ │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ └─ [endsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ variant_1: struct #50 - │ │ │ └─ [not]: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [posts]: optional #64 - │ │ └─ item: union #63 - │ │ ├─ variant_0: struct #58 - │ │ │ └─ [every]: optional '_57_PostWhere?' #57 - │ │ │ └─ item: &PostWhere #56 - │ │ ├─ variant_1: struct #60 - │ │ │ └─ [some]: optional '_59_PostWhere?' #59 - │ │ │ └─ item: &PostWhere #56 - │ │ └─ variant_2: struct #62 - │ │ └─ [none]: optional '_61_PostWhere?' #61 - │ │ └─ item: &PostWhere #56 + │ │ └─ [title]: optional '_53__string_filter_c?' #53 + │ │ └─ item: optional '_string_filter_c' #52 + │ │ └─ item: union #51 + │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ variant_1: struct #50 + │ │ └─ [not]: union '_string_filter' #49 + │ │ ├─ variant_0: string #37 + │ │ ├─ variant_1: struct #40 + │ │ │ └─ [equals]: string #37 + │ │ ├─ variant_2: struct #41 + │ │ │ └─ [not]: string #37 + │ │ ├─ variant_3: struct #42 + │ │ │ └─ [in]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_4: struct #43 + │ │ │ └─ [notIn]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_5: struct #46 + │ │ │ ├─ [contains]: string #37 + │ │ │ └─ [mode]: optional #45 + │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #47 + │ │ │ └─ [search]: string #37 + │ │ └─ variant_7: struct #48 + │ │ ├─ [endsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [startsWith]: optional #38 + │ │ └─ item: string #37 │ └─ variant_1: list '_68_PostWhere[]' #68 │ └─ item: struct 'PostWhere' #67 + │ ├─ [author]: optional '_66_UserWhere__skip_19_PostWhere?' #66 + │ │ └─ item: struct 'UserWhere__skip_19_PostWhere' #65 + │ │ ├─ [id]: optional '_54__integer_filter_c?' #54 + │ │ │ └─ item: optional '_integer_filter_c' #35 + │ │ │ └─ item: union #34 + │ │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_1: struct #33 + │ │ │ └─ [not]: either '_integer_filter' #32 + │ │ │ ├─ variant_0: integer #24 + │ │ │ ├─ variant_1: struct #27 + │ │ │ │ └─ [equals]: integer #24 + │ │ │ ├─ variant_2: struct #28 + │ │ │ │ └─ [not]: integer #24 + │ │ │ ├─ variant_3: struct #29 + │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ variant_4: struct #30 + │ │ │ │ └─ [in]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_5: struct #31 + │ │ │ └─ [notIn]: list #26 + │ │ │ └─ item: integer #24 + │ │ ├─ [name]: optional '_55__string_filter_c?' #55 + │ │ │ └─ item: optional '_string_filter_c' #52 + │ │ │ └─ item: union #51 + │ │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ │ ├─ variant_0: string #37 + │ │ │ │ ├─ variant_1: struct #40 + │ │ │ │ │ └─ [equals]: string #37 + │ │ │ │ ├─ variant_2: struct #41 + │ │ │ │ │ └─ [not]: string #37 + │ │ │ │ ├─ variant_3: struct #42 + │ │ │ │ │ └─ [in]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_4: struct #43 + │ │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_5: struct #46 + │ │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #47 + │ │ │ │ │ └─ [search]: string #37 + │ │ │ │ └─ variant_7: struct #48 + │ │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ └─ [startsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ variant_1: struct #50 + │ │ │ └─ [not]: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [posts]: optional #64 + │ │ └─ item: union #63 + │ │ ├─ variant_0: struct #58 + │ │ │ └─ [every]: optional '_57_PostWhere?' #57 + │ │ │ └─ item: &PostWhere #56 + │ │ ├─ variant_1: struct #60 + │ │ │ └─ [some]: optional '_59_PostWhere?' #59 + │ │ │ └─ item: &PostWhere #56 + │ │ └─ variant_2: struct #62 + │ │ └─ [none]: optional '_61_PostWhere?' #61 + │ │ └─ item: &PostWhere #56 │ ├─ [id]: optional '_36__integer_filter_c?' #36 │ │ └─ item: optional '_integer_filter_c' #35 │ │ └─ item: union #34 @@ -240,13 +349,13 @@ root: struct #82 │ │ │ ├─ variant_2: struct #28 │ │ │ │ └─ [not]: integer #24 │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 │ │ │ │ ├─ [gt]: optional #25 │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 + │ │ │ │ └─ [lte]: optional #25 │ │ │ │ └─ item: integer #24 │ │ │ ├─ variant_4: struct #30 │ │ │ │ └─ [in]: list #26 @@ -262,13 +371,13 @@ root: struct #82 │ │ ├─ variant_2: struct #28 │ │ │ └─ [not]: integer #24 │ │ ├─ variant_3: struct #29 - │ │ │ ├─ [lt]: optional #25 - │ │ │ │ └─ item: integer #24 │ │ │ ├─ [gt]: optional #25 │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [lte]: optional #25 + │ │ │ ├─ [gte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ [lt]: optional #25 │ │ │ │ └─ item: integer #24 - │ │ │ └─ [gte]: optional #25 + │ │ │ └─ [lte]: optional #25 │ │ │ └─ item: integer #24 │ │ ├─ variant_4: struct #30 │ │ │ └─ [in]: list #26 @@ -276,165 +385,56 @@ root: struct #82 │ │ └─ variant_5: struct #31 │ │ └─ [notIn]: list #26 │ │ └─ item: integer #24 - │ ├─ [title]: optional '_53__string_filter_c?' #53 - │ │ └─ item: optional '_string_filter_c' #52 - │ │ └─ item: union #51 - │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ variant_1: struct #50 - │ │ └─ [not]: union '_string_filter' #49 - │ │ ├─ variant_0: string #37 - │ │ ├─ variant_1: struct #40 - │ │ │ └─ [equals]: string #37 - │ │ ├─ variant_2: struct #41 - │ │ │ └─ [not]: string #37 - │ │ ├─ variant_3: struct #42 - │ │ │ └─ [in]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_4: struct #43 - │ │ │ └─ [notIn]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_5: struct #46 - │ │ │ ├─ [contains]: string #37 - │ │ │ └─ [mode]: optional #45 - │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #47 - │ │ │ └─ [search]: string #37 - │ │ └─ variant_7: struct #48 - │ │ ├─ [startsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [endsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ [author]: optional '_66_UserWhere__skip_19_PostWhere?' #66 - │ └─ item: struct 'UserWhere__skip_19_PostWhere' #65 - │ ├─ [id]: optional '_54__integer_filter_c?' #54 - │ │ └─ item: optional '_integer_filter_c' #35 - │ │ └─ item: union #34 - │ │ ├─ variant_0: either '_integer_filter' #32 - │ │ │ ├─ variant_0: integer #24 - │ │ │ ├─ variant_1: struct #27 - │ │ │ │ └─ [equals]: integer #24 - │ │ │ ├─ variant_2: struct #28 - │ │ │ │ └─ [not]: integer #24 - │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ variant_4: struct #30 - │ │ │ │ └─ [in]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_5: struct #31 - │ │ │ └─ [notIn]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_1: struct #33 - │ │ └─ [not]: either '_integer_filter' #32 - │ │ ├─ variant_0: integer #24 - │ │ ├─ variant_1: struct #27 - │ │ │ └─ [equals]: integer #24 - │ │ ├─ variant_2: struct #28 - │ │ │ └─ [not]: integer #24 - │ │ ├─ variant_3: struct #29 - │ │ │ ├─ [lt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [gt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [lte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ [gte]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ variant_4: struct #30 - │ │ │ └─ [in]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_5: struct #31 - │ │ └─ [notIn]: list #26 - │ │ └─ item: integer #24 - │ ├─ [name]: optional '_55__string_filter_c?' #55 - │ │ └─ item: optional '_string_filter_c' #52 - │ │ └─ item: union #51 - │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ variant_1: struct #50 - │ │ └─ [not]: union '_string_filter' #49 - │ │ ├─ variant_0: string #37 - │ │ ├─ variant_1: struct #40 - │ │ │ └─ [equals]: string #37 - │ │ ├─ variant_2: struct #41 - │ │ │ └─ [not]: string #37 - │ │ ├─ variant_3: struct #42 - │ │ │ └─ [in]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_4: struct #43 - │ │ │ └─ [notIn]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_5: struct #46 - │ │ │ ├─ [contains]: string #37 - │ │ │ └─ [mode]: optional #45 - │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #47 - │ │ │ └─ [search]: string #37 - │ │ └─ variant_7: struct #48 - │ │ ├─ [startsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [endsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ [posts]: optional #64 - │ └─ item: union #63 - │ ├─ variant_0: struct #58 - │ │ └─ [every]: optional '_57_PostWhere?' #57 - │ │ └─ item: &PostWhere #56 - │ ├─ variant_1: struct #60 - │ │ └─ [some]: optional '_59_PostWhere?' #59 - │ │ └─ item: &PostWhere #56 - │ └─ variant_2: struct #62 - │ └─ [none]: optional '_61_PostWhere?' #61 - │ └─ item: &PostWhere #56 + │ └─ [title]: optional '_53__string_filter_c?' #53 + │ └─ item: optional '_string_filter_c' #52 + │ └─ item: union #51 + │ ├─ variant_0: union '_string_filter' #49 + │ │ ├─ variant_0: string #37 + │ │ ├─ variant_1: struct #40 + │ │ │ └─ [equals]: string #37 + │ │ ├─ variant_2: struct #41 + │ │ │ └─ [not]: string #37 + │ │ ├─ variant_3: struct #42 + │ │ │ └─ [in]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_4: struct #43 + │ │ │ └─ [notIn]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_5: struct #46 + │ │ │ ├─ [contains]: string #37 + │ │ │ └─ [mode]: optional #45 + │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #47 + │ │ │ └─ [search]: string #37 + │ │ └─ variant_7: struct #48 + │ │ ├─ [endsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [startsWith]: optional #38 + │ │ └─ item: string #37 + │ └─ variant_1: struct #50 + │ └─ [not]: union '_string_filter' #49 + │ ├─ variant_0: string #37 + │ ├─ variant_1: struct #40 + │ │ └─ [equals]: string #37 + │ ├─ variant_2: struct #41 + │ │ └─ [not]: string #37 + │ ├─ variant_3: struct #42 + │ │ └─ [in]: list #39 + │ │ └─ item: string #37 + │ ├─ variant_4: struct #43 + │ │ └─ [notIn]: list #39 + │ │ └─ item: string #37 + │ ├─ variant_5: struct #46 + │ │ ├─ [contains]: string #37 + │ │ └─ [mode]: optional #45 + │ │ └─ item: string #44 enum{ '"insensitive"' } + │ ├─ variant_6: struct #47 + │ │ └─ [search]: string #37 + │ └─ variant_7: struct #48 + │ ├─ [endsWith]: optional #38 + │ │ └─ item: string #37 + │ └─ [startsWith]: optional #38 + │ └─ item: string #37 ├─ variant_2: struct #73 │ └─ [connectOrCreate]: struct #70 │ ├─ [create]: union #23 @@ -449,6 +449,115 @@ root: struct #82 │ │ └─ [title]: string #17 │ └─ [where]: union #69 │ ├─ variant_0: struct 'PostWhere' #67 + │ │ ├─ [author]: optional '_66_UserWhere__skip_19_PostWhere?' #66 + │ │ │ └─ item: struct 'UserWhere__skip_19_PostWhere' #65 + │ │ │ ├─ [id]: optional '_54__integer_filter_c?' #54 + │ │ │ │ └─ item: optional '_integer_filter_c' #35 + │ │ │ │ └─ item: union #34 + │ │ │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_1: struct #33 + │ │ │ │ └─ [not]: either '_integer_filter' #32 + │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ [name]: optional '_55__string_filter_c?' #55 + │ │ │ │ └─ item: optional '_string_filter_c' #52 + │ │ │ │ └─ item: union #51 + │ │ │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ │ │ ├─ variant_0: string #37 + │ │ │ │ │ ├─ variant_1: struct #40 + │ │ │ │ │ │ └─ [equals]: string #37 + │ │ │ │ │ ├─ variant_2: struct #41 + │ │ │ │ │ │ └─ [not]: string #37 + │ │ │ │ │ ├─ variant_3: struct #42 + │ │ │ │ │ │ └─ [in]: list #39 + │ │ │ │ │ │ └─ item: string #37 + │ │ │ │ │ ├─ variant_4: struct #43 + │ │ │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ │ │ └─ item: string #37 + │ │ │ │ │ ├─ variant_5: struct #46 + │ │ │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ │ │ ├─ variant_6: struct #47 + │ │ │ │ │ │ └─ [search]: string #37 + │ │ │ │ │ └─ variant_7: struct #48 + │ │ │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ │ │ └─ item: string #37 + │ │ │ │ │ └─ [startsWith]: optional #38 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ └─ variant_1: struct #50 + │ │ │ │ └─ [not]: union '_string_filter' #49 + │ │ │ │ ├─ variant_0: string #37 + │ │ │ │ ├─ variant_1: struct #40 + │ │ │ │ │ └─ [equals]: string #37 + │ │ │ │ ├─ variant_2: struct #41 + │ │ │ │ │ └─ [not]: string #37 + │ │ │ │ ├─ variant_3: struct #42 + │ │ │ │ │ └─ [in]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_4: struct #43 + │ │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_5: struct #46 + │ │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #47 + │ │ │ │ │ └─ [search]: string #37 + │ │ │ │ └─ variant_7: struct #48 + │ │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ └─ [startsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [posts]: optional #64 + │ │ │ └─ item: union #63 + │ │ │ ├─ variant_0: struct #58 + │ │ │ │ └─ [every]: optional '_57_PostWhere?' #57 + │ │ │ │ └─ item: &PostWhere #56 + │ │ │ ├─ variant_1: struct #60 + │ │ │ │ └─ [some]: optional '_59_PostWhere?' #59 + │ │ │ │ └─ item: &PostWhere #56 + │ │ │ └─ variant_2: struct #62 + │ │ │ └─ [none]: optional '_61_PostWhere?' #61 + │ │ │ └─ item: &PostWhere #56 │ │ ├─ [id]: optional '_36__integer_filter_c?' #36 │ │ │ └─ item: optional '_integer_filter_c' #35 │ │ │ └─ item: union #34 @@ -459,13 +568,13 @@ root: struct #82 │ │ │ │ ├─ variant_2: struct #28 │ │ │ │ │ └─ [not]: integer #24 │ │ │ │ ├─ variant_3: struct #29 - │ │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 │ │ │ │ │ ├─ [gt]: optional #25 │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ ├─ [lte]: optional #25 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ └─ [gte]: optional #25 + │ │ │ │ │ └─ [lte]: optional #25 │ │ │ │ │ └─ item: integer #24 │ │ │ │ ├─ variant_4: struct #30 │ │ │ │ │ └─ [in]: list #26 @@ -481,13 +590,13 @@ root: struct #82 │ │ │ ├─ variant_2: struct #28 │ │ │ │ └─ [not]: integer #24 │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 │ │ │ │ ├─ [gt]: optional #25 │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 + │ │ │ │ └─ [lte]: optional #25 │ │ │ │ └─ item: integer #24 │ │ │ ├─ variant_4: struct #30 │ │ │ │ └─ [in]: list #26 @@ -495,167 +604,167 @@ root: struct #82 │ │ │ └─ variant_5: struct #31 │ │ │ └─ [notIn]: list #26 │ │ │ └─ item: integer #24 - │ │ ├─ [title]: optional '_53__string_filter_c?' #53 - │ │ │ └─ item: optional '_string_filter_c' #52 - │ │ │ └─ item: union #51 - │ │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ │ ├─ variant_0: string #37 - │ │ │ │ ├─ variant_1: struct #40 - │ │ │ │ │ └─ [equals]: string #37 - │ │ │ │ ├─ variant_2: struct #41 - │ │ │ │ │ └─ [not]: string #37 - │ │ │ │ ├─ variant_3: struct #42 - │ │ │ │ │ └─ [in]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_4: struct #43 - │ │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_5: struct #46 - │ │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #47 - │ │ │ │ │ └─ [search]: string #37 - │ │ │ │ └─ variant_7: struct #48 - │ │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ └─ [endsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ variant_1: struct #50 - │ │ │ └─ [not]: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [author]: optional '_66_UserWhere__skip_19_PostWhere?' #66 - │ │ └─ item: struct 'UserWhere__skip_19_PostWhere' #65 - │ │ ├─ [id]: optional '_54__integer_filter_c?' #54 - │ │ │ └─ item: optional '_integer_filter_c' #35 - │ │ │ └─ item: union #34 - │ │ │ ├─ variant_0: either '_integer_filter' #32 - │ │ │ │ ├─ variant_0: integer #24 - │ │ │ │ ├─ variant_1: struct #27 - │ │ │ │ │ └─ [equals]: integer #24 - │ │ │ │ ├─ variant_2: struct #28 - │ │ │ │ │ └─ [not]: integer #24 - │ │ │ │ ├─ variant_3: struct #29 - │ │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ │ └─ item: integer #24 - │ │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ variant_4: struct #30 - │ │ │ │ │ └─ [in]: list #26 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ variant_5: struct #31 - │ │ │ │ └─ [notIn]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_1: struct #33 - │ │ │ └─ [not]: either '_integer_filter' #32 - │ │ │ ├─ variant_0: integer #24 - │ │ │ ├─ variant_1: struct #27 - │ │ │ │ └─ [equals]: integer #24 - │ │ │ ├─ variant_2: struct #28 - │ │ │ │ └─ [not]: integer #24 - │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ variant_4: struct #30 - │ │ │ │ └─ [in]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_5: struct #31 - │ │ │ └─ [notIn]: list #26 - │ │ │ └─ item: integer #24 - │ │ ├─ [name]: optional '_55__string_filter_c?' #55 - │ │ │ └─ item: optional '_string_filter_c' #52 - │ │ │ └─ item: union #51 - │ │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ │ ├─ variant_0: string #37 - │ │ │ │ ├─ variant_1: struct #40 - │ │ │ │ │ └─ [equals]: string #37 - │ │ │ │ ├─ variant_2: struct #41 - │ │ │ │ │ └─ [not]: string #37 - │ │ │ │ ├─ variant_3: struct #42 - │ │ │ │ │ └─ [in]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_4: struct #43 - │ │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ ├─ variant_5: struct #46 - │ │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #47 - │ │ │ │ │ └─ [search]: string #37 - │ │ │ │ └─ variant_7: struct #48 - │ │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ │ └─ item: string #37 - │ │ │ │ └─ [endsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ variant_1: struct #50 - │ │ │ └─ [not]: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [posts]: optional #64 - │ │ └─ item: union #63 - │ │ ├─ variant_0: struct #58 - │ │ │ └─ [every]: optional '_57_PostWhere?' #57 - │ │ │ └─ item: &PostWhere #56 - │ │ ├─ variant_1: struct #60 - │ │ │ └─ [some]: optional '_59_PostWhere?' #59 - │ │ │ └─ item: &PostWhere #56 - │ │ └─ variant_2: struct #62 - │ │ └─ [none]: optional '_61_PostWhere?' #61 - │ │ └─ item: &PostWhere #56 + │ │ └─ [title]: optional '_53__string_filter_c?' #53 + │ │ └─ item: optional '_string_filter_c' #52 + │ │ └─ item: union #51 + │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ variant_1: struct #50 + │ │ └─ [not]: union '_string_filter' #49 + │ │ ├─ variant_0: string #37 + │ │ ├─ variant_1: struct #40 + │ │ │ └─ [equals]: string #37 + │ │ ├─ variant_2: struct #41 + │ │ │ └─ [not]: string #37 + │ │ ├─ variant_3: struct #42 + │ │ │ └─ [in]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_4: struct #43 + │ │ │ └─ [notIn]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_5: struct #46 + │ │ │ ├─ [contains]: string #37 + │ │ │ └─ [mode]: optional #45 + │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #47 + │ │ │ └─ [search]: string #37 + │ │ └─ variant_7: struct #48 + │ │ ├─ [endsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [startsWith]: optional #38 + │ │ └─ item: string #37 │ └─ variant_1: list '_68_PostWhere[]' #68 │ └─ item: struct 'PostWhere' #67 + │ ├─ [author]: optional '_66_UserWhere__skip_19_PostWhere?' #66 + │ │ └─ item: struct 'UserWhere__skip_19_PostWhere' #65 + │ │ ├─ [id]: optional '_54__integer_filter_c?' #54 + │ │ │ └─ item: optional '_integer_filter_c' #35 + │ │ │ └─ item: union #34 + │ │ │ ├─ variant_0: either '_integer_filter' #32 + │ │ │ │ ├─ variant_0: integer #24 + │ │ │ │ ├─ variant_1: struct #27 + │ │ │ │ │ └─ [equals]: integer #24 + │ │ │ │ ├─ variant_2: struct #28 + │ │ │ │ │ └─ [not]: integer #24 + │ │ │ │ ├─ variant_3: struct #29 + │ │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ │ └─ item: integer #24 + │ │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ variant_4: struct #30 + │ │ │ │ │ └─ [in]: list #26 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ variant_5: struct #31 + │ │ │ │ └─ [notIn]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_1: struct #33 + │ │ │ └─ [not]: either '_integer_filter' #32 + │ │ │ ├─ variant_0: integer #24 + │ │ │ ├─ variant_1: struct #27 + │ │ │ │ └─ [equals]: integer #24 + │ │ │ ├─ variant_2: struct #28 + │ │ │ │ └─ [not]: integer #24 + │ │ │ ├─ variant_3: struct #29 + │ │ │ │ ├─ [gt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ └─ [lte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ variant_4: struct #30 + │ │ │ │ └─ [in]: list #26 + │ │ │ │ └─ item: integer #24 + │ │ │ └─ variant_5: struct #31 + │ │ │ └─ [notIn]: list #26 + │ │ │ └─ item: integer #24 + │ │ ├─ [name]: optional '_55__string_filter_c?' #55 + │ │ │ └─ item: optional '_string_filter_c' #52 + │ │ │ └─ item: union #51 + │ │ │ ├─ variant_0: union '_string_filter' #49 + │ │ │ │ ├─ variant_0: string #37 + │ │ │ │ ├─ variant_1: struct #40 + │ │ │ │ │ └─ [equals]: string #37 + │ │ │ │ ├─ variant_2: struct #41 + │ │ │ │ │ └─ [not]: string #37 + │ │ │ │ ├─ variant_3: struct #42 + │ │ │ │ │ └─ [in]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_4: struct #43 + │ │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ ├─ variant_5: struct #46 + │ │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #47 + │ │ │ │ │ └─ [search]: string #37 + │ │ │ │ └─ variant_7: struct #48 + │ │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ │ └─ item: string #37 + │ │ │ │ └─ [startsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ variant_1: struct #50 + │ │ │ └─ [not]: union '_string_filter' #49 + │ │ │ ├─ variant_0: string #37 + │ │ │ ├─ variant_1: struct #40 + │ │ │ │ └─ [equals]: string #37 + │ │ │ ├─ variant_2: struct #41 + │ │ │ │ └─ [not]: string #37 + │ │ │ ├─ variant_3: struct #42 + │ │ │ │ └─ [in]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_4: struct #43 + │ │ │ │ └─ [notIn]: list #39 + │ │ │ │ └─ item: string #37 + │ │ │ ├─ variant_5: struct #46 + │ │ │ │ ├─ [contains]: string #37 + │ │ │ │ └─ [mode]: optional #45 + │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #47 + │ │ │ │ └─ [search]: string #37 + │ │ │ └─ variant_7: struct #48 + │ │ │ ├─ [endsWith]: optional #38 + │ │ │ │ └─ item: string #37 + │ │ │ └─ [startsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [posts]: optional #64 + │ │ └─ item: union #63 + │ │ ├─ variant_0: struct #58 + │ │ │ └─ [every]: optional '_57_PostWhere?' #57 + │ │ │ └─ item: &PostWhere #56 + │ │ ├─ variant_1: struct #60 + │ │ │ └─ [some]: optional '_59_PostWhere?' #59 + │ │ │ └─ item: &PostWhere #56 + │ │ └─ variant_2: struct #62 + │ │ └─ [none]: optional '_61_PostWhere?' #61 + │ │ └─ item: &PostWhere #56 │ ├─ [id]: optional '_36__integer_filter_c?' #36 │ │ └─ item: optional '_integer_filter_c' #35 │ │ └─ item: union #34 @@ -666,13 +775,13 @@ root: struct #82 │ │ │ ├─ variant_2: struct #28 │ │ │ │ └─ [not]: integer #24 │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 │ │ │ │ ├─ [gt]: optional #25 │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 + │ │ │ │ ├─ [gte]: optional #25 + │ │ │ │ │ └─ item: integer #24 + │ │ │ │ ├─ [lt]: optional #25 │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 + │ │ │ │ └─ [lte]: optional #25 │ │ │ │ └─ item: integer #24 │ │ │ ├─ variant_4: struct #30 │ │ │ │ └─ [in]: list #26 @@ -688,13 +797,13 @@ root: struct #82 │ │ ├─ variant_2: struct #28 │ │ │ └─ [not]: integer #24 │ │ ├─ variant_3: struct #29 - │ │ │ ├─ [lt]: optional #25 - │ │ │ │ └─ item: integer #24 │ │ │ ├─ [gt]: optional #25 │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [lte]: optional #25 + │ │ │ ├─ [gte]: optional #25 + │ │ │ │ └─ item: integer #24 + │ │ │ ├─ [lt]: optional #25 │ │ │ │ └─ item: integer #24 - │ │ │ └─ [gte]: optional #25 + │ │ │ └─ [lte]: optional #25 │ │ │ └─ item: integer #24 │ │ ├─ variant_4: struct #30 │ │ │ └─ [in]: list #26 @@ -702,165 +811,56 @@ root: struct #82 │ │ └─ variant_5: struct #31 │ │ └─ [notIn]: list #26 │ │ └─ item: integer #24 - │ ├─ [title]: optional '_53__string_filter_c?' #53 - │ │ └─ item: optional '_string_filter_c' #52 - │ │ └─ item: union #51 - │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ variant_1: struct #50 - │ │ └─ [not]: union '_string_filter' #49 - │ │ ├─ variant_0: string #37 - │ │ ├─ variant_1: struct #40 - │ │ │ └─ [equals]: string #37 - │ │ ├─ variant_2: struct #41 - │ │ │ └─ [not]: string #37 - │ │ ├─ variant_3: struct #42 - │ │ │ └─ [in]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_4: struct #43 - │ │ │ └─ [notIn]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_5: struct #46 - │ │ │ ├─ [contains]: string #37 - │ │ │ └─ [mode]: optional #45 - │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #47 - │ │ │ └─ [search]: string #37 - │ │ └─ variant_7: struct #48 - │ │ ├─ [startsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [endsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ [author]: optional '_66_UserWhere__skip_19_PostWhere?' #66 - │ └─ item: struct 'UserWhere__skip_19_PostWhere' #65 - │ ├─ [id]: optional '_54__integer_filter_c?' #54 - │ │ └─ item: optional '_integer_filter_c' #35 - │ │ └─ item: union #34 - │ │ ├─ variant_0: either '_integer_filter' #32 - │ │ │ ├─ variant_0: integer #24 - │ │ │ ├─ variant_1: struct #27 - │ │ │ │ └─ [equals]: integer #24 - │ │ │ ├─ variant_2: struct #28 - │ │ │ │ └─ [not]: integer #24 - │ │ │ ├─ variant_3: struct #29 - │ │ │ │ ├─ [lt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [gt]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ ├─ [lte]: optional #25 - │ │ │ │ │ └─ item: integer #24 - │ │ │ │ └─ [gte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ variant_4: struct #30 - │ │ │ │ └─ [in]: list #26 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ variant_5: struct #31 - │ │ │ └─ [notIn]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_1: struct #33 - │ │ └─ [not]: either '_integer_filter' #32 - │ │ ├─ variant_0: integer #24 - │ │ ├─ variant_1: struct #27 - │ │ │ └─ [equals]: integer #24 - │ │ ├─ variant_2: struct #28 - │ │ │ └─ [not]: integer #24 - │ │ ├─ variant_3: struct #29 - │ │ │ ├─ [lt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [gt]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ ├─ [lte]: optional #25 - │ │ │ │ └─ item: integer #24 - │ │ │ └─ [gte]: optional #25 - │ │ │ └─ item: integer #24 - │ │ ├─ variant_4: struct #30 - │ │ │ └─ [in]: list #26 - │ │ │ └─ item: integer #24 - │ │ └─ variant_5: struct #31 - │ │ └─ [notIn]: list #26 - │ │ └─ item: integer #24 - │ ├─ [name]: optional '_55__string_filter_c?' #55 - │ │ └─ item: optional '_string_filter_c' #52 - │ │ └─ item: union #51 - │ │ ├─ variant_0: union '_string_filter' #49 - │ │ │ ├─ variant_0: string #37 - │ │ │ ├─ variant_1: struct #40 - │ │ │ │ └─ [equals]: string #37 - │ │ │ ├─ variant_2: struct #41 - │ │ │ │ └─ [not]: string #37 - │ │ │ ├─ variant_3: struct #42 - │ │ │ │ └─ [in]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_4: struct #43 - │ │ │ │ └─ [notIn]: list #39 - │ │ │ │ └─ item: string #37 - │ │ │ ├─ variant_5: struct #46 - │ │ │ │ ├─ [contains]: string #37 - │ │ │ │ └─ [mode]: optional #45 - │ │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #47 - │ │ │ │ └─ [search]: string #37 - │ │ │ └─ variant_7: struct #48 - │ │ │ ├─ [startsWith]: optional #38 - │ │ │ │ └─ item: string #37 - │ │ │ └─ [endsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ variant_1: struct #50 - │ │ └─ [not]: union '_string_filter' #49 - │ │ ├─ variant_0: string #37 - │ │ ├─ variant_1: struct #40 - │ │ │ └─ [equals]: string #37 - │ │ ├─ variant_2: struct #41 - │ │ │ └─ [not]: string #37 - │ │ ├─ variant_3: struct #42 - │ │ │ └─ [in]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_4: struct #43 - │ │ │ └─ [notIn]: list #39 - │ │ │ └─ item: string #37 - │ │ ├─ variant_5: struct #46 - │ │ │ ├─ [contains]: string #37 - │ │ │ └─ [mode]: optional #45 - │ │ │ └─ item: string #44 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #47 - │ │ │ └─ [search]: string #37 - │ │ └─ variant_7: struct #48 - │ │ ├─ [startsWith]: optional #38 - │ │ │ └─ item: string #37 - │ │ └─ [endsWith]: optional #38 - │ │ └─ item: string #37 - │ └─ [posts]: optional #64 - │ └─ item: union #63 - │ ├─ variant_0: struct #58 - │ │ └─ [every]: optional '_57_PostWhere?' #57 - │ │ └─ item: &PostWhere #56 - │ ├─ variant_1: struct #60 - │ │ └─ [some]: optional '_59_PostWhere?' #59 - │ │ └─ item: &PostWhere #56 - │ └─ variant_2: struct #62 - │ └─ [none]: optional '_61_PostWhere?' #61 - │ └─ item: &PostWhere #56 + │ └─ [title]: optional '_53__string_filter_c?' #53 + │ └─ item: optional '_string_filter_c' #52 + │ └─ item: union #51 + │ ├─ variant_0: union '_string_filter' #49 + │ │ ├─ variant_0: string #37 + │ │ ├─ variant_1: struct #40 + │ │ │ └─ [equals]: string #37 + │ │ ├─ variant_2: struct #41 + │ │ │ └─ [not]: string #37 + │ │ ├─ variant_3: struct #42 + │ │ │ └─ [in]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_4: struct #43 + │ │ │ └─ [notIn]: list #39 + │ │ │ └─ item: string #37 + │ │ ├─ variant_5: struct #46 + │ │ │ ├─ [contains]: string #37 + │ │ │ └─ [mode]: optional #45 + │ │ │ └─ item: string #44 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #47 + │ │ │ └─ [search]: string #37 + │ │ └─ variant_7: struct #48 + │ │ ├─ [endsWith]: optional #38 + │ │ │ └─ item: string #37 + │ │ └─ [startsWith]: optional #38 + │ │ └─ item: string #37 + │ └─ variant_1: struct #50 + │ └─ [not]: union '_string_filter' #49 + │ ├─ variant_0: string #37 + │ ├─ variant_1: struct #40 + │ │ └─ [equals]: string #37 + │ ├─ variant_2: struct #41 + │ │ └─ [not]: string #37 + │ ├─ variant_3: struct #42 + │ │ └─ [in]: list #39 + │ │ └─ item: string #37 + │ ├─ variant_4: struct #43 + │ │ └─ [notIn]: list #39 + │ │ └─ item: string #37 + │ ├─ variant_5: struct #46 + │ │ ├─ [contains]: string #37 + │ │ └─ [mode]: optional #45 + │ │ └─ item: string #44 enum{ '"insensitive"' } + │ ├─ variant_6: struct #47 + │ │ └─ [search]: string #37 + │ └─ variant_7: struct #48 + │ ├─ [endsWith]: optional #38 + │ │ └─ item: string #37 + │ └─ [startsWith]: optional #38 + │ └─ item: string #37 └─ variant_3: struct #77 └─ [createMany]: optional #76 └─ item: struct #75 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many User out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many User out.snap index 46ab6f2c2..5749cfc9d 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many User out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_many User out.snap @@ -1,6 +1,6 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: struct #84 └─ [count]: integer #83 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one Post inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one Post inp.snap index b85f6ab7f..b317d1fbc 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one Post inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one Post inp.snap @@ -1,825 +1,825 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #103 └─ [data]: struct '_Post_CreateInput' #102 + ├─ [author]: union #101 + │ ├─ variant_0: struct #98 + │ │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #80 + │ │ ├─ [id]: integer #8 + │ │ └─ [name]: string #9 + │ ├─ variant_1: struct #99 + │ │ └─ [connect]: struct 'UserWhere' #96 + │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 + │ │ │ └─ item: optional '_integer_filter_c' #32 + │ │ │ └─ item: union #31 + │ │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_1: struct #30 + │ │ │ └─ [not]: either '_integer_filter' #29 + │ │ │ ├─ variant_0: integer #21 + │ │ │ ├─ variant_1: struct #24 + │ │ │ │ └─ [equals]: integer #21 + │ │ │ ├─ variant_2: struct #25 + │ │ │ │ └─ [not]: integer #21 + │ │ │ ├─ variant_3: struct #26 + │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ variant_4: struct #27 + │ │ │ │ └─ [in]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_5: struct #28 + │ │ │ └─ [notIn]: list #23 + │ │ │ └─ item: integer #21 + │ │ ├─ [name]: optional '_82__string_filter_c?' #82 + │ │ │ └─ item: optional '_string_filter_c' #49 + │ │ │ └─ item: union #48 + │ │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ │ ├─ variant_0: string #34 + │ │ │ │ ├─ variant_1: struct #37 + │ │ │ │ │ └─ [equals]: string #34 + │ │ │ │ ├─ variant_2: struct #38 + │ │ │ │ │ └─ [not]: string #34 + │ │ │ │ ├─ variant_3: struct #39 + │ │ │ │ │ └─ [in]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_4: struct #40 + │ │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_5: struct #43 + │ │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #44 + │ │ │ │ │ └─ [search]: string #34 + │ │ │ │ └─ variant_7: struct #45 + │ │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ └─ [startsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ variant_1: struct #47 + │ │ │ └─ [not]: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [posts]: optional #95 + │ │ └─ item: union #94 + │ │ ├─ variant_0: struct #89 + │ │ │ └─ [every]: optional '_88_PostWhere__skip_12_UserWhere?' #88 + │ │ │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 + │ │ │ ├─ [author]: optional '_86_UserWhere?' #86 + │ │ │ │ └─ item: &UserWhere #85 + │ │ │ ├─ [id]: optional '_83__integer_filter_c?' #83 + │ │ │ │ └─ item: optional '_integer_filter_c' #32 + │ │ │ │ └─ item: union #31 + │ │ │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_1: struct #30 + │ │ │ │ └─ [not]: either '_integer_filter' #29 + │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ [title]: optional '_84__string_filter_c?' #84 + │ │ │ └─ item: optional '_string_filter_c' #49 + │ │ │ └─ item: union #48 + │ │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ │ ├─ variant_0: string #34 + │ │ │ │ ├─ variant_1: struct #37 + │ │ │ │ │ └─ [equals]: string #34 + │ │ │ │ ├─ variant_2: struct #38 + │ │ │ │ │ └─ [not]: string #34 + │ │ │ │ ├─ variant_3: struct #39 + │ │ │ │ │ └─ [in]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_4: struct #40 + │ │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_5: struct #43 + │ │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #44 + │ │ │ │ │ └─ [search]: string #34 + │ │ │ │ └─ variant_7: struct #45 + │ │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ └─ [startsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ variant_1: struct #47 + │ │ │ └─ [not]: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ ├─ variant_1: struct #91 + │ │ │ └─ [some]: optional '_90_PostWhere__skip_12_UserWhere?' #90 + │ │ │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 + │ │ │ ├─ [author]: optional '_86_UserWhere?' #86 + │ │ │ │ └─ item: &UserWhere #85 + │ │ │ ├─ [id]: optional '_83__integer_filter_c?' #83 + │ │ │ │ └─ item: optional '_integer_filter_c' #32 + │ │ │ │ └─ item: union #31 + │ │ │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_1: struct #30 + │ │ │ │ └─ [not]: either '_integer_filter' #29 + │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ [title]: optional '_84__string_filter_c?' #84 + │ │ │ └─ item: optional '_string_filter_c' #49 + │ │ │ └─ item: union #48 + │ │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ │ ├─ variant_0: string #34 + │ │ │ │ ├─ variant_1: struct #37 + │ │ │ │ │ └─ [equals]: string #34 + │ │ │ │ ├─ variant_2: struct #38 + │ │ │ │ │ └─ [not]: string #34 + │ │ │ │ ├─ variant_3: struct #39 + │ │ │ │ │ └─ [in]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_4: struct #40 + │ │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_5: struct #43 + │ │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #44 + │ │ │ │ │ └─ [search]: string #34 + │ │ │ │ └─ variant_7: struct #45 + │ │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ └─ [startsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ variant_1: struct #47 + │ │ │ └─ [not]: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ variant_2: struct #93 + │ │ └─ [none]: optional '_92_PostWhere__skip_12_UserWhere?' #92 + │ │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 + │ │ ├─ [author]: optional '_86_UserWhere?' #86 + │ │ │ └─ item: &UserWhere #85 + │ │ ├─ [id]: optional '_83__integer_filter_c?' #83 + │ │ │ └─ item: optional '_integer_filter_c' #32 + │ │ │ └─ item: union #31 + │ │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_1: struct #30 + │ │ │ └─ [not]: either '_integer_filter' #29 + │ │ │ ├─ variant_0: integer #21 + │ │ │ ├─ variant_1: struct #24 + │ │ │ │ └─ [equals]: integer #21 + │ │ │ ├─ variant_2: struct #25 + │ │ │ │ └─ [not]: integer #21 + │ │ │ ├─ variant_3: struct #26 + │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ variant_4: struct #27 + │ │ │ │ └─ [in]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_5: struct #28 + │ │ │ └─ [notIn]: list #23 + │ │ │ └─ item: integer #21 + │ │ └─ [title]: optional '_84__string_filter_c?' #84 + │ │ └─ item: optional '_string_filter_c' #49 + │ │ └─ item: union #48 + │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ variant_1: struct #47 + │ │ └─ [not]: union '_string_filter' #46 + │ │ ├─ variant_0: string #34 + │ │ ├─ variant_1: struct #37 + │ │ │ └─ [equals]: string #34 + │ │ ├─ variant_2: struct #38 + │ │ │ └─ [not]: string #34 + │ │ ├─ variant_3: struct #39 + │ │ │ └─ [in]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_4: struct #40 + │ │ │ └─ [notIn]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_5: struct #43 + │ │ │ ├─ [contains]: string #34 + │ │ │ └─ [mode]: optional #42 + │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #44 + │ │ │ └─ [search]: string #34 + │ │ └─ variant_7: struct #45 + │ │ ├─ [endsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [startsWith]: optional #35 + │ │ └─ item: string #34 + │ └─ variant_2: struct #100 + │ └─ [connectOrCreate]: struct #97 + │ ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #80 + │ │ ├─ [id]: integer #8 + │ │ └─ [name]: string #9 + │ └─ [where]: struct 'UserWhere' #96 + │ ├─ [id]: optional '_81__integer_filter_c?' #81 + │ │ └─ item: optional '_integer_filter_c' #32 + │ │ └─ item: union #31 + │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ ├─ variant_0: integer #21 + │ │ │ ├─ variant_1: struct #24 + │ │ │ │ └─ [equals]: integer #21 + │ │ │ ├─ variant_2: struct #25 + │ │ │ │ └─ [not]: integer #21 + │ │ │ ├─ variant_3: struct #26 + │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ variant_4: struct #27 + │ │ │ │ └─ [in]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_5: struct #28 + │ │ │ └─ [notIn]: list #23 + │ │ │ └─ item: integer #21 + │ │ └─ variant_1: struct #30 + │ │ └─ [not]: either '_integer_filter' #29 + │ │ ├─ variant_0: integer #21 + │ │ ├─ variant_1: struct #24 + │ │ │ └─ [equals]: integer #21 + │ │ ├─ variant_2: struct #25 + │ │ │ └─ [not]: integer #21 + │ │ ├─ variant_3: struct #26 + │ │ │ ├─ [gt]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ [gte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ [lt]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ [lte]: optional #22 + │ │ │ └─ item: integer #21 + │ │ ├─ variant_4: struct #27 + │ │ │ └─ [in]: list #23 + │ │ │ └─ item: integer #21 + │ │ └─ variant_5: struct #28 + │ │ └─ [notIn]: list #23 + │ │ └─ item: integer #21 + │ ├─ [name]: optional '_82__string_filter_c?' #82 + │ │ └─ item: optional '_string_filter_c' #49 + │ │ └─ item: union #48 + │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ variant_1: struct #47 + │ │ └─ [not]: union '_string_filter' #46 + │ │ ├─ variant_0: string #34 + │ │ ├─ variant_1: struct #37 + │ │ │ └─ [equals]: string #34 + │ │ ├─ variant_2: struct #38 + │ │ │ └─ [not]: string #34 + │ │ ├─ variant_3: struct #39 + │ │ │ └─ [in]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_4: struct #40 + │ │ │ └─ [notIn]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_5: struct #43 + │ │ │ ├─ [contains]: string #34 + │ │ │ └─ [mode]: optional #42 + │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #44 + │ │ │ └─ [search]: string #34 + │ │ └─ variant_7: struct #45 + │ │ ├─ [endsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [startsWith]: optional #35 + │ │ └─ item: string #34 + │ └─ [posts]: optional #95 + │ └─ item: union #94 + │ ├─ variant_0: struct #89 + │ │ └─ [every]: optional '_88_PostWhere__skip_12_UserWhere?' #88 + │ │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 + │ │ ├─ [author]: optional '_86_UserWhere?' #86 + │ │ │ └─ item: &UserWhere #85 + │ │ ├─ [id]: optional '_83__integer_filter_c?' #83 + │ │ │ └─ item: optional '_integer_filter_c' #32 + │ │ │ └─ item: union #31 + │ │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_1: struct #30 + │ │ │ └─ [not]: either '_integer_filter' #29 + │ │ │ ├─ variant_0: integer #21 + │ │ │ ├─ variant_1: struct #24 + │ │ │ │ └─ [equals]: integer #21 + │ │ │ ├─ variant_2: struct #25 + │ │ │ │ └─ [not]: integer #21 + │ │ │ ├─ variant_3: struct #26 + │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ variant_4: struct #27 + │ │ │ │ └─ [in]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_5: struct #28 + │ │ │ └─ [notIn]: list #23 + │ │ │ └─ item: integer #21 + │ │ └─ [title]: optional '_84__string_filter_c?' #84 + │ │ └─ item: optional '_string_filter_c' #49 + │ │ └─ item: union #48 + │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ variant_1: struct #47 + │ │ └─ [not]: union '_string_filter' #46 + │ │ ├─ variant_0: string #34 + │ │ ├─ variant_1: struct #37 + │ │ │ └─ [equals]: string #34 + │ │ ├─ variant_2: struct #38 + │ │ │ └─ [not]: string #34 + │ │ ├─ variant_3: struct #39 + │ │ │ └─ [in]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_4: struct #40 + │ │ │ └─ [notIn]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_5: struct #43 + │ │ │ ├─ [contains]: string #34 + │ │ │ └─ [mode]: optional #42 + │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #44 + │ │ │ └─ [search]: string #34 + │ │ └─ variant_7: struct #45 + │ │ ├─ [endsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [startsWith]: optional #35 + │ │ └─ item: string #34 + │ ├─ variant_1: struct #91 + │ │ └─ [some]: optional '_90_PostWhere__skip_12_UserWhere?' #90 + │ │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 + │ │ ├─ [author]: optional '_86_UserWhere?' #86 + │ │ │ └─ item: &UserWhere #85 + │ │ ├─ [id]: optional '_83__integer_filter_c?' #83 + │ │ │ └─ item: optional '_integer_filter_c' #32 + │ │ │ └─ item: union #31 + │ │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_1: struct #30 + │ │ │ └─ [not]: either '_integer_filter' #29 + │ │ │ ├─ variant_0: integer #21 + │ │ │ ├─ variant_1: struct #24 + │ │ │ │ └─ [equals]: integer #21 + │ │ │ ├─ variant_2: struct #25 + │ │ │ │ └─ [not]: integer #21 + │ │ │ ├─ variant_3: struct #26 + │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ variant_4: struct #27 + │ │ │ │ └─ [in]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_5: struct #28 + │ │ │ └─ [notIn]: list #23 + │ │ │ └─ item: integer #21 + │ │ └─ [title]: optional '_84__string_filter_c?' #84 + │ │ └─ item: optional '_string_filter_c' #49 + │ │ └─ item: union #48 + │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ variant_1: struct #47 + │ │ └─ [not]: union '_string_filter' #46 + │ │ ├─ variant_0: string #34 + │ │ ├─ variant_1: struct #37 + │ │ │ └─ [equals]: string #34 + │ │ ├─ variant_2: struct #38 + │ │ │ └─ [not]: string #34 + │ │ ├─ variant_3: struct #39 + │ │ │ └─ [in]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_4: struct #40 + │ │ │ └─ [notIn]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_5: struct #43 + │ │ │ ├─ [contains]: string #34 + │ │ │ └─ [mode]: optional #42 + │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #44 + │ │ │ └─ [search]: string #34 + │ │ └─ variant_7: struct #45 + │ │ ├─ [endsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [startsWith]: optional #35 + │ │ └─ item: string #34 + │ └─ variant_2: struct #93 + │ └─ [none]: optional '_92_PostWhere__skip_12_UserWhere?' #92 + │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 + │ ├─ [author]: optional '_86_UserWhere?' #86 + │ │ └─ item: &UserWhere #85 + │ ├─ [id]: optional '_83__integer_filter_c?' #83 + │ │ └─ item: optional '_integer_filter_c' #32 + │ │ └─ item: union #31 + │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ ├─ variant_0: integer #21 + │ │ │ ├─ variant_1: struct #24 + │ │ │ │ └─ [equals]: integer #21 + │ │ │ ├─ variant_2: struct #25 + │ │ │ │ └─ [not]: integer #21 + │ │ │ ├─ variant_3: struct #26 + │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ variant_4: struct #27 + │ │ │ │ └─ [in]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_5: struct #28 + │ │ │ └─ [notIn]: list #23 + │ │ │ └─ item: integer #21 + │ │ └─ variant_1: struct #30 + │ │ └─ [not]: either '_integer_filter' #29 + │ │ ├─ variant_0: integer #21 + │ │ ├─ variant_1: struct #24 + │ │ │ └─ [equals]: integer #21 + │ │ ├─ variant_2: struct #25 + │ │ │ └─ [not]: integer #21 + │ │ ├─ variant_3: struct #26 + │ │ │ ├─ [gt]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ [gte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ [lt]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ [lte]: optional #22 + │ │ │ └─ item: integer #21 + │ │ ├─ variant_4: struct #27 + │ │ │ └─ [in]: list #23 + │ │ │ └─ item: integer #21 + │ │ └─ variant_5: struct #28 + │ │ └─ [notIn]: list #23 + │ │ └─ item: integer #21 + │ └─ [title]: optional '_84__string_filter_c?' #84 + │ └─ item: optional '_string_filter_c' #49 + │ └─ item: union #48 + │ ├─ variant_0: union '_string_filter' #46 + │ │ ├─ variant_0: string #34 + │ │ ├─ variant_1: struct #37 + │ │ │ └─ [equals]: string #34 + │ │ ├─ variant_2: struct #38 + │ │ │ └─ [not]: string #34 + │ │ ├─ variant_3: struct #39 + │ │ │ └─ [in]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_4: struct #40 + │ │ │ └─ [notIn]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_5: struct #43 + │ │ │ ├─ [contains]: string #34 + │ │ │ └─ [mode]: optional #42 + │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #44 + │ │ │ └─ [search]: string #34 + │ │ └─ variant_7: struct #45 + │ │ ├─ [endsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [startsWith]: optional #35 + │ │ └─ item: string #34 + │ └─ variant_1: struct #47 + │ └─ [not]: union '_string_filter' #46 + │ ├─ variant_0: string #34 + │ ├─ variant_1: struct #37 + │ │ └─ [equals]: string #34 + │ ├─ variant_2: struct #38 + │ │ └─ [not]: string #34 + │ ├─ variant_3: struct #39 + │ │ └─ [in]: list #36 + │ │ └─ item: string #34 + │ ├─ variant_4: struct #40 + │ │ └─ [notIn]: list #36 + │ │ └─ item: string #34 + │ ├─ variant_5: struct #43 + │ │ ├─ [contains]: string #34 + │ │ └─ [mode]: optional #42 + │ │ └─ item: string #41 enum{ '"insensitive"' } + │ ├─ variant_6: struct #44 + │ │ └─ [search]: string #34 + │ └─ variant_7: struct #45 + │ ├─ [endsWith]: optional #35 + │ │ └─ item: string #34 + │ └─ [startsWith]: optional #35 + │ └─ item: string #34 ├─ [id]: optional #79 │ └─ item: integer #13 - ├─ [title]: string #14 - └─ [author]: union #101 - ├─ variant_0: struct #98 - │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #80 - │ ├─ [id]: integer #8 - │ └─ [name]: string #9 - ├─ variant_1: struct #99 - │ └─ [connect]: struct 'UserWhere' #96 - │ ├─ [id]: optional '_81__integer_filter_c?' #81 - │ │ └─ item: optional '_integer_filter_c' #32 - │ │ └─ item: union #31 - │ │ ├─ variant_0: either '_integer_filter' #29 - │ │ │ ├─ variant_0: integer #21 - │ │ │ ├─ variant_1: struct #24 - │ │ │ │ └─ [equals]: integer #21 - │ │ │ ├─ variant_2: struct #25 - │ │ │ │ └─ [not]: integer #21 - │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ variant_4: struct #27 - │ │ │ │ └─ [in]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_5: struct #28 - │ │ │ └─ [notIn]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_1: struct #30 - │ │ └─ [not]: either '_integer_filter' #29 - │ │ ├─ variant_0: integer #21 - │ │ ├─ variant_1: struct #24 - │ │ │ └─ [equals]: integer #21 - │ │ ├─ variant_2: struct #25 - │ │ │ └─ [not]: integer #21 - │ │ ├─ variant_3: struct #26 - │ │ │ ├─ [lt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [gt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [lte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ [gte]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ variant_4: struct #27 - │ │ │ └─ [in]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_5: struct #28 - │ │ └─ [notIn]: list #23 - │ │ └─ item: integer #21 - │ ├─ [name]: optional '_82__string_filter_c?' #82 - │ │ └─ item: optional '_string_filter_c' #49 - │ │ └─ item: union #48 - │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ variant_1: struct #47 - │ │ └─ [not]: union '_string_filter' #46 - │ │ ├─ variant_0: string #34 - │ │ ├─ variant_1: struct #37 - │ │ │ └─ [equals]: string #34 - │ │ ├─ variant_2: struct #38 - │ │ │ └─ [not]: string #34 - │ │ ├─ variant_3: struct #39 - │ │ │ └─ [in]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_4: struct #40 - │ │ │ └─ [notIn]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_5: struct #43 - │ │ │ ├─ [contains]: string #34 - │ │ │ └─ [mode]: optional #42 - │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #44 - │ │ │ └─ [search]: string #34 - │ │ └─ variant_7: struct #45 - │ │ ├─ [startsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [endsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ [posts]: optional #95 - │ └─ item: union #94 - │ ├─ variant_0: struct #89 - │ │ └─ [every]: optional '_88_PostWhere__skip_12_UserWhere?' #88 - │ │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 - │ │ ├─ [id]: optional '_83__integer_filter_c?' #83 - │ │ │ └─ item: optional '_integer_filter_c' #32 - │ │ │ └─ item: union #31 - │ │ │ ├─ variant_0: either '_integer_filter' #29 - │ │ │ │ ├─ variant_0: integer #21 - │ │ │ │ ├─ variant_1: struct #24 - │ │ │ │ │ └─ [equals]: integer #21 - │ │ │ │ ├─ variant_2: struct #25 - │ │ │ │ │ └─ [not]: integer #21 - │ │ │ │ ├─ variant_3: struct #26 - │ │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ variant_4: struct #27 - │ │ │ │ │ └─ [in]: list #23 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ variant_5: struct #28 - │ │ │ │ └─ [notIn]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_1: struct #30 - │ │ │ └─ [not]: either '_integer_filter' #29 - │ │ │ ├─ variant_0: integer #21 - │ │ │ ├─ variant_1: struct #24 - │ │ │ │ └─ [equals]: integer #21 - │ │ │ ├─ variant_2: struct #25 - │ │ │ │ └─ [not]: integer #21 - │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ variant_4: struct #27 - │ │ │ │ └─ [in]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_5: struct #28 - │ │ │ └─ [notIn]: list #23 - │ │ │ └─ item: integer #21 - │ │ ├─ [title]: optional '_84__string_filter_c?' #84 - │ │ │ └─ item: optional '_string_filter_c' #49 - │ │ │ └─ item: union #48 - │ │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ │ ├─ variant_0: string #34 - │ │ │ │ ├─ variant_1: struct #37 - │ │ │ │ │ └─ [equals]: string #34 - │ │ │ │ ├─ variant_2: struct #38 - │ │ │ │ │ └─ [not]: string #34 - │ │ │ │ ├─ variant_3: struct #39 - │ │ │ │ │ └─ [in]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_4: struct #40 - │ │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_5: struct #43 - │ │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #44 - │ │ │ │ │ └─ [search]: string #34 - │ │ │ │ └─ variant_7: struct #45 - │ │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ └─ [endsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ variant_1: struct #47 - │ │ │ └─ [not]: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [author]: optional '_86_UserWhere?' #86 - │ │ └─ item: &UserWhere #85 - │ ├─ variant_1: struct #91 - │ │ └─ [some]: optional '_90_PostWhere__skip_12_UserWhere?' #90 - │ │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 - │ │ ├─ [id]: optional '_83__integer_filter_c?' #83 - │ │ │ └─ item: optional '_integer_filter_c' #32 - │ │ │ └─ item: union #31 - │ │ │ ├─ variant_0: either '_integer_filter' #29 - │ │ │ │ ├─ variant_0: integer #21 - │ │ │ │ ├─ variant_1: struct #24 - │ │ │ │ │ └─ [equals]: integer #21 - │ │ │ │ ├─ variant_2: struct #25 - │ │ │ │ │ └─ [not]: integer #21 - │ │ │ │ ├─ variant_3: struct #26 - │ │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ variant_4: struct #27 - │ │ │ │ │ └─ [in]: list #23 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ variant_5: struct #28 - │ │ │ │ └─ [notIn]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_1: struct #30 - │ │ │ └─ [not]: either '_integer_filter' #29 - │ │ │ ├─ variant_0: integer #21 - │ │ │ ├─ variant_1: struct #24 - │ │ │ │ └─ [equals]: integer #21 - │ │ │ ├─ variant_2: struct #25 - │ │ │ │ └─ [not]: integer #21 - │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ variant_4: struct #27 - │ │ │ │ └─ [in]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_5: struct #28 - │ │ │ └─ [notIn]: list #23 - │ │ │ └─ item: integer #21 - │ │ ├─ [title]: optional '_84__string_filter_c?' #84 - │ │ │ └─ item: optional '_string_filter_c' #49 - │ │ │ └─ item: union #48 - │ │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ │ ├─ variant_0: string #34 - │ │ │ │ ├─ variant_1: struct #37 - │ │ │ │ │ └─ [equals]: string #34 - │ │ │ │ ├─ variant_2: struct #38 - │ │ │ │ │ └─ [not]: string #34 - │ │ │ │ ├─ variant_3: struct #39 - │ │ │ │ │ └─ [in]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_4: struct #40 - │ │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_5: struct #43 - │ │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #44 - │ │ │ │ │ └─ [search]: string #34 - │ │ │ │ └─ variant_7: struct #45 - │ │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ └─ [endsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ variant_1: struct #47 - │ │ │ └─ [not]: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [author]: optional '_86_UserWhere?' #86 - │ │ └─ item: &UserWhere #85 - │ └─ variant_2: struct #93 - │ └─ [none]: optional '_92_PostWhere__skip_12_UserWhere?' #92 - │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 - │ ├─ [id]: optional '_83__integer_filter_c?' #83 - │ │ └─ item: optional '_integer_filter_c' #32 - │ │ └─ item: union #31 - │ │ ├─ variant_0: either '_integer_filter' #29 - │ │ │ ├─ variant_0: integer #21 - │ │ │ ├─ variant_1: struct #24 - │ │ │ │ └─ [equals]: integer #21 - │ │ │ ├─ variant_2: struct #25 - │ │ │ │ └─ [not]: integer #21 - │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ variant_4: struct #27 - │ │ │ │ └─ [in]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_5: struct #28 - │ │ │ └─ [notIn]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_1: struct #30 - │ │ └─ [not]: either '_integer_filter' #29 - │ │ ├─ variant_0: integer #21 - │ │ ├─ variant_1: struct #24 - │ │ │ └─ [equals]: integer #21 - │ │ ├─ variant_2: struct #25 - │ │ │ └─ [not]: integer #21 - │ │ ├─ variant_3: struct #26 - │ │ │ ├─ [lt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [gt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [lte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ [gte]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ variant_4: struct #27 - │ │ │ └─ [in]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_5: struct #28 - │ │ └─ [notIn]: list #23 - │ │ └─ item: integer #21 - │ ├─ [title]: optional '_84__string_filter_c?' #84 - │ │ └─ item: optional '_string_filter_c' #49 - │ │ └─ item: union #48 - │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ variant_1: struct #47 - │ │ └─ [not]: union '_string_filter' #46 - │ │ ├─ variant_0: string #34 - │ │ ├─ variant_1: struct #37 - │ │ │ └─ [equals]: string #34 - │ │ ├─ variant_2: struct #38 - │ │ │ └─ [not]: string #34 - │ │ ├─ variant_3: struct #39 - │ │ │ └─ [in]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_4: struct #40 - │ │ │ └─ [notIn]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_5: struct #43 - │ │ │ ├─ [contains]: string #34 - │ │ │ └─ [mode]: optional #42 - │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #44 - │ │ │ └─ [search]: string #34 - │ │ └─ variant_7: struct #45 - │ │ ├─ [startsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [endsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ [author]: optional '_86_UserWhere?' #86 - │ └─ item: &UserWhere #85 - └─ variant_2: struct #100 - └─ [connectOrCreate]: struct #97 - ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #80 - │ ├─ [id]: integer #8 - │ └─ [name]: string #9 - └─ [where]: struct 'UserWhere' #96 - ├─ [id]: optional '_81__integer_filter_c?' #81 - │ └─ item: optional '_integer_filter_c' #32 - │ └─ item: union #31 - │ ├─ variant_0: either '_integer_filter' #29 - │ │ ├─ variant_0: integer #21 - │ │ ├─ variant_1: struct #24 - │ │ │ └─ [equals]: integer #21 - │ │ ├─ variant_2: struct #25 - │ │ │ └─ [not]: integer #21 - │ │ ├─ variant_3: struct #26 - │ │ │ ├─ [lt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [gt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [lte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ [gte]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ variant_4: struct #27 - │ │ │ └─ [in]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_5: struct #28 - │ │ └─ [notIn]: list #23 - │ │ └─ item: integer #21 - │ └─ variant_1: struct #30 - │ └─ [not]: either '_integer_filter' #29 - │ ├─ variant_0: integer #21 - │ ├─ variant_1: struct #24 - │ │ └─ [equals]: integer #21 - │ ├─ variant_2: struct #25 - │ │ └─ [not]: integer #21 - │ ├─ variant_3: struct #26 - │ │ ├─ [lt]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ [gt]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ [lte]: optional #22 - │ │ │ └─ item: integer #21 - │ │ └─ [gte]: optional #22 - │ │ └─ item: integer #21 - │ ├─ variant_4: struct #27 - │ │ └─ [in]: list #23 - │ │ └─ item: integer #21 - │ └─ variant_5: struct #28 - │ └─ [notIn]: list #23 - │ └─ item: integer #21 - ├─ [name]: optional '_82__string_filter_c?' #82 - │ └─ item: optional '_string_filter_c' #49 - │ └─ item: union #48 - │ ├─ variant_0: union '_string_filter' #46 - │ │ ├─ variant_0: string #34 - │ │ ├─ variant_1: struct #37 - │ │ │ └─ [equals]: string #34 - │ │ ├─ variant_2: struct #38 - │ │ │ └─ [not]: string #34 - │ │ ├─ variant_3: struct #39 - │ │ │ └─ [in]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_4: struct #40 - │ │ │ └─ [notIn]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_5: struct #43 - │ │ │ ├─ [contains]: string #34 - │ │ │ └─ [mode]: optional #42 - │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #44 - │ │ │ └─ [search]: string #34 - │ │ └─ variant_7: struct #45 - │ │ ├─ [startsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [endsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ variant_1: struct #47 - │ └─ [not]: union '_string_filter' #46 - │ ├─ variant_0: string #34 - │ ├─ variant_1: struct #37 - │ │ └─ [equals]: string #34 - │ ├─ variant_2: struct #38 - │ │ └─ [not]: string #34 - │ ├─ variant_3: struct #39 - │ │ └─ [in]: list #36 - │ │ └─ item: string #34 - │ ├─ variant_4: struct #40 - │ │ └─ [notIn]: list #36 - │ │ └─ item: string #34 - │ ├─ variant_5: struct #43 - │ │ ├─ [contains]: string #34 - │ │ └─ [mode]: optional #42 - │ │ └─ item: string #41 enum{ '"insensitive"' } - │ ├─ variant_6: struct #44 - │ │ └─ [search]: string #34 - │ └─ variant_7: struct #45 - │ ├─ [startsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ [endsWith]: optional #35 - │ └─ item: string #34 - └─ [posts]: optional #95 - └─ item: union #94 - ├─ variant_0: struct #89 - │ └─ [every]: optional '_88_PostWhere__skip_12_UserWhere?' #88 - │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 - │ ├─ [id]: optional '_83__integer_filter_c?' #83 - │ │ └─ item: optional '_integer_filter_c' #32 - │ │ └─ item: union #31 - │ │ ├─ variant_0: either '_integer_filter' #29 - │ │ │ ├─ variant_0: integer #21 - │ │ │ ├─ variant_1: struct #24 - │ │ │ │ └─ [equals]: integer #21 - │ │ │ ├─ variant_2: struct #25 - │ │ │ │ └─ [not]: integer #21 - │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ variant_4: struct #27 - │ │ │ │ └─ [in]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_5: struct #28 - │ │ │ └─ [notIn]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_1: struct #30 - │ │ └─ [not]: either '_integer_filter' #29 - │ │ ├─ variant_0: integer #21 - │ │ ├─ variant_1: struct #24 - │ │ │ └─ [equals]: integer #21 - │ │ ├─ variant_2: struct #25 - │ │ │ └─ [not]: integer #21 - │ │ ├─ variant_3: struct #26 - │ │ │ ├─ [lt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [gt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [lte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ [gte]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ variant_4: struct #27 - │ │ │ └─ [in]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_5: struct #28 - │ │ └─ [notIn]: list #23 - │ │ └─ item: integer #21 - │ ├─ [title]: optional '_84__string_filter_c?' #84 - │ │ └─ item: optional '_string_filter_c' #49 - │ │ └─ item: union #48 - │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ variant_1: struct #47 - │ │ └─ [not]: union '_string_filter' #46 - │ │ ├─ variant_0: string #34 - │ │ ├─ variant_1: struct #37 - │ │ │ └─ [equals]: string #34 - │ │ ├─ variant_2: struct #38 - │ │ │ └─ [not]: string #34 - │ │ ├─ variant_3: struct #39 - │ │ │ └─ [in]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_4: struct #40 - │ │ │ └─ [notIn]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_5: struct #43 - │ │ │ ├─ [contains]: string #34 - │ │ │ └─ [mode]: optional #42 - │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #44 - │ │ │ └─ [search]: string #34 - │ │ └─ variant_7: struct #45 - │ │ ├─ [startsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [endsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ [author]: optional '_86_UserWhere?' #86 - │ └─ item: &UserWhere #85 - ├─ variant_1: struct #91 - │ └─ [some]: optional '_90_PostWhere__skip_12_UserWhere?' #90 - │ └─ item: struct 'PostWhere__skip_12_UserWhere' #87 - │ ├─ [id]: optional '_83__integer_filter_c?' #83 - │ │ └─ item: optional '_integer_filter_c' #32 - │ │ └─ item: union #31 - │ │ ├─ variant_0: either '_integer_filter' #29 - │ │ │ ├─ variant_0: integer #21 - │ │ │ ├─ variant_1: struct #24 - │ │ │ │ └─ [equals]: integer #21 - │ │ │ ├─ variant_2: struct #25 - │ │ │ │ └─ [not]: integer #21 - │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ variant_4: struct #27 - │ │ │ │ └─ [in]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_5: struct #28 - │ │ │ └─ [notIn]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_1: struct #30 - │ │ └─ [not]: either '_integer_filter' #29 - │ │ ├─ variant_0: integer #21 - │ │ ├─ variant_1: struct #24 - │ │ │ └─ [equals]: integer #21 - │ │ ├─ variant_2: struct #25 - │ │ │ └─ [not]: integer #21 - │ │ ├─ variant_3: struct #26 - │ │ │ ├─ [lt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [gt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [lte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ [gte]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ variant_4: struct #27 - │ │ │ └─ [in]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_5: struct #28 - │ │ └─ [notIn]: list #23 - │ │ └─ item: integer #21 - │ ├─ [title]: optional '_84__string_filter_c?' #84 - │ │ └─ item: optional '_string_filter_c' #49 - │ │ └─ item: union #48 - │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ variant_1: struct #47 - │ │ └─ [not]: union '_string_filter' #46 - │ │ ├─ variant_0: string #34 - │ │ ├─ variant_1: struct #37 - │ │ │ └─ [equals]: string #34 - │ │ ├─ variant_2: struct #38 - │ │ │ └─ [not]: string #34 - │ │ ├─ variant_3: struct #39 - │ │ │ └─ [in]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_4: struct #40 - │ │ │ └─ [notIn]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_5: struct #43 - │ │ │ ├─ [contains]: string #34 - │ │ │ └─ [mode]: optional #42 - │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #44 - │ │ │ └─ [search]: string #34 - │ │ └─ variant_7: struct #45 - │ │ ├─ [startsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [endsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ [author]: optional '_86_UserWhere?' #86 - │ └─ item: &UserWhere #85 - └─ variant_2: struct #93 - └─ [none]: optional '_92_PostWhere__skip_12_UserWhere?' #92 - └─ item: struct 'PostWhere__skip_12_UserWhere' #87 - ├─ [id]: optional '_83__integer_filter_c?' #83 - │ └─ item: optional '_integer_filter_c' #32 - │ └─ item: union #31 - │ ├─ variant_0: either '_integer_filter' #29 - │ │ ├─ variant_0: integer #21 - │ │ ├─ variant_1: struct #24 - │ │ │ └─ [equals]: integer #21 - │ │ ├─ variant_2: struct #25 - │ │ │ └─ [not]: integer #21 - │ │ ├─ variant_3: struct #26 - │ │ │ ├─ [lt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [gt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [lte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ [gte]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ variant_4: struct #27 - │ │ │ └─ [in]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_5: struct #28 - │ │ └─ [notIn]: list #23 - │ │ └─ item: integer #21 - │ └─ variant_1: struct #30 - │ └─ [not]: either '_integer_filter' #29 - │ ├─ variant_0: integer #21 - │ ├─ variant_1: struct #24 - │ │ └─ [equals]: integer #21 - │ ├─ variant_2: struct #25 - │ │ └─ [not]: integer #21 - │ ├─ variant_3: struct #26 - │ │ ├─ [lt]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ [gt]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ [lte]: optional #22 - │ │ │ └─ item: integer #21 - │ │ └─ [gte]: optional #22 - │ │ └─ item: integer #21 - │ ├─ variant_4: struct #27 - │ │ └─ [in]: list #23 - │ │ └─ item: integer #21 - │ └─ variant_5: struct #28 - │ └─ [notIn]: list #23 - │ └─ item: integer #21 - ├─ [title]: optional '_84__string_filter_c?' #84 - │ └─ item: optional '_string_filter_c' #49 - │ └─ item: union #48 - │ ├─ variant_0: union '_string_filter' #46 - │ │ ├─ variant_0: string #34 - │ │ ├─ variant_1: struct #37 - │ │ │ └─ [equals]: string #34 - │ │ ├─ variant_2: struct #38 - │ │ │ └─ [not]: string #34 - │ │ ├─ variant_3: struct #39 - │ │ │ └─ [in]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_4: struct #40 - │ │ │ └─ [notIn]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_5: struct #43 - │ │ │ ├─ [contains]: string #34 - │ │ │ └─ [mode]: optional #42 - │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #44 - │ │ │ └─ [search]: string #34 - │ │ └─ variant_7: struct #45 - │ │ ├─ [startsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [endsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ variant_1: struct #47 - │ └─ [not]: union '_string_filter' #46 - │ ├─ variant_0: string #34 - │ ├─ variant_1: struct #37 - │ │ └─ [equals]: string #34 - │ ├─ variant_2: struct #38 - │ │ └─ [not]: string #34 - │ ├─ variant_3: struct #39 - │ │ └─ [in]: list #36 - │ │ └─ item: string #34 - │ ├─ variant_4: struct #40 - │ │ └─ [notIn]: list #36 - │ │ └─ item: string #34 - │ ├─ variant_5: struct #43 - │ │ ├─ [contains]: string #34 - │ │ └─ [mode]: optional #42 - │ │ └─ item: string #41 enum{ '"insensitive"' } - │ ├─ variant_6: struct #44 - │ │ └─ [search]: string #34 - │ └─ variant_7: struct #45 - │ ├─ [startsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ [endsWith]: optional #35 - │ └─ item: string #34 - └─ [author]: optional '_86_UserWhere?' #86 - └─ item: &UserWhere #85 + └─ [title]: string #14 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one Record inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one Record inp.snap index 153c97121..6c4fcba9f 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one Record inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one Record inp.snap @@ -1,12 +1,12 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #7 └─ [data]: struct '_Record_CreateInput' #6 + ├─ [age]: optional #3 + │ └─ item: integer #2 ├─ [id]: optional #5 │ └─ item: string #0 - ├─ [name]: string #1 - └─ [age]: optional #3 - └─ item: integer #2 + └─ [name]: string #1 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one User inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one User inp.snap index 6725a92e1..6e688ffcd 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one User inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__create_one User inp.snap @@ -1,6 +1,6 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #78 └─ [data]: struct '_User_CreateInput' #77 @@ -22,6 +22,115 @@ root: struct #78 ├─ variant_1: struct #69 │ └─ [connect]: union #66 │ ├─ variant_0: struct 'PostWhere' #64 + │ │ ├─ [author]: optional '_63_UserWhere__skip_16_PostWhere?' #63 + │ │ │ └─ item: struct 'UserWhere__skip_16_PostWhere' #62 + │ │ │ ├─ [id]: optional '_51__integer_filter_c?' #51 + │ │ │ │ └─ item: optional '_integer_filter_c' #32 + │ │ │ │ └─ item: union #31 + │ │ │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_1: struct #30 + │ │ │ │ └─ [not]: either '_integer_filter' #29 + │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ [name]: optional '_52__string_filter_c?' #52 + │ │ │ │ └─ item: optional '_string_filter_c' #49 + │ │ │ │ └─ item: union #48 + │ │ │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ │ │ ├─ variant_0: string #34 + │ │ │ │ │ ├─ variant_1: struct #37 + │ │ │ │ │ │ └─ [equals]: string #34 + │ │ │ │ │ ├─ variant_2: struct #38 + │ │ │ │ │ │ └─ [not]: string #34 + │ │ │ │ │ ├─ variant_3: struct #39 + │ │ │ │ │ │ └─ [in]: list #36 + │ │ │ │ │ │ └─ item: string #34 + │ │ │ │ │ ├─ variant_4: struct #40 + │ │ │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ │ │ └─ item: string #34 + │ │ │ │ │ ├─ variant_5: struct #43 + │ │ │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ │ │ ├─ variant_6: struct #44 + │ │ │ │ │ │ └─ [search]: string #34 + │ │ │ │ │ └─ variant_7: struct #45 + │ │ │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ │ │ └─ item: string #34 + │ │ │ │ │ └─ [startsWith]: optional #35 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ └─ variant_1: struct #47 + │ │ │ │ └─ [not]: union '_string_filter' #46 + │ │ │ │ ├─ variant_0: string #34 + │ │ │ │ ├─ variant_1: struct #37 + │ │ │ │ │ └─ [equals]: string #34 + │ │ │ │ ├─ variant_2: struct #38 + │ │ │ │ │ └─ [not]: string #34 + │ │ │ │ ├─ variant_3: struct #39 + │ │ │ │ │ └─ [in]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_4: struct #40 + │ │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_5: struct #43 + │ │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #44 + │ │ │ │ │ └─ [search]: string #34 + │ │ │ │ └─ variant_7: struct #45 + │ │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ └─ [startsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [posts]: optional #61 + │ │ │ └─ item: union #60 + │ │ │ ├─ variant_0: struct #55 + │ │ │ │ └─ [every]: optional '_54_PostWhere?' #54 + │ │ │ │ └─ item: &PostWhere #53 + │ │ │ ├─ variant_1: struct #57 + │ │ │ │ └─ [some]: optional '_56_PostWhere?' #56 + │ │ │ │ └─ item: &PostWhere #53 + │ │ │ └─ variant_2: struct #59 + │ │ │ └─ [none]: optional '_58_PostWhere?' #58 + │ │ │ └─ item: &PostWhere #53 │ │ ├─ [id]: optional '_33__integer_filter_c?' #33 │ │ │ └─ item: optional '_integer_filter_c' #32 │ │ │ └─ item: union #31 @@ -32,13 +141,13 @@ root: struct #78 │ │ │ │ ├─ variant_2: struct #25 │ │ │ │ │ └─ [not]: integer #21 │ │ │ │ ├─ variant_3: struct #26 - │ │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 │ │ │ │ │ ├─ [gt]: optional #22 │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ ├─ [lte]: optional #22 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ └─ [gte]: optional #22 + │ │ │ │ │ └─ [lte]: optional #22 │ │ │ │ │ └─ item: integer #21 │ │ │ │ ├─ variant_4: struct #27 │ │ │ │ │ └─ [in]: list #23 @@ -54,13 +163,13 @@ root: struct #78 │ │ │ ├─ variant_2: struct #25 │ │ │ │ └─ [not]: integer #21 │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 │ │ │ │ ├─ [gt]: optional #22 │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 + │ │ │ │ └─ [lte]: optional #22 │ │ │ │ └─ item: integer #21 │ │ │ ├─ variant_4: struct #27 │ │ │ │ └─ [in]: list #23 @@ -68,167 +177,167 @@ root: struct #78 │ │ │ └─ variant_5: struct #28 │ │ │ └─ [notIn]: list #23 │ │ │ └─ item: integer #21 - │ │ ├─ [title]: optional '_50__string_filter_c?' #50 - │ │ │ └─ item: optional '_string_filter_c' #49 - │ │ │ └─ item: union #48 - │ │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ │ ├─ variant_0: string #34 - │ │ │ │ ├─ variant_1: struct #37 - │ │ │ │ │ └─ [equals]: string #34 - │ │ │ │ ├─ variant_2: struct #38 - │ │ │ │ │ └─ [not]: string #34 - │ │ │ │ ├─ variant_3: struct #39 - │ │ │ │ │ └─ [in]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_4: struct #40 - │ │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_5: struct #43 - │ │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #44 - │ │ │ │ │ └─ [search]: string #34 - │ │ │ │ └─ variant_7: struct #45 - │ │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ └─ [endsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ variant_1: struct #47 - │ │ │ └─ [not]: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [author]: optional '_63_UserWhere__skip_16_PostWhere?' #63 - │ │ └─ item: struct 'UserWhere__skip_16_PostWhere' #62 - │ │ ├─ [id]: optional '_51__integer_filter_c?' #51 - │ │ │ └─ item: optional '_integer_filter_c' #32 - │ │ │ └─ item: union #31 - │ │ │ ├─ variant_0: either '_integer_filter' #29 - │ │ │ │ ├─ variant_0: integer #21 - │ │ │ │ ├─ variant_1: struct #24 - │ │ │ │ │ └─ [equals]: integer #21 - │ │ │ │ ├─ variant_2: struct #25 - │ │ │ │ │ └─ [not]: integer #21 - │ │ │ │ ├─ variant_3: struct #26 - │ │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ variant_4: struct #27 - │ │ │ │ │ └─ [in]: list #23 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ variant_5: struct #28 - │ │ │ │ └─ [notIn]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_1: struct #30 - │ │ │ └─ [not]: either '_integer_filter' #29 - │ │ │ ├─ variant_0: integer #21 - │ │ │ ├─ variant_1: struct #24 - │ │ │ │ └─ [equals]: integer #21 - │ │ │ ├─ variant_2: struct #25 - │ │ │ │ └─ [not]: integer #21 - │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ variant_4: struct #27 - │ │ │ │ └─ [in]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_5: struct #28 - │ │ │ └─ [notIn]: list #23 - │ │ │ └─ item: integer #21 - │ │ ├─ [name]: optional '_52__string_filter_c?' #52 - │ │ │ └─ item: optional '_string_filter_c' #49 - │ │ │ └─ item: union #48 - │ │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ │ ├─ variant_0: string #34 - │ │ │ │ ├─ variant_1: struct #37 - │ │ │ │ │ └─ [equals]: string #34 - │ │ │ │ ├─ variant_2: struct #38 - │ │ │ │ │ └─ [not]: string #34 - │ │ │ │ ├─ variant_3: struct #39 - │ │ │ │ │ └─ [in]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_4: struct #40 - │ │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_5: struct #43 - │ │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #44 - │ │ │ │ │ └─ [search]: string #34 - │ │ │ │ └─ variant_7: struct #45 - │ │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ └─ [endsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ variant_1: struct #47 - │ │ │ └─ [not]: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [posts]: optional #61 - │ │ └─ item: union #60 - │ │ ├─ variant_0: struct #55 - │ │ │ └─ [every]: optional '_54_PostWhere?' #54 - │ │ │ └─ item: &PostWhere #53 - │ │ ├─ variant_1: struct #57 - │ │ │ └─ [some]: optional '_56_PostWhere?' #56 - │ │ │ └─ item: &PostWhere #53 - │ │ └─ variant_2: struct #59 - │ │ └─ [none]: optional '_58_PostWhere?' #58 - │ │ └─ item: &PostWhere #53 + │ │ └─ [title]: optional '_50__string_filter_c?' #50 + │ │ └─ item: optional '_string_filter_c' #49 + │ │ └─ item: union #48 + │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ variant_1: struct #47 + │ │ └─ [not]: union '_string_filter' #46 + │ │ ├─ variant_0: string #34 + │ │ ├─ variant_1: struct #37 + │ │ │ └─ [equals]: string #34 + │ │ ├─ variant_2: struct #38 + │ │ │ └─ [not]: string #34 + │ │ ├─ variant_3: struct #39 + │ │ │ └─ [in]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_4: struct #40 + │ │ │ └─ [notIn]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_5: struct #43 + │ │ │ ├─ [contains]: string #34 + │ │ │ └─ [mode]: optional #42 + │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #44 + │ │ │ └─ [search]: string #34 + │ │ └─ variant_7: struct #45 + │ │ ├─ [endsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [startsWith]: optional #35 + │ │ └─ item: string #34 │ └─ variant_1: list '_65_PostWhere[]' #65 │ └─ item: struct 'PostWhere' #64 + │ ├─ [author]: optional '_63_UserWhere__skip_16_PostWhere?' #63 + │ │ └─ item: struct 'UserWhere__skip_16_PostWhere' #62 + │ │ ├─ [id]: optional '_51__integer_filter_c?' #51 + │ │ │ └─ item: optional '_integer_filter_c' #32 + │ │ │ └─ item: union #31 + │ │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_1: struct #30 + │ │ │ └─ [not]: either '_integer_filter' #29 + │ │ │ ├─ variant_0: integer #21 + │ │ │ ├─ variant_1: struct #24 + │ │ │ │ └─ [equals]: integer #21 + │ │ │ ├─ variant_2: struct #25 + │ │ │ │ └─ [not]: integer #21 + │ │ │ ├─ variant_3: struct #26 + │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ variant_4: struct #27 + │ │ │ │ └─ [in]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_5: struct #28 + │ │ │ └─ [notIn]: list #23 + │ │ │ └─ item: integer #21 + │ │ ├─ [name]: optional '_52__string_filter_c?' #52 + │ │ │ └─ item: optional '_string_filter_c' #49 + │ │ │ └─ item: union #48 + │ │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ │ ├─ variant_0: string #34 + │ │ │ │ ├─ variant_1: struct #37 + │ │ │ │ │ └─ [equals]: string #34 + │ │ │ │ ├─ variant_2: struct #38 + │ │ │ │ │ └─ [not]: string #34 + │ │ │ │ ├─ variant_3: struct #39 + │ │ │ │ │ └─ [in]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_4: struct #40 + │ │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_5: struct #43 + │ │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #44 + │ │ │ │ │ └─ [search]: string #34 + │ │ │ │ └─ variant_7: struct #45 + │ │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ └─ [startsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ variant_1: struct #47 + │ │ │ └─ [not]: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [posts]: optional #61 + │ │ └─ item: union #60 + │ │ ├─ variant_0: struct #55 + │ │ │ └─ [every]: optional '_54_PostWhere?' #54 + │ │ │ └─ item: &PostWhere #53 + │ │ ├─ variant_1: struct #57 + │ │ │ └─ [some]: optional '_56_PostWhere?' #56 + │ │ │ └─ item: &PostWhere #53 + │ │ └─ variant_2: struct #59 + │ │ └─ [none]: optional '_58_PostWhere?' #58 + │ │ └─ item: &PostWhere #53 │ ├─ [id]: optional '_33__integer_filter_c?' #33 │ │ └─ item: optional '_integer_filter_c' #32 │ │ └─ item: union #31 @@ -239,13 +348,13 @@ root: struct #78 │ │ │ ├─ variant_2: struct #25 │ │ │ │ └─ [not]: integer #21 │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 │ │ │ │ ├─ [gt]: optional #22 │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 + │ │ │ │ └─ [lte]: optional #22 │ │ │ │ └─ item: integer #21 │ │ │ ├─ variant_4: struct #27 │ │ │ │ └─ [in]: list #23 @@ -261,13 +370,13 @@ root: struct #78 │ │ ├─ variant_2: struct #25 │ │ │ └─ [not]: integer #21 │ │ ├─ variant_3: struct #26 - │ │ │ ├─ [lt]: optional #22 - │ │ │ │ └─ item: integer #21 │ │ │ ├─ [gt]: optional #22 │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [lte]: optional #22 + │ │ │ ├─ [gte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ [lt]: optional #22 │ │ │ │ └─ item: integer #21 - │ │ │ └─ [gte]: optional #22 + │ │ │ └─ [lte]: optional #22 │ │ │ └─ item: integer #21 │ │ ├─ variant_4: struct #27 │ │ │ └─ [in]: list #23 @@ -275,165 +384,56 @@ root: struct #78 │ │ └─ variant_5: struct #28 │ │ └─ [notIn]: list #23 │ │ └─ item: integer #21 - │ ├─ [title]: optional '_50__string_filter_c?' #50 - │ │ └─ item: optional '_string_filter_c' #49 - │ │ └─ item: union #48 - │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ variant_1: struct #47 - │ │ └─ [not]: union '_string_filter' #46 - │ │ ├─ variant_0: string #34 - │ │ ├─ variant_1: struct #37 - │ │ │ └─ [equals]: string #34 - │ │ ├─ variant_2: struct #38 - │ │ │ └─ [not]: string #34 - │ │ ├─ variant_3: struct #39 - │ │ │ └─ [in]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_4: struct #40 - │ │ │ └─ [notIn]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_5: struct #43 - │ │ │ ├─ [contains]: string #34 - │ │ │ └─ [mode]: optional #42 - │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #44 - │ │ │ └─ [search]: string #34 - │ │ └─ variant_7: struct #45 - │ │ ├─ [startsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [endsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ [author]: optional '_63_UserWhere__skip_16_PostWhere?' #63 - │ └─ item: struct 'UserWhere__skip_16_PostWhere' #62 - │ ├─ [id]: optional '_51__integer_filter_c?' #51 - │ │ └─ item: optional '_integer_filter_c' #32 - │ │ └─ item: union #31 - │ │ ├─ variant_0: either '_integer_filter' #29 - │ │ │ ├─ variant_0: integer #21 - │ │ │ ├─ variant_1: struct #24 - │ │ │ │ └─ [equals]: integer #21 - │ │ │ ├─ variant_2: struct #25 - │ │ │ │ └─ [not]: integer #21 - │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ variant_4: struct #27 - │ │ │ │ └─ [in]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_5: struct #28 - │ │ │ └─ [notIn]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_1: struct #30 - │ │ └─ [not]: either '_integer_filter' #29 - │ │ ├─ variant_0: integer #21 - │ │ ├─ variant_1: struct #24 - │ │ │ └─ [equals]: integer #21 - │ │ ├─ variant_2: struct #25 - │ │ │ └─ [not]: integer #21 - │ │ ├─ variant_3: struct #26 - │ │ │ ├─ [lt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [gt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [lte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ [gte]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ variant_4: struct #27 - │ │ │ └─ [in]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_5: struct #28 - │ │ └─ [notIn]: list #23 - │ │ └─ item: integer #21 - │ ├─ [name]: optional '_52__string_filter_c?' #52 - │ │ └─ item: optional '_string_filter_c' #49 - │ │ └─ item: union #48 - │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ variant_1: struct #47 - │ │ └─ [not]: union '_string_filter' #46 - │ │ ├─ variant_0: string #34 - │ │ ├─ variant_1: struct #37 - │ │ │ └─ [equals]: string #34 - │ │ ├─ variant_2: struct #38 - │ │ │ └─ [not]: string #34 - │ │ ├─ variant_3: struct #39 - │ │ │ └─ [in]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_4: struct #40 - │ │ │ └─ [notIn]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_5: struct #43 - │ │ │ ├─ [contains]: string #34 - │ │ │ └─ [mode]: optional #42 - │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #44 - │ │ │ └─ [search]: string #34 - │ │ └─ variant_7: struct #45 - │ │ ├─ [startsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [endsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ [posts]: optional #61 - │ └─ item: union #60 - │ ├─ variant_0: struct #55 - │ │ └─ [every]: optional '_54_PostWhere?' #54 - │ │ └─ item: &PostWhere #53 - │ ├─ variant_1: struct #57 - │ │ └─ [some]: optional '_56_PostWhere?' #56 - │ │ └─ item: &PostWhere #53 - │ └─ variant_2: struct #59 - │ └─ [none]: optional '_58_PostWhere?' #58 - │ └─ item: &PostWhere #53 + │ └─ [title]: optional '_50__string_filter_c?' #50 + │ └─ item: optional '_string_filter_c' #49 + │ └─ item: union #48 + │ ├─ variant_0: union '_string_filter' #46 + │ │ ├─ variant_0: string #34 + │ │ ├─ variant_1: struct #37 + │ │ │ └─ [equals]: string #34 + │ │ ├─ variant_2: struct #38 + │ │ │ └─ [not]: string #34 + │ │ ├─ variant_3: struct #39 + │ │ │ └─ [in]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_4: struct #40 + │ │ │ └─ [notIn]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_5: struct #43 + │ │ │ ├─ [contains]: string #34 + │ │ │ └─ [mode]: optional #42 + │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #44 + │ │ │ └─ [search]: string #34 + │ │ └─ variant_7: struct #45 + │ │ ├─ [endsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [startsWith]: optional #35 + │ │ └─ item: string #34 + │ └─ variant_1: struct #47 + │ └─ [not]: union '_string_filter' #46 + │ ├─ variant_0: string #34 + │ ├─ variant_1: struct #37 + │ │ └─ [equals]: string #34 + │ ├─ variant_2: struct #38 + │ │ └─ [not]: string #34 + │ ├─ variant_3: struct #39 + │ │ └─ [in]: list #36 + │ │ └─ item: string #34 + │ ├─ variant_4: struct #40 + │ │ └─ [notIn]: list #36 + │ │ └─ item: string #34 + │ ├─ variant_5: struct #43 + │ │ ├─ [contains]: string #34 + │ │ └─ [mode]: optional #42 + │ │ └─ item: string #41 enum{ '"insensitive"' } + │ ├─ variant_6: struct #44 + │ │ └─ [search]: string #34 + │ └─ variant_7: struct #45 + │ ├─ [endsWith]: optional #35 + │ │ └─ item: string #34 + │ └─ [startsWith]: optional #35 + │ └─ item: string #34 ├─ variant_2: struct #70 │ └─ [connectOrCreate]: struct #67 │ ├─ [create]: union #20 @@ -448,6 +448,115 @@ root: struct #78 │ │ └─ [title]: string #14 │ └─ [where]: union #66 │ ├─ variant_0: struct 'PostWhere' #64 + │ │ ├─ [author]: optional '_63_UserWhere__skip_16_PostWhere?' #63 + │ │ │ └─ item: struct 'UserWhere__skip_16_PostWhere' #62 + │ │ │ ├─ [id]: optional '_51__integer_filter_c?' #51 + │ │ │ │ └─ item: optional '_integer_filter_c' #32 + │ │ │ │ └─ item: union #31 + │ │ │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_1: struct #30 + │ │ │ │ └─ [not]: either '_integer_filter' #29 + │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ [name]: optional '_52__string_filter_c?' #52 + │ │ │ │ └─ item: optional '_string_filter_c' #49 + │ │ │ │ └─ item: union #48 + │ │ │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ │ │ ├─ variant_0: string #34 + │ │ │ │ │ ├─ variant_1: struct #37 + │ │ │ │ │ │ └─ [equals]: string #34 + │ │ │ │ │ ├─ variant_2: struct #38 + │ │ │ │ │ │ └─ [not]: string #34 + │ │ │ │ │ ├─ variant_3: struct #39 + │ │ │ │ │ │ └─ [in]: list #36 + │ │ │ │ │ │ └─ item: string #34 + │ │ │ │ │ ├─ variant_4: struct #40 + │ │ │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ │ │ └─ item: string #34 + │ │ │ │ │ ├─ variant_5: struct #43 + │ │ │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ │ │ ├─ variant_6: struct #44 + │ │ │ │ │ │ └─ [search]: string #34 + │ │ │ │ │ └─ variant_7: struct #45 + │ │ │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ │ │ └─ item: string #34 + │ │ │ │ │ └─ [startsWith]: optional #35 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ └─ variant_1: struct #47 + │ │ │ │ └─ [not]: union '_string_filter' #46 + │ │ │ │ ├─ variant_0: string #34 + │ │ │ │ ├─ variant_1: struct #37 + │ │ │ │ │ └─ [equals]: string #34 + │ │ │ │ ├─ variant_2: struct #38 + │ │ │ │ │ └─ [not]: string #34 + │ │ │ │ ├─ variant_3: struct #39 + │ │ │ │ │ └─ [in]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_4: struct #40 + │ │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_5: struct #43 + │ │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #44 + │ │ │ │ │ └─ [search]: string #34 + │ │ │ │ └─ variant_7: struct #45 + │ │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ └─ [startsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [posts]: optional #61 + │ │ │ └─ item: union #60 + │ │ │ ├─ variant_0: struct #55 + │ │ │ │ └─ [every]: optional '_54_PostWhere?' #54 + │ │ │ │ └─ item: &PostWhere #53 + │ │ │ ├─ variant_1: struct #57 + │ │ │ │ └─ [some]: optional '_56_PostWhere?' #56 + │ │ │ │ └─ item: &PostWhere #53 + │ │ │ └─ variant_2: struct #59 + │ │ │ └─ [none]: optional '_58_PostWhere?' #58 + │ │ │ └─ item: &PostWhere #53 │ │ ├─ [id]: optional '_33__integer_filter_c?' #33 │ │ │ └─ item: optional '_integer_filter_c' #32 │ │ │ └─ item: union #31 @@ -458,13 +567,13 @@ root: struct #78 │ │ │ │ ├─ variant_2: struct #25 │ │ │ │ │ └─ [not]: integer #21 │ │ │ │ ├─ variant_3: struct #26 - │ │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 │ │ │ │ │ ├─ [gt]: optional #22 │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ ├─ [lte]: optional #22 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ └─ [gte]: optional #22 + │ │ │ │ │ └─ [lte]: optional #22 │ │ │ │ │ └─ item: integer #21 │ │ │ │ ├─ variant_4: struct #27 │ │ │ │ │ └─ [in]: list #23 @@ -480,13 +589,13 @@ root: struct #78 │ │ │ ├─ variant_2: struct #25 │ │ │ │ └─ [not]: integer #21 │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 │ │ │ │ ├─ [gt]: optional #22 │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 + │ │ │ │ └─ [lte]: optional #22 │ │ │ │ └─ item: integer #21 │ │ │ ├─ variant_4: struct #27 │ │ │ │ └─ [in]: list #23 @@ -494,167 +603,167 @@ root: struct #78 │ │ │ └─ variant_5: struct #28 │ │ │ └─ [notIn]: list #23 │ │ │ └─ item: integer #21 - │ │ ├─ [title]: optional '_50__string_filter_c?' #50 - │ │ │ └─ item: optional '_string_filter_c' #49 - │ │ │ └─ item: union #48 - │ │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ │ ├─ variant_0: string #34 - │ │ │ │ ├─ variant_1: struct #37 - │ │ │ │ │ └─ [equals]: string #34 - │ │ │ │ ├─ variant_2: struct #38 - │ │ │ │ │ └─ [not]: string #34 - │ │ │ │ ├─ variant_3: struct #39 - │ │ │ │ │ └─ [in]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_4: struct #40 - │ │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_5: struct #43 - │ │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #44 - │ │ │ │ │ └─ [search]: string #34 - │ │ │ │ └─ variant_7: struct #45 - │ │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ └─ [endsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ variant_1: struct #47 - │ │ │ └─ [not]: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [author]: optional '_63_UserWhere__skip_16_PostWhere?' #63 - │ │ └─ item: struct 'UserWhere__skip_16_PostWhere' #62 - │ │ ├─ [id]: optional '_51__integer_filter_c?' #51 - │ │ │ └─ item: optional '_integer_filter_c' #32 - │ │ │ └─ item: union #31 - │ │ │ ├─ variant_0: either '_integer_filter' #29 - │ │ │ │ ├─ variant_0: integer #21 - │ │ │ │ ├─ variant_1: struct #24 - │ │ │ │ │ └─ [equals]: integer #21 - │ │ │ │ ├─ variant_2: struct #25 - │ │ │ │ │ └─ [not]: integer #21 - │ │ │ │ ├─ variant_3: struct #26 - │ │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ │ └─ item: integer #21 - │ │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ variant_4: struct #27 - │ │ │ │ │ └─ [in]: list #23 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ variant_5: struct #28 - │ │ │ │ └─ [notIn]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_1: struct #30 - │ │ │ └─ [not]: either '_integer_filter' #29 - │ │ │ ├─ variant_0: integer #21 - │ │ │ ├─ variant_1: struct #24 - │ │ │ │ └─ [equals]: integer #21 - │ │ │ ├─ variant_2: struct #25 - │ │ │ │ └─ [not]: integer #21 - │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ variant_4: struct #27 - │ │ │ │ └─ [in]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_5: struct #28 - │ │ │ └─ [notIn]: list #23 - │ │ │ └─ item: integer #21 - │ │ ├─ [name]: optional '_52__string_filter_c?' #52 - │ │ │ └─ item: optional '_string_filter_c' #49 - │ │ │ └─ item: union #48 - │ │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ │ ├─ variant_0: string #34 - │ │ │ │ ├─ variant_1: struct #37 - │ │ │ │ │ └─ [equals]: string #34 - │ │ │ │ ├─ variant_2: struct #38 - │ │ │ │ │ └─ [not]: string #34 - │ │ │ │ ├─ variant_3: struct #39 - │ │ │ │ │ └─ [in]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_4: struct #40 - │ │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ ├─ variant_5: struct #43 - │ │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #44 - │ │ │ │ │ └─ [search]: string #34 - │ │ │ │ └─ variant_7: struct #45 - │ │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ │ └─ item: string #34 - │ │ │ │ └─ [endsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ variant_1: struct #47 - │ │ │ └─ [not]: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [posts]: optional #61 - │ │ └─ item: union #60 - │ │ ├─ variant_0: struct #55 - │ │ │ └─ [every]: optional '_54_PostWhere?' #54 - │ │ │ └─ item: &PostWhere #53 - │ │ ├─ variant_1: struct #57 - │ │ │ └─ [some]: optional '_56_PostWhere?' #56 - │ │ │ └─ item: &PostWhere #53 - │ │ └─ variant_2: struct #59 - │ │ └─ [none]: optional '_58_PostWhere?' #58 - │ │ └─ item: &PostWhere #53 + │ │ └─ [title]: optional '_50__string_filter_c?' #50 + │ │ └─ item: optional '_string_filter_c' #49 + │ │ └─ item: union #48 + │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ variant_1: struct #47 + │ │ └─ [not]: union '_string_filter' #46 + │ │ ├─ variant_0: string #34 + │ │ ├─ variant_1: struct #37 + │ │ │ └─ [equals]: string #34 + │ │ ├─ variant_2: struct #38 + │ │ │ └─ [not]: string #34 + │ │ ├─ variant_3: struct #39 + │ │ │ └─ [in]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_4: struct #40 + │ │ │ └─ [notIn]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_5: struct #43 + │ │ │ ├─ [contains]: string #34 + │ │ │ └─ [mode]: optional #42 + │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #44 + │ │ │ └─ [search]: string #34 + │ │ └─ variant_7: struct #45 + │ │ ├─ [endsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [startsWith]: optional #35 + │ │ └─ item: string #34 │ └─ variant_1: list '_65_PostWhere[]' #65 │ └─ item: struct 'PostWhere' #64 + │ ├─ [author]: optional '_63_UserWhere__skip_16_PostWhere?' #63 + │ │ └─ item: struct 'UserWhere__skip_16_PostWhere' #62 + │ │ ├─ [id]: optional '_51__integer_filter_c?' #51 + │ │ │ └─ item: optional '_integer_filter_c' #32 + │ │ │ └─ item: union #31 + │ │ │ ├─ variant_0: either '_integer_filter' #29 + │ │ │ │ ├─ variant_0: integer #21 + │ │ │ │ ├─ variant_1: struct #24 + │ │ │ │ │ └─ [equals]: integer #21 + │ │ │ │ ├─ variant_2: struct #25 + │ │ │ │ │ └─ [not]: integer #21 + │ │ │ │ ├─ variant_3: struct #26 + │ │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ │ └─ item: integer #21 + │ │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ variant_4: struct #27 + │ │ │ │ │ └─ [in]: list #23 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ variant_5: struct #28 + │ │ │ │ └─ [notIn]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_1: struct #30 + │ │ │ └─ [not]: either '_integer_filter' #29 + │ │ │ ├─ variant_0: integer #21 + │ │ │ ├─ variant_1: struct #24 + │ │ │ │ └─ [equals]: integer #21 + │ │ │ ├─ variant_2: struct #25 + │ │ │ │ └─ [not]: integer #21 + │ │ │ ├─ variant_3: struct #26 + │ │ │ │ ├─ [gt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ └─ [lte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ variant_4: struct #27 + │ │ │ │ └─ [in]: list #23 + │ │ │ │ └─ item: integer #21 + │ │ │ └─ variant_5: struct #28 + │ │ │ └─ [notIn]: list #23 + │ │ │ └─ item: integer #21 + │ │ ├─ [name]: optional '_52__string_filter_c?' #52 + │ │ │ └─ item: optional '_string_filter_c' #49 + │ │ │ └─ item: union #48 + │ │ │ ├─ variant_0: union '_string_filter' #46 + │ │ │ │ ├─ variant_0: string #34 + │ │ │ │ ├─ variant_1: struct #37 + │ │ │ │ │ └─ [equals]: string #34 + │ │ │ │ ├─ variant_2: struct #38 + │ │ │ │ │ └─ [not]: string #34 + │ │ │ │ ├─ variant_3: struct #39 + │ │ │ │ │ └─ [in]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_4: struct #40 + │ │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ ├─ variant_5: struct #43 + │ │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ │ ├─ variant_6: struct #44 + │ │ │ │ │ └─ [search]: string #34 + │ │ │ │ └─ variant_7: struct #45 + │ │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ │ └─ item: string #34 + │ │ │ │ └─ [startsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ variant_1: struct #47 + │ │ │ └─ [not]: union '_string_filter' #46 + │ │ │ ├─ variant_0: string #34 + │ │ │ ├─ variant_1: struct #37 + │ │ │ │ └─ [equals]: string #34 + │ │ │ ├─ variant_2: struct #38 + │ │ │ │ └─ [not]: string #34 + │ │ │ ├─ variant_3: struct #39 + │ │ │ │ └─ [in]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_4: struct #40 + │ │ │ │ └─ [notIn]: list #36 + │ │ │ │ └─ item: string #34 + │ │ │ ├─ variant_5: struct #43 + │ │ │ │ ├─ [contains]: string #34 + │ │ │ │ └─ [mode]: optional #42 + │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #44 + │ │ │ │ └─ [search]: string #34 + │ │ │ └─ variant_7: struct #45 + │ │ │ ├─ [endsWith]: optional #35 + │ │ │ │ └─ item: string #34 + │ │ │ └─ [startsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [posts]: optional #61 + │ │ └─ item: union #60 + │ │ ├─ variant_0: struct #55 + │ │ │ └─ [every]: optional '_54_PostWhere?' #54 + │ │ │ └─ item: &PostWhere #53 + │ │ ├─ variant_1: struct #57 + │ │ │ └─ [some]: optional '_56_PostWhere?' #56 + │ │ │ └─ item: &PostWhere #53 + │ │ └─ variant_2: struct #59 + │ │ └─ [none]: optional '_58_PostWhere?' #58 + │ │ └─ item: &PostWhere #53 │ ├─ [id]: optional '_33__integer_filter_c?' #33 │ │ └─ item: optional '_integer_filter_c' #32 │ │ └─ item: union #31 @@ -665,13 +774,13 @@ root: struct #78 │ │ │ ├─ variant_2: struct #25 │ │ │ │ └─ [not]: integer #21 │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 │ │ │ │ ├─ [gt]: optional #22 │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 + │ │ │ │ ├─ [gte]: optional #22 + │ │ │ │ │ └─ item: integer #21 + │ │ │ │ ├─ [lt]: optional #22 │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 + │ │ │ │ └─ [lte]: optional #22 │ │ │ │ └─ item: integer #21 │ │ │ ├─ variant_4: struct #27 │ │ │ │ └─ [in]: list #23 @@ -687,13 +796,13 @@ root: struct #78 │ │ ├─ variant_2: struct #25 │ │ │ └─ [not]: integer #21 │ │ ├─ variant_3: struct #26 - │ │ │ ├─ [lt]: optional #22 - │ │ │ │ └─ item: integer #21 │ │ │ ├─ [gt]: optional #22 │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [lte]: optional #22 + │ │ │ ├─ [gte]: optional #22 + │ │ │ │ └─ item: integer #21 + │ │ │ ├─ [lt]: optional #22 │ │ │ │ └─ item: integer #21 - │ │ │ └─ [gte]: optional #22 + │ │ │ └─ [lte]: optional #22 │ │ │ └─ item: integer #21 │ │ ├─ variant_4: struct #27 │ │ │ └─ [in]: list #23 @@ -701,165 +810,56 @@ root: struct #78 │ │ └─ variant_5: struct #28 │ │ └─ [notIn]: list #23 │ │ └─ item: integer #21 - │ ├─ [title]: optional '_50__string_filter_c?' #50 - │ │ └─ item: optional '_string_filter_c' #49 - │ │ └─ item: union #48 - │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ variant_1: struct #47 - │ │ └─ [not]: union '_string_filter' #46 - │ │ ├─ variant_0: string #34 - │ │ ├─ variant_1: struct #37 - │ │ │ └─ [equals]: string #34 - │ │ ├─ variant_2: struct #38 - │ │ │ └─ [not]: string #34 - │ │ ├─ variant_3: struct #39 - │ │ │ └─ [in]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_4: struct #40 - │ │ │ └─ [notIn]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_5: struct #43 - │ │ │ ├─ [contains]: string #34 - │ │ │ └─ [mode]: optional #42 - │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #44 - │ │ │ └─ [search]: string #34 - │ │ └─ variant_7: struct #45 - │ │ ├─ [startsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [endsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ [author]: optional '_63_UserWhere__skip_16_PostWhere?' #63 - │ └─ item: struct 'UserWhere__skip_16_PostWhere' #62 - │ ├─ [id]: optional '_51__integer_filter_c?' #51 - │ │ └─ item: optional '_integer_filter_c' #32 - │ │ └─ item: union #31 - │ │ ├─ variant_0: either '_integer_filter' #29 - │ │ │ ├─ variant_0: integer #21 - │ │ │ ├─ variant_1: struct #24 - │ │ │ │ └─ [equals]: integer #21 - │ │ │ ├─ variant_2: struct #25 - │ │ │ │ └─ [not]: integer #21 - │ │ │ ├─ variant_3: struct #26 - │ │ │ │ ├─ [lt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [gt]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ ├─ [lte]: optional #22 - │ │ │ │ │ └─ item: integer #21 - │ │ │ │ └─ [gte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ variant_4: struct #27 - │ │ │ │ └─ [in]: list #23 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ variant_5: struct #28 - │ │ │ └─ [notIn]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_1: struct #30 - │ │ └─ [not]: either '_integer_filter' #29 - │ │ ├─ variant_0: integer #21 - │ │ ├─ variant_1: struct #24 - │ │ │ └─ [equals]: integer #21 - │ │ ├─ variant_2: struct #25 - │ │ │ └─ [not]: integer #21 - │ │ ├─ variant_3: struct #26 - │ │ │ ├─ [lt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [gt]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ ├─ [lte]: optional #22 - │ │ │ │ └─ item: integer #21 - │ │ │ └─ [gte]: optional #22 - │ │ │ └─ item: integer #21 - │ │ ├─ variant_4: struct #27 - │ │ │ └─ [in]: list #23 - │ │ │ └─ item: integer #21 - │ │ └─ variant_5: struct #28 - │ │ └─ [notIn]: list #23 - │ │ └─ item: integer #21 - │ ├─ [name]: optional '_52__string_filter_c?' #52 - │ │ └─ item: optional '_string_filter_c' #49 - │ │ └─ item: union #48 - │ │ ├─ variant_0: union '_string_filter' #46 - │ │ │ ├─ variant_0: string #34 - │ │ │ ├─ variant_1: struct #37 - │ │ │ │ └─ [equals]: string #34 - │ │ │ ├─ variant_2: struct #38 - │ │ │ │ └─ [not]: string #34 - │ │ │ ├─ variant_3: struct #39 - │ │ │ │ └─ [in]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_4: struct #40 - │ │ │ │ └─ [notIn]: list #36 - │ │ │ │ └─ item: string #34 - │ │ │ ├─ variant_5: struct #43 - │ │ │ │ ├─ [contains]: string #34 - │ │ │ │ └─ [mode]: optional #42 - │ │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #44 - │ │ │ │ └─ [search]: string #34 - │ │ │ └─ variant_7: struct #45 - │ │ │ ├─ [startsWith]: optional #35 - │ │ │ │ └─ item: string #34 - │ │ │ └─ [endsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ variant_1: struct #47 - │ │ └─ [not]: union '_string_filter' #46 - │ │ ├─ variant_0: string #34 - │ │ ├─ variant_1: struct #37 - │ │ │ └─ [equals]: string #34 - │ │ ├─ variant_2: struct #38 - │ │ │ └─ [not]: string #34 - │ │ ├─ variant_3: struct #39 - │ │ │ └─ [in]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_4: struct #40 - │ │ │ └─ [notIn]: list #36 - │ │ │ └─ item: string #34 - │ │ ├─ variant_5: struct #43 - │ │ │ ├─ [contains]: string #34 - │ │ │ └─ [mode]: optional #42 - │ │ │ └─ item: string #41 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #44 - │ │ │ └─ [search]: string #34 - │ │ └─ variant_7: struct #45 - │ │ ├─ [startsWith]: optional #35 - │ │ │ └─ item: string #34 - │ │ └─ [endsWith]: optional #35 - │ │ └─ item: string #34 - │ └─ [posts]: optional #61 - │ └─ item: union #60 - │ ├─ variant_0: struct #55 - │ │ └─ [every]: optional '_54_PostWhere?' #54 - │ │ └─ item: &PostWhere #53 - │ ├─ variant_1: struct #57 - │ │ └─ [some]: optional '_56_PostWhere?' #56 - │ │ └─ item: &PostWhere #53 - │ └─ variant_2: struct #59 - │ └─ [none]: optional '_58_PostWhere?' #58 - │ └─ item: &PostWhere #53 + │ └─ [title]: optional '_50__string_filter_c?' #50 + │ └─ item: optional '_string_filter_c' #49 + │ └─ item: union #48 + │ ├─ variant_0: union '_string_filter' #46 + │ │ ├─ variant_0: string #34 + │ │ ├─ variant_1: struct #37 + │ │ │ └─ [equals]: string #34 + │ │ ├─ variant_2: struct #38 + │ │ │ └─ [not]: string #34 + │ │ ├─ variant_3: struct #39 + │ │ │ └─ [in]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_4: struct #40 + │ │ │ └─ [notIn]: list #36 + │ │ │ └─ item: string #34 + │ │ ├─ variant_5: struct #43 + │ │ │ ├─ [contains]: string #34 + │ │ │ └─ [mode]: optional #42 + │ │ │ └─ item: string #41 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #44 + │ │ │ └─ [search]: string #34 + │ │ └─ variant_7: struct #45 + │ │ ├─ [endsWith]: optional #35 + │ │ │ └─ item: string #34 + │ │ └─ [startsWith]: optional #35 + │ │ └─ item: string #34 + │ └─ variant_1: struct #47 + │ └─ [not]: union '_string_filter' #46 + │ ├─ variant_0: string #34 + │ ├─ variant_1: struct #37 + │ │ └─ [equals]: string #34 + │ ├─ variant_2: struct #38 + │ │ └─ [not]: string #34 + │ ├─ variant_3: struct #39 + │ │ └─ [in]: list #36 + │ │ └─ item: string #34 + │ ├─ variant_4: struct #40 + │ │ └─ [notIn]: list #36 + │ │ └─ item: string #34 + │ ├─ variant_5: struct #43 + │ │ ├─ [contains]: string #34 + │ │ └─ [mode]: optional #42 + │ │ └─ item: string #41 enum{ '"insensitive"' } + │ ├─ variant_6: struct #44 + │ │ └─ [search]: string #34 + │ └─ variant_7: struct #45 + │ ├─ [endsWith]: optional #35 + │ │ └─ item: string #34 + │ └─ [startsWith]: optional #35 + │ └─ item: string #34 └─ variant_3: struct #74 └─ [createMany]: optional #73 └─ item: struct #72 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first Post out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first Post out.snap index 310002f53..c25bd0182 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first Post out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first Post out.snap @@ -1,12 +1,12 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: optional '_22__PostOutputType?' #22 └─ item: struct '_PostOutputType' #21 + ├─ [author]: struct '_UserOutputType_excluding___rel_Post_User_1' #20 + │ ├─ [id]: integer #7 + │ └─ [name]: string #8 ├─ [id]: integer #12 - ├─ [title]: string #13 - └─ [author]: struct '_UserOutputType_excluding___rel_Post_User_1' #20 - ├─ [id]: integer #7 - └─ [name]: string #8 + └─ [title]: string #13 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first Record out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first Record out.snap index cd47fbec2..01cc66dda 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first Record out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first Record out.snap @@ -1,11 +1,11 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: "tree::PrintOptions::new().indent_size(3).print(out)" --- root: optional '_6__RecordOutputType?' #6 └─ item: struct '_RecordOutputType' #5 + ├─ [age]: optional #3 + │ └─ item: integer #2 ├─ [id]: string #0 - ├─ [name]: string #1 - └─ [age]: optional #3 - └─ item: integer #2 + └─ [name]: string #1 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first User out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first User out.snap index af4195a74..0037edd31 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first User out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_first User out.snap @@ -1,6 +1,6 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: optional '_19__UserOutputType?' #19 └─ item: struct '_UserOutputType' #18 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Post inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Post inp.snap index 70b82c33f..640d14e2a 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Post inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Post inp.snap @@ -1,260 +1,260 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct '_Post_QueryInput' #159 -├─ [where]: optional '_143_QueryPostWhereInput?' #143 -│ └─ item: struct 'QueryPostWhereInput' #142 -│ ├─ [id]: optional '_122__integer_filter_c?' #122 -│ │ └─ item: optional '_integer_filter_c' #34 -│ │ └─ item: union #33 -│ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ ├─ variant_0: integer #23 -│ │ │ ├─ variant_1: struct #26 -│ │ │ │ └─ [equals]: integer #23 -│ │ │ ├─ variant_2: struct #27 -│ │ │ │ └─ [not]: integer #23 -│ │ │ ├─ variant_3: struct #28 -│ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ [gte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ variant_4: struct #29 -│ │ │ │ └─ [in]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_5: struct #30 -│ │ │ └─ [notIn]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_1: struct #32 -│ │ └─ [not]: either '_integer_filter' #31 -│ │ ├─ variant_0: integer #23 -│ │ ├─ variant_1: struct #26 -│ │ │ └─ [equals]: integer #23 -│ │ ├─ variant_2: struct #27 -│ │ │ └─ [not]: integer #23 -│ │ ├─ variant_3: struct #28 -│ │ │ ├─ [lt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [gt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [lte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ [gte]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ variant_4: struct #29 -│ │ │ └─ [in]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_5: struct #30 -│ │ └─ [notIn]: list #25 -│ │ └─ item: integer #23 -│ ├─ [title]: optional '_123__string_filter_c?' #123 -│ │ └─ item: optional '_string_filter_c' #20 -│ │ └─ item: union #19 -│ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ variant_1: struct #18 -│ │ └─ [not]: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ ├─ [author]: optional '_136_UserWhere__skip_77_PostWhere?' #136 -│ │ └─ item: struct 'UserWhere__skip_77_PostWhere' #135 -│ │ ├─ [id]: optional '_124__integer_filter_c?' #124 -│ │ │ └─ item: optional '_integer_filter_c' #34 -│ │ │ └─ item: union #33 -│ │ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_5: struct #30 -│ │ │ │ └─ [notIn]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_1: struct #32 -│ │ │ └─ [not]: either '_integer_filter' #31 -│ │ │ ├─ variant_0: integer #23 -│ │ │ ├─ variant_1: struct #26 -│ │ │ │ └─ [equals]: integer #23 -│ │ │ ├─ variant_2: struct #27 -│ │ │ │ └─ [not]: integer #23 -│ │ │ ├─ variant_3: struct #28 -│ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ [gte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ variant_4: struct #29 -│ │ │ │ └─ [in]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_5: struct #30 -│ │ │ └─ [notIn]: list #25 -│ │ │ └─ item: integer #23 -│ │ ├─ [name]: optional '_125__string_filter_c?' #125 -│ │ │ └─ item: optional '_string_filter_c' #20 -│ │ │ └─ item: union #19 -│ │ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ │ ├─ variant_0: string #5 -│ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ └─ [not]: string #5 -│ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ └─ [search]: string #5 -│ │ │ │ └─ variant_7: struct #16 -│ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ variant_1: struct #18 -│ │ │ └─ [not]: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [posts]: optional #134 -│ │ └─ item: union #133 -│ │ ├─ variant_0: struct #128 -│ │ │ └─ [every]: optional '_127_PostWhere?' #127 -│ │ │ └─ item: &PostWhere #126 -│ │ ├─ variant_1: struct #130 -│ │ │ └─ [some]: optional '_129_PostWhere?' #129 -│ │ │ └─ item: &PostWhere #126 -│ │ └─ variant_2: struct #132 -│ │ └─ [none]: optional '_131_PostWhere?' #131 -│ │ └─ item: &PostWhere #126 -│ ├─ [AND]: optional '_140__139_QueryPostWhereInput[]?' #140 -│ │ └─ item: list '_139_QueryPostWhereInput[]' #139 -│ │ └─ item: &QueryPostWhereInput #138 -│ ├─ [OR]: optional '_140__139_QueryPostWhereInput[]?' #140 -│ │ └─ item: list '_139_QueryPostWhereInput[]' #139 -│ │ └─ item: &QueryPostWhereInput #138 -│ └─ [NOT]: optional '_141_QueryPostWhereInput?' #141 -│ └─ item: &QueryPostWhereInput #138 +├─ [cursor]: optional '_155__Post_Cursor?' #155 +│ └─ item: union '_Post_Cursor' #154 +│ ├─ variant_0: struct #152 +│ │ └─ [id]: integer #74 +│ └─ variant_1: struct #153 +│ └─ [title]: string #75 +├─ [distinct]: optional '_158__KeysOf_Post?' #158 +│ └─ item: list '_KeysOf_Post' #157 +│ └─ item: string #156 enum{ '"id"', '"title"', '"author"' } ├─ [orderBy]: optional '_149__Post_OrderBy?' #149 │ └─ item: list '_Post_OrderBy' #148 │ └─ item: struct #147 +│ ├─ [author]: optional '_146__User_OrderBy_excluding___rel_Post_User_1?' #146 +│ │ └─ item: list '_User_OrderBy_excluding___rel_Post_User_1' #145 +│ │ └─ item: struct #144 +│ │ ├─ [id]: optional '_Sort' #47 +│ │ │ └─ item: union #46 +│ │ │ ├─ variant_0: struct #45 +│ │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ │ └─ [name]: optional '_Sort' #47 +│ │ └─ item: union #46 +│ │ ├─ variant_0: struct #45 +│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ ├─ [id]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [title]: optional '_Sort' #47 -│ │ └─ item: union #46 -│ │ ├─ variant_0: struct #45 -│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └─ [author]: optional '_146__User_OrderBy_excluding___rel_Post_User_1?' #146 -│ └─ item: list '_User_OrderBy_excluding___rel_Post_User_1' #145 -│ └─ item: struct #144 -│ ├─ [id]: optional '_Sort' #47 -│ │ └─ item: union #46 -│ │ ├─ variant_0: struct #45 -│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └─ [name]: optional '_Sort' #47 -│ └─ item: union #46 -│ ├─ variant_0: struct #45 -│ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -├─ [take]: optional '_150__Take?' #150 -│ └─ item: integer '_Take' #54 +│ └─ [title]: optional '_Sort' #47 +│ └─ item: union #46 +│ ├─ variant_0: struct #45 +│ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } ├─ [skip]: optional '_151__Skip?' #151 │ └─ item: integer '_Skip' #56 -├─ [cursor]: optional '_155__Post_Cursor?' #155 -│ └─ item: union '_Post_Cursor' #154 -│ ├─ variant_0: struct #152 -│ │ └─ [id]: integer #74 -│ └─ variant_1: struct #153 -│ └─ [title]: string #75 -└─ [distinct]: optional '_158__KeysOf_Post?' #158 - └─ item: list '_KeysOf_Post' #157 - └─ item: string #156 enum{ '"id"', '"title"', '"author"' } +├─ [take]: optional '_150__Take?' #150 +│ └─ item: integer '_Take' #54 +└─ [where]: optional '_143_QueryPostWhereInput?' #143 + └─ item: struct 'QueryPostWhereInput' #142 + ├─ [AND]: optional '_140__139_QueryPostWhereInput[]?' #140 + │ └─ item: list '_139_QueryPostWhereInput[]' #139 + │ └─ item: &QueryPostWhereInput #138 + ├─ [NOT]: optional '_141_QueryPostWhereInput?' #141 + │ └─ item: &QueryPostWhereInput #138 + ├─ [OR]: optional '_140__139_QueryPostWhereInput[]?' #140 + │ └─ item: list '_139_QueryPostWhereInput[]' #139 + │ └─ item: &QueryPostWhereInput #138 + ├─ [author]: optional '_136_UserWhere__skip_77_PostWhere?' #136 + │ └─ item: struct 'UserWhere__skip_77_PostWhere' #135 + │ ├─ [id]: optional '_124__integer_filter_c?' #124 + │ │ └─ item: optional '_integer_filter_c' #34 + │ │ └─ item: union #33 + │ │ ├─ variant_0: either '_integer_filter' #31 + │ │ │ ├─ variant_0: integer #23 + │ │ │ ├─ variant_1: struct #26 + │ │ │ │ └─ [equals]: integer #23 + │ │ │ ├─ variant_2: struct #27 + │ │ │ │ └─ [not]: integer #23 + │ │ │ ├─ variant_3: struct #28 + │ │ │ │ ├─ [gt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [gte]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [lt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ └─ [lte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ variant_4: struct #29 + │ │ │ │ └─ [in]: list #25 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ variant_5: struct #30 + │ │ │ └─ [notIn]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_1: struct #32 + │ │ └─ [not]: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ ├─ [name]: optional '_125__string_filter_c?' #125 + │ │ └─ item: optional '_string_filter_c' #20 + │ │ └─ item: union #19 + │ │ ├─ variant_0: union '_string_filter' #17 + │ │ │ ├─ variant_0: string #5 + │ │ │ ├─ variant_1: struct #8 + │ │ │ │ └─ [equals]: string #5 + │ │ │ ├─ variant_2: struct #9 + │ │ │ │ └─ [not]: string #5 + │ │ │ ├─ variant_3: struct #10 + │ │ │ │ └─ [in]: list #7 + │ │ │ │ └─ item: string #5 + │ │ │ ├─ variant_4: struct #11 + │ │ │ │ └─ [notIn]: list #7 + │ │ │ │ └─ item: string #5 + │ │ │ ├─ variant_5: struct #14 + │ │ │ │ ├─ [contains]: string #5 + │ │ │ │ └─ [mode]: optional #13 + │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #15 + │ │ │ │ └─ [search]: string #5 + │ │ │ └─ variant_7: struct #16 + │ │ │ ├─ [endsWith]: optional #6 + │ │ │ │ └─ item: string #5 + │ │ │ └─ [startsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ variant_1: struct #18 + │ │ └─ [not]: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [posts]: optional #134 + │ └─ item: union #133 + │ ├─ variant_0: struct #128 + │ │ └─ [every]: optional '_127_PostWhere?' #127 + │ │ └─ item: &PostWhere #126 + │ ├─ variant_1: struct #130 + │ │ └─ [some]: optional '_129_PostWhere?' #129 + │ │ └─ item: &PostWhere #126 + │ └─ variant_2: struct #132 + │ └─ [none]: optional '_131_PostWhere?' #131 + │ └─ item: &PostWhere #126 + ├─ [id]: optional '_122__integer_filter_c?' #122 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 + └─ [title]: optional '_123__string_filter_c?' #123 + └─ item: optional '_string_filter_c' #20 + └─ item: union #19 + ├─ variant_0: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_1: struct #18 + └─ [not]: union '_string_filter' #17 + ├─ variant_0: string #5 + ├─ variant_1: struct #8 + │ └─ [equals]: string #5 + ├─ variant_2: struct #9 + │ └─ [not]: string #5 + ├─ variant_3: struct #10 + │ └─ [in]: list #7 + │ └─ item: string #5 + ├─ variant_4: struct #11 + │ └─ [notIn]: list #7 + │ └─ item: string #5 + ├─ variant_5: struct #14 + │ ├─ [contains]: string #5 + │ └─ [mode]: optional #13 + │ └─ item: string #12 enum{ '"insensitive"' } + ├─ variant_6: struct #15 + │ └─ [search]: string #5 + └─ variant_7: struct #16 + ├─ [endsWith]: optional #6 + │ └─ item: string #5 + └─ [startsWith]: optional #6 + └─ item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Post out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Post out.snap index fa156a5ef..c08864506 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Post out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Post out.snap @@ -1,14 +1,14 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: list '_161_PostWithNestedCount[]' #161 └─ item: struct 'PostWithNestedCount' #160 + ├─ [author]: struct 'User' #73 + │ ├─ [id]: integer #69 + │ ├─ [name]: string #70 + │ └─ [posts]: list '_72_Post[]' #72 + │ └─ item: &Post #71 ├─ [id]: integer #74 - ├─ [title]: string #75 - └─ [author]: struct 'User' #73 - ├─ [id]: integer #69 - ├─ [name]: string #70 - └─ [posts]: list '_72_Post[]' #72 - └─ item: &Post #71 + └─ [title]: string #75 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Record inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Record inp.snap index 23b293600..d6061292d 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Record inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Record inp.snap @@ -1,196 +1,196 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct '_Record_QueryInput' #66 -├─ [where]: optional '_42_QueryRecordWhereInput?' #42 -│ └─ item: struct 'QueryRecordWhereInput' #41 -│ ├─ [id]: optional '_21__string_filter_c?' #21 -│ │ └─ item: optional '_string_filter_c' #20 -│ │ └─ item: union #19 -│ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ variant_1: struct #18 -│ │ └─ [not]: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ ├─ [name]: optional '_22__string_filter_c?' #22 -│ │ └─ item: optional '_string_filter_c' #20 -│ │ └─ item: union #19 -│ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ variant_1: struct #18 -│ │ └─ [not]: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ ├─ [age]: optional '_35__integer_filter_c?' #35 -│ │ └─ item: optional '_integer_filter_c' #34 -│ │ └─ item: union #33 -│ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ ├─ variant_0: integer #23 -│ │ │ ├─ variant_1: struct #26 -│ │ │ │ └─ [equals]: integer #23 -│ │ │ ├─ variant_2: struct #27 -│ │ │ │ └─ [not]: integer #23 -│ │ │ ├─ variant_3: struct #28 -│ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ [gte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ variant_4: struct #29 -│ │ │ │ └─ [in]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_5: struct #30 -│ │ │ └─ [notIn]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_1: struct #32 -│ │ └─ [not]: either '_integer_filter' #31 -│ │ ├─ variant_0: integer #23 -│ │ ├─ variant_1: struct #26 -│ │ │ └─ [equals]: integer #23 -│ │ ├─ variant_2: struct #27 -│ │ │ └─ [not]: integer #23 -│ │ ├─ variant_3: struct #28 -│ │ │ ├─ [lt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [gt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [lte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ [gte]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ variant_4: struct #29 -│ │ │ └─ [in]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_5: struct #30 -│ │ └─ [notIn]: list #25 -│ │ └─ item: integer #23 -│ ├─ [AND]: optional '_39__38_QueryRecordWhereInput[]?' #39 -│ │ └─ item: list '_38_QueryRecordWhereInput[]' #38 -│ │ └─ item: &QueryRecordWhereInput #37 -│ ├─ [OR]: optional '_39__38_QueryRecordWhereInput[]?' #39 -│ │ └─ item: list '_38_QueryRecordWhereInput[]' #38 -│ │ └─ item: &QueryRecordWhereInput #37 -│ └─ [NOT]: optional '_40_QueryRecordWhereInput?' #40 -│ └─ item: &QueryRecordWhereInput #37 +├─ [cursor]: optional '_62__Record_Cursor?' #62 +│ └─ item: union '_Record_Cursor' #61 +│ ├─ variant_0: struct #58 +│ │ └─ [id]: string #0 +│ ├─ variant_1: struct #59 +│ │ └─ [name]: string #1 +│ └─ variant_2: struct #60 +│ └─ [age]: integer #2 +├─ [distinct]: optional '_65__KeysOf_Record?' #65 +│ └─ item: list '_KeysOf_Record' #64 +│ └─ item: string #63 enum{ '"id"', '"name"', '"age"' } ├─ [orderBy]: optional '_53__Record_OrderBy?' #53 │ └─ item: list '_Record_OrderBy' #52 │ └─ item: struct #51 -│ ├─ [id]: optional '_Sort' #47 -│ │ └─ item: union #46 -│ │ ├─ variant_0: struct #45 +│ ├─ [age]: optional '_Sort_nullable' #50 +│ │ └─ item: union #49 +│ │ ├─ variant_0: struct #48 +│ │ │ ├─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [name]: optional '_Sort' #47 +│ ├─ [id]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └─ [age]: optional '_Sort_nullable' #50 -│ └─ item: union #49 -│ ├─ variant_0: struct #48 -│ │ ├─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ └─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } +│ └─ [name]: optional '_Sort' #47 +│ └─ item: union #46 +│ ├─ variant_0: struct #45 +│ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -├─ [take]: optional '_55__Take?' #55 -│ └─ item: integer '_Take' #54 ├─ [skip]: optional '_57__Skip?' #57 │ └─ item: integer '_Skip' #56 -├─ [cursor]: optional '_62__Record_Cursor?' #62 -│ └─ item: union '_Record_Cursor' #61 -│ ├─ variant_0: struct #58 -│ │ └─ [id]: string #0 -│ ├─ variant_1: struct #59 -│ │ └─ [name]: string #1 -│ └─ variant_2: struct #60 -│ └─ [age]: integer #2 -└─ [distinct]: optional '_65__KeysOf_Record?' #65 - └─ item: list '_KeysOf_Record' #64 - └─ item: string #63 enum{ '"id"', '"name"', '"age"' } +├─ [take]: optional '_55__Take?' #55 +│ └─ item: integer '_Take' #54 +└─ [where]: optional '_42_QueryRecordWhereInput?' #42 + └─ item: struct 'QueryRecordWhereInput' #41 + ├─ [AND]: optional '_39__38_QueryRecordWhereInput[]?' #39 + │ └─ item: list '_38_QueryRecordWhereInput[]' #38 + │ └─ item: &QueryRecordWhereInput #37 + ├─ [NOT]: optional '_40_QueryRecordWhereInput?' #40 + │ └─ item: &QueryRecordWhereInput #37 + ├─ [OR]: optional '_39__38_QueryRecordWhereInput[]?' #39 + │ └─ item: list '_38_QueryRecordWhereInput[]' #38 + │ └─ item: &QueryRecordWhereInput #37 + ├─ [age]: optional '_35__integer_filter_c?' #35 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 + ├─ [id]: optional '_21__string_filter_c?' #21 + │ └─ item: optional '_string_filter_c' #20 + │ └─ item: union #19 + │ ├─ variant_0: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ variant_1: struct #18 + │ └─ [not]: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ [name]: optional '_22__string_filter_c?' #22 + └─ item: optional '_string_filter_c' #20 + └─ item: union #19 + ├─ variant_0: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_1: struct #18 + └─ [not]: union '_string_filter' #17 + ├─ variant_0: string #5 + ├─ variant_1: struct #8 + │ └─ [equals]: string #5 + ├─ variant_2: struct #9 + │ └─ [not]: string #5 + ├─ variant_3: struct #10 + │ └─ [in]: list #7 + │ └─ item: string #5 + ├─ variant_4: struct #11 + │ └─ [notIn]: list #7 + │ └─ item: string #5 + ├─ variant_5: struct #14 + │ ├─ [contains]: string #5 + │ └─ [mode]: optional #13 + │ └─ item: string #12 enum{ '"insensitive"' } + ├─ variant_6: struct #15 + │ └─ [search]: string #5 + └─ variant_7: struct #16 + ├─ [endsWith]: optional #6 + │ └─ item: string #5 + └─ [startsWith]: optional #6 + └─ item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Record out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Record out.snap index 6db70d211..15ac6c65a 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Record out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many Record out.snap @@ -1,11 +1,11 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: "tree::PrintOptions::new().indent_size(3).print(out)" --- root: list '_68_RecordWithNestedCount[]' #68 └─ item: struct 'RecordWithNestedCount' #67 + ├─ [age]: optional #3 + │ └─ item: integer #2 ├─ [id]: string #0 - ├─ [name]: string #1 - └─ [age]: optional #3 - └─ item: integer #2 + └─ [name]: string #1 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many User inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many User inp.snap index 2709c29d9..d533b041e 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many User inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many User inp.snap @@ -1,419 +1,17 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct '_User_QueryInput' #114 -├─ [where]: optional '_99_QueryUserWhereInput?' #99 -│ └─ item: struct 'QueryUserWhereInput' #98 -│ ├─ [id]: optional '_78__integer_filter_c?' #78 -│ │ └─ item: optional '_integer_filter_c' #34 -│ │ └─ item: union #33 -│ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ ├─ variant_0: integer #23 -│ │ │ ├─ variant_1: struct #26 -│ │ │ │ └─ [equals]: integer #23 -│ │ │ ├─ variant_2: struct #27 -│ │ │ │ └─ [not]: integer #23 -│ │ │ ├─ variant_3: struct #28 -│ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ [gte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ variant_4: struct #29 -│ │ │ │ └─ [in]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_5: struct #30 -│ │ │ └─ [notIn]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_1: struct #32 -│ │ └─ [not]: either '_integer_filter' #31 -│ │ ├─ variant_0: integer #23 -│ │ ├─ variant_1: struct #26 -│ │ │ └─ [equals]: integer #23 -│ │ ├─ variant_2: struct #27 -│ │ │ └─ [not]: integer #23 -│ │ ├─ variant_3: struct #28 -│ │ │ ├─ [lt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [gt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [lte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ [gte]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ variant_4: struct #29 -│ │ │ └─ [in]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_5: struct #30 -│ │ └─ [notIn]: list #25 -│ │ └─ item: integer #23 -│ ├─ [name]: optional '_79__string_filter_c?' #79 -│ │ └─ item: optional '_string_filter_c' #20 -│ │ └─ item: union #19 -│ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ variant_1: struct #18 -│ │ └─ [not]: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ ├─ [posts]: optional #92 -│ │ └─ item: union #91 -│ │ ├─ variant_0: struct #86 -│ │ │ └─ [every]: optional '_85_PostWhere__skip_73_UserWhere?' #85 -│ │ │ └─ item: struct 'PostWhere__skip_73_UserWhere' #84 -│ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ │ └─ item: optional '_integer_filter_c' #34 -│ │ │ │ └─ item: union #33 -│ │ │ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ variant_5: struct #30 -│ │ │ │ │ └─ [notIn]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_1: struct #32 -│ │ │ │ └─ [not]: either '_integer_filter' #31 -│ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_5: struct #30 -│ │ │ │ └─ [notIn]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [title]: optional '_81__string_filter_c?' #81 -│ │ │ │ └─ item: optional '_string_filter_c' #20 -│ │ │ │ └─ item: union #19 -│ │ │ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ │ │ ├─ variant_0: string #5 -│ │ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ │ └─ [not]: string #5 -│ │ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ │ └─ [search]: string #5 -│ │ │ │ │ └─ variant_7: struct #16 -│ │ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ variant_1: struct #18 -│ │ │ │ └─ [not]: union '_string_filter' #17 -│ │ │ │ ├─ variant_0: string #5 -│ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ └─ [not]: string #5 -│ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ └─ [search]: string #5 -│ │ │ │ └─ variant_7: struct #16 -│ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [author]: optional '_83_UserWhere?' #83 -│ │ │ └─ item: &UserWhere #82 -│ │ ├─ variant_1: struct #88 -│ │ │ └─ [some]: optional '_87_PostWhere__skip_73_UserWhere?' #87 -│ │ │ └─ item: struct 'PostWhere__skip_73_UserWhere' #84 -│ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ │ └─ item: optional '_integer_filter_c' #34 -│ │ │ │ └─ item: union #33 -│ │ │ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ variant_5: struct #30 -│ │ │ │ │ └─ [notIn]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_1: struct #32 -│ │ │ │ └─ [not]: either '_integer_filter' #31 -│ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_5: struct #30 -│ │ │ │ └─ [notIn]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [title]: optional '_81__string_filter_c?' #81 -│ │ │ │ └─ item: optional '_string_filter_c' #20 -│ │ │ │ └─ item: union #19 -│ │ │ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ │ │ ├─ variant_0: string #5 -│ │ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ │ └─ [not]: string #5 -│ │ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ │ └─ [search]: string #5 -│ │ │ │ │ └─ variant_7: struct #16 -│ │ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ variant_1: struct #18 -│ │ │ │ └─ [not]: union '_string_filter' #17 -│ │ │ │ ├─ variant_0: string #5 -│ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ └─ [not]: string #5 -│ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ └─ [search]: string #5 -│ │ │ │ └─ variant_7: struct #16 -│ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [author]: optional '_83_UserWhere?' #83 -│ │ │ └─ item: &UserWhere #82 -│ │ └─ variant_2: struct #90 -│ │ └─ [none]: optional '_89_PostWhere__skip_73_UserWhere?' #89 -│ │ └─ item: struct 'PostWhere__skip_73_UserWhere' #84 -│ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ └─ item: optional '_integer_filter_c' #34 -│ │ │ └─ item: union #33 -│ │ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_5: struct #30 -│ │ │ │ └─ [notIn]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_1: struct #32 -│ │ │ └─ [not]: either '_integer_filter' #31 -│ │ │ ├─ variant_0: integer #23 -│ │ │ ├─ variant_1: struct #26 -│ │ │ │ └─ [equals]: integer #23 -│ │ │ ├─ variant_2: struct #27 -│ │ │ │ └─ [not]: integer #23 -│ │ │ ├─ variant_3: struct #28 -│ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ [gte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ variant_4: struct #29 -│ │ │ │ └─ [in]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_5: struct #30 -│ │ │ └─ [notIn]: list #25 -│ │ │ └─ item: integer #23 -│ │ ├─ [title]: optional '_81__string_filter_c?' #81 -│ │ │ └─ item: optional '_string_filter_c' #20 -│ │ │ └─ item: union #19 -│ │ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ │ ├─ variant_0: string #5 -│ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ └─ [not]: string #5 -│ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ └─ [search]: string #5 -│ │ │ │ └─ variant_7: struct #16 -│ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ variant_1: struct #18 -│ │ │ └─ [not]: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [author]: optional '_83_UserWhere?' #83 -│ │ └─ item: &UserWhere #82 -│ ├─ [AND]: optional '_96__95_QueryUserWhereInput[]?' #96 -│ │ └─ item: list '_95_QueryUserWhereInput[]' #95 -│ │ └─ item: &QueryUserWhereInput #94 -│ ├─ [OR]: optional '_96__95_QueryUserWhereInput[]?' #96 -│ │ └─ item: list '_95_QueryUserWhereInput[]' #95 -│ │ └─ item: &QueryUserWhereInput #94 -│ └─ [NOT]: optional '_97_QueryUserWhereInput?' #97 -│ └─ item: &QueryUserWhereInput #94 +├─ [cursor]: optional '_110__User_Cursor?' #110 +│ └─ item: union '_User_Cursor' #109 +│ ├─ variant_0: struct #107 +│ │ └─ [id]: integer #69 +│ └─ variant_1: struct #108 +│ └─ [name]: string #70 +├─ [distinct]: optional '_113__KeysOf_User?' #113 +│ └─ item: list '_KeysOf_User' #112 +│ └─ item: string #111 enum{ '"id"', '"name"', '"posts"' } ├─ [orderBy]: optional '_104__User_OrderBy?' #104 │ └─ item: list '_User_OrderBy' #103 │ └─ item: struct #102 @@ -429,17 +27,17 @@ root: struct '_User_QueryInput' #114 │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ └─ [posts]: optional '_SortByAggregates' #101 │ └─ item: struct #100 -│ ├─ [_count]: optional '_Sort' #47 +│ ├─ [_avg]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_avg]: optional '_Sort' #47 +│ ├─ [_count]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_sum]: optional '_Sort' #47 +│ ├─ [_max]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } @@ -449,22 +47,424 @@ root: struct '_User_QueryInput' #114 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └─ [_max]: optional '_Sort' #47 +│ └─ [_sum]: optional '_Sort' #47 │ └─ item: union #46 │ ├─ variant_0: struct #45 │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -├─ [take]: optional '_105__Take?' #105 -│ └─ item: integer '_Take' #54 ├─ [skip]: optional '_106__Skip?' #106 │ └─ item: integer '_Skip' #56 -├─ [cursor]: optional '_110__User_Cursor?' #110 -│ └─ item: union '_User_Cursor' #109 -│ ├─ variant_0: struct #107 -│ │ └─ [id]: integer #69 -│ └─ variant_1: struct #108 -│ └─ [name]: string #70 -└─ [distinct]: optional '_113__KeysOf_User?' #113 - └─ item: list '_KeysOf_User' #112 - └─ item: string #111 enum{ '"id"', '"name"', '"posts"' } +├─ [take]: optional '_105__Take?' #105 +│ └─ item: integer '_Take' #54 +└─ [where]: optional '_99_QueryUserWhereInput?' #99 + └─ item: struct 'QueryUserWhereInput' #98 + ├─ [AND]: optional '_96__95_QueryUserWhereInput[]?' #96 + │ └─ item: list '_95_QueryUserWhereInput[]' #95 + │ └─ item: &QueryUserWhereInput #94 + ├─ [NOT]: optional '_97_QueryUserWhereInput?' #97 + │ └─ item: &QueryUserWhereInput #94 + ├─ [OR]: optional '_96__95_QueryUserWhereInput[]?' #96 + │ └─ item: list '_95_QueryUserWhereInput[]' #95 + │ └─ item: &QueryUserWhereInput #94 + ├─ [id]: optional '_78__integer_filter_c?' #78 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 + ├─ [name]: optional '_79__string_filter_c?' #79 + │ └─ item: optional '_string_filter_c' #20 + │ └─ item: union #19 + │ ├─ variant_0: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ variant_1: struct #18 + │ └─ [not]: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ [posts]: optional #92 + └─ item: union #91 + ├─ variant_0: struct #86 + │ └─ [every]: optional '_85_PostWhere__skip_73_UserWhere?' #85 + │ └─ item: struct 'PostWhere__skip_73_UserWhere' #84 + │ ├─ [author]: optional '_83_UserWhere?' #83 + │ │ └─ item: &UserWhere #82 + │ ├─ [id]: optional '_80__integer_filter_c?' #80 + │ │ └─ item: optional '_integer_filter_c' #34 + │ │ └─ item: union #33 + │ │ ├─ variant_0: either '_integer_filter' #31 + │ │ │ ├─ variant_0: integer #23 + │ │ │ ├─ variant_1: struct #26 + │ │ │ │ └─ [equals]: integer #23 + │ │ │ ├─ variant_2: struct #27 + │ │ │ │ └─ [not]: integer #23 + │ │ │ ├─ variant_3: struct #28 + │ │ │ │ ├─ [gt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [gte]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [lt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ └─ [lte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ variant_4: struct #29 + │ │ │ │ └─ [in]: list #25 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ variant_5: struct #30 + │ │ │ └─ [notIn]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_1: struct #32 + │ │ └─ [not]: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ [title]: optional '_81__string_filter_c?' #81 + │ └─ item: optional '_string_filter_c' #20 + │ └─ item: union #19 + │ ├─ variant_0: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ variant_1: struct #18 + │ └─ [not]: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + ├─ variant_1: struct #88 + │ └─ [some]: optional '_87_PostWhere__skip_73_UserWhere?' #87 + │ └─ item: struct 'PostWhere__skip_73_UserWhere' #84 + │ ├─ [author]: optional '_83_UserWhere?' #83 + │ │ └─ item: &UserWhere #82 + │ ├─ [id]: optional '_80__integer_filter_c?' #80 + │ │ └─ item: optional '_integer_filter_c' #34 + │ │ └─ item: union #33 + │ │ ├─ variant_0: either '_integer_filter' #31 + │ │ │ ├─ variant_0: integer #23 + │ │ │ ├─ variant_1: struct #26 + │ │ │ │ └─ [equals]: integer #23 + │ │ │ ├─ variant_2: struct #27 + │ │ │ │ └─ [not]: integer #23 + │ │ │ ├─ variant_3: struct #28 + │ │ │ │ ├─ [gt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [gte]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [lt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ └─ [lte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ variant_4: struct #29 + │ │ │ │ └─ [in]: list #25 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ variant_5: struct #30 + │ │ │ └─ [notIn]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_1: struct #32 + │ │ └─ [not]: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ [title]: optional '_81__string_filter_c?' #81 + │ └─ item: optional '_string_filter_c' #20 + │ └─ item: union #19 + │ ├─ variant_0: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ variant_1: struct #18 + │ └─ [not]: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_2: struct #90 + └─ [none]: optional '_89_PostWhere__skip_73_UserWhere?' #89 + └─ item: struct 'PostWhere__skip_73_UserWhere' #84 + ├─ [author]: optional '_83_UserWhere?' #83 + │ └─ item: &UserWhere #82 + ├─ [id]: optional '_80__integer_filter_c?' #80 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 + └─ [title]: optional '_81__string_filter_c?' #81 + └─ item: optional '_string_filter_c' #20 + └─ item: union #19 + ├─ variant_0: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_1: struct #18 + └─ [not]: union '_string_filter' #17 + ├─ variant_0: string #5 + ├─ variant_1: struct #8 + │ └─ [equals]: string #5 + ├─ variant_2: struct #9 + │ └─ [not]: string #5 + ├─ variant_3: struct #10 + │ └─ [in]: list #7 + │ └─ item: string #5 + ├─ variant_4: struct #11 + │ └─ [notIn]: list #7 + │ └─ item: string #5 + ├─ variant_5: struct #14 + │ ├─ [contains]: string #5 + │ └─ [mode]: optional #13 + │ └─ item: string #12 enum{ '"insensitive"' } + ├─ variant_6: struct #15 + │ └─ [search]: string #5 + └─ variant_7: struct #16 + ├─ [endsWith]: optional #6 + │ └─ item: string #5 + └─ [startsWith]: optional #6 + └─ item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many User out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many User out.snap index f4c1eec31..ad8f48c68 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many User out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_many User out.snap @@ -1,16 +1,16 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: list '_121_UserWithNestedCount[]' #121 └─ item: struct 'UserWithNestedCount' #120 + ├─ [_count]: struct #119 + │ └─ [posts]: optional '_Count' #118 + │ └─ item: integer #117 ├─ [id]: integer #69 ├─ [name]: string #70 - ├─ [posts]: list '_116_PostWithNestedCount_excluding___rel_Post_User_1[]' #116 - │ └─ item: struct 'PostWithNestedCount_excluding___rel_Post_User_1' #115 - │ ├─ [id]: integer #74 - │ └─ [title]: string #75 - └─ [_count]: struct #119 - └─ [posts]: optional '_Count' #118 - └─ item: integer #117 + └─ [posts]: list '_116_PostWithNestedCount_excluding___rel_Post_User_1[]' #116 + └─ item: struct 'PostWithNestedCount_excluding___rel_Post_User_1' #115 + ├─ [id]: integer #74 + └─ [title]: string #75 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Post inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Post inp.snap index 15774b076..86b51ad88 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Post inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Post inp.snap @@ -1,106 +1,18 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #107 └─ [where]: optional '_106_QueryPostWhereUniqueInput?' #106 └─ item: struct 'QueryPostWhereUniqueInput' #105 - ├─ [id]: optional '_85__integer_filter_c?' #85 - │ └─ item: optional '_integer_filter_c' #34 - │ └─ item: union #33 - │ ├─ variant_0: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_1: struct #32 - │ └─ [not]: either '_integer_filter' #31 - │ ├─ variant_0: integer #23 - │ ├─ variant_1: struct #26 - │ │ └─ [equals]: integer #23 - │ ├─ variant_2: struct #27 - │ │ └─ [not]: integer #23 - │ ├─ variant_3: struct #28 - │ │ ├─ [lt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [gt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [lte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ └─ [gte]: optional #24 - │ │ └─ item: integer #23 - │ ├─ variant_4: struct #29 - │ │ └─ [in]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_5: struct #30 - │ └─ [notIn]: list #25 - │ └─ item: integer #23 - ├─ [title]: optional '_86__string_filter_c?' #86 - │ └─ item: optional '_string_filter_c' #20 - │ └─ item: union #19 - │ ├─ variant_0: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ variant_1: struct #18 - │ └─ [not]: union '_string_filter' #17 - │ ├─ variant_0: string #5 - │ ├─ variant_1: struct #8 - │ │ └─ [equals]: string #5 - │ ├─ variant_2: struct #9 - │ │ └─ [not]: string #5 - │ ├─ variant_3: struct #10 - │ │ └─ [in]: list #7 - │ │ └─ item: string #5 - │ ├─ variant_4: struct #11 - │ │ └─ [notIn]: list #7 - │ │ └─ item: string #5 - │ ├─ variant_5: struct #14 - │ │ ├─ [contains]: string #5 - │ │ └─ [mode]: optional #13 - │ │ └─ item: string #12 enum{ '"insensitive"' } - │ ├─ variant_6: struct #15 - │ │ └─ [search]: string #5 - │ └─ variant_7: struct #16 - │ ├─ [startsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [endsWith]: optional #6 - │ └─ item: string #5 + ├─ [AND]: optional '_103__102_QueryPostWhereUniqueInput[]?' #103 + │ └─ item: list '_102_QueryPostWhereUniqueInput[]' #102 + │ └─ item: &QueryPostWhereUniqueInput #101 + ├─ [NOT]: optional '_104_QueryPostWhereUniqueInput?' #104 + │ └─ item: &QueryPostWhereUniqueInput #101 + ├─ [OR]: optional '_103__102_QueryPostWhereUniqueInput[]?' #103 + │ └─ item: list '_102_QueryPostWhereUniqueInput[]' #102 + │ └─ item: &QueryPostWhereUniqueInput #101 ├─ [author]: optional '_99_UserWhere__skip_54_PostWhere?' #99 │ └─ item: struct 'UserWhere__skip_54_PostWhere' #98 │ ├─ [id]: optional '_87__integer_filter_c?' #87 @@ -113,13 +25,13 @@ root: struct #107 │ │ │ ├─ variant_2: struct #27 │ │ │ │ └─ [not]: integer #23 │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 │ │ │ │ ├─ [gt]: optional #24 │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 + │ │ │ │ ├─ [gte]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [lt]: optional #24 │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 + │ │ │ │ └─ [lte]: optional #24 │ │ │ │ └─ item: integer #23 │ │ │ ├─ variant_4: struct #29 │ │ │ │ └─ [in]: list #25 @@ -135,13 +47,13 @@ root: struct #107 │ │ ├─ variant_2: struct #27 │ │ │ └─ [not]: integer #23 │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 │ │ │ ├─ [gt]: optional #24 │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 + │ │ │ └─ [lte]: optional #24 │ │ │ └─ item: integer #23 │ │ ├─ variant_4: struct #29 │ │ │ └─ [in]: list #25 @@ -171,9 +83,9 @@ root: struct #107 │ │ │ ├─ variant_6: struct #15 │ │ │ │ └─ [search]: string #5 │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 + │ │ │ ├─ [endsWith]: optional #6 │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 + │ │ │ └─ [startsWith]: optional #6 │ │ │ └─ item: string #5 │ │ └─ variant_1: struct #18 │ │ └─ [not]: union '_string_filter' #17 @@ -195,9 +107,9 @@ root: struct #107 │ │ ├─ variant_6: struct #15 │ │ │ └─ [search]: string #5 │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 + │ │ ├─ [endsWith]: optional #6 │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 + │ │ └─ [startsWith]: optional #6 │ │ └─ item: string #5 │ └─ [posts]: optional #97 │ └─ item: union #96 @@ -210,12 +122,100 @@ root: struct #107 │ └─ variant_2: struct #95 │ └─ [none]: optional '_94_PostWhere?' #94 │ └─ item: &PostWhere #89 - ├─ [AND]: optional '_103__102_QueryPostWhereUniqueInput[]?' #103 - │ └─ item: list '_102_QueryPostWhereUniqueInput[]' #102 - │ └─ item: &QueryPostWhereUniqueInput #101 - ├─ [OR]: optional '_103__102_QueryPostWhereUniqueInput[]?' #103 - │ └─ item: list '_102_QueryPostWhereUniqueInput[]' #102 - │ └─ item: &QueryPostWhereUniqueInput #101 - └─ [NOT]: optional '_104_QueryPostWhereUniqueInput?' #104 - └─ item: &QueryPostWhereUniqueInput #101 + ├─ [id]: optional '_85__integer_filter_c?' #85 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 + └─ [title]: optional '_86__string_filter_c?' #86 + └─ item: optional '_string_filter_c' #20 + └─ item: union #19 + ├─ variant_0: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_1: struct #18 + └─ [not]: union '_string_filter' #17 + ├─ variant_0: string #5 + ├─ variant_1: struct #8 + │ └─ [equals]: string #5 + ├─ variant_2: struct #9 + │ └─ [not]: string #5 + ├─ variant_3: struct #10 + │ └─ [in]: list #7 + │ └─ item: string #5 + ├─ variant_4: struct #11 + │ └─ [notIn]: list #7 + │ └─ item: string #5 + ├─ variant_5: struct #14 + │ ├─ [contains]: string #5 + │ └─ [mode]: optional #13 + │ └─ item: string #12 enum{ '"insensitive"' } + ├─ variant_6: struct #15 + │ └─ [search]: string #5 + └─ variant_7: struct #16 + ├─ [endsWith]: optional #6 + │ └─ item: string #5 + └─ [startsWith]: optional #6 + └─ item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Post out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Post out.snap index 125855f15..0a1bbd224 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Post out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Post out.snap @@ -1,14 +1,14 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: optional '_109_PostWithNestedCount?' #109 └─ item: struct 'PostWithNestedCount' #108 + ├─ [author]: struct 'User' #50 + │ ├─ [id]: integer #46 + │ ├─ [name]: string #47 + │ └─ [posts]: list '_49_Post[]' #49 + │ └─ item: &Post #48 ├─ [id]: integer #51 - ├─ [title]: string #52 - └─ [author]: struct 'User' #50 - ├─ [id]: integer #46 - ├─ [name]: string #47 - └─ [posts]: list '_49_Post[]' #49 - └─ item: &Post #48 + └─ [title]: string #52 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Record inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Record inp.snap index 298445a07..7a6b67a53 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Record inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Record inp.snap @@ -1,10 +1,64 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #43 └─ [where]: optional '_42_QueryRecordWhereUniqueInput?' #42 └─ item: struct 'QueryRecordWhereUniqueInput' #41 + ├─ [AND]: optional '_39__38_QueryRecordWhereUniqueInput[]?' #39 + │ └─ item: list '_38_QueryRecordWhereUniqueInput[]' #38 + │ └─ item: &QueryRecordWhereUniqueInput #37 + ├─ [NOT]: optional '_40_QueryRecordWhereUniqueInput?' #40 + │ └─ item: &QueryRecordWhereUniqueInput #37 + ├─ [OR]: optional '_39__38_QueryRecordWhereUniqueInput[]?' #39 + │ └─ item: list '_38_QueryRecordWhereUniqueInput[]' #38 + │ └─ item: &QueryRecordWhereUniqueInput #37 + ├─ [age]: optional '_35__integer_filter_c?' #35 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 ├─ [id]: optional '_21__string_filter_c?' #21 │ └─ item: optional '_string_filter_c' #20 │ └─ item: union #19 @@ -27,9 +81,9 @@ root: struct #43 │ │ ├─ variant_6: struct #15 │ │ │ └─ [search]: string #5 │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 + │ │ ├─ [endsWith]: optional #6 │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 + │ │ └─ [startsWith]: optional #6 │ │ └─ item: string #5 │ └─ variant_1: struct #18 │ └─ [not]: union '_string_filter' #17 @@ -51,112 +105,58 @@ root: struct #43 │ ├─ variant_6: struct #15 │ │ └─ [search]: string #5 │ └─ variant_7: struct #16 - │ ├─ [startsWith]: optional #6 + │ ├─ [endsWith]: optional #6 │ │ └─ item: string #5 - │ └─ [endsWith]: optional #6 + │ └─ [startsWith]: optional #6 │ └─ item: string #5 - ├─ [name]: optional '_22__string_filter_c?' #22 - │ └─ item: optional '_string_filter_c' #20 - │ └─ item: union #19 - │ ├─ variant_0: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ variant_1: struct #18 - │ └─ [not]: union '_string_filter' #17 - │ ├─ variant_0: string #5 - │ ├─ variant_1: struct #8 - │ │ └─ [equals]: string #5 - │ ├─ variant_2: struct #9 - │ │ └─ [not]: string #5 - │ ├─ variant_3: struct #10 - │ │ └─ [in]: list #7 - │ │ └─ item: string #5 - │ ├─ variant_4: struct #11 - │ │ └─ [notIn]: list #7 - │ │ └─ item: string #5 - │ ├─ variant_5: struct #14 - │ │ ├─ [contains]: string #5 - │ │ └─ [mode]: optional #13 - │ │ └─ item: string #12 enum{ '"insensitive"' } - │ ├─ variant_6: struct #15 - │ │ └─ [search]: string #5 - │ └─ variant_7: struct #16 - │ ├─ [startsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [endsWith]: optional #6 - │ └─ item: string #5 - ├─ [age]: optional '_35__integer_filter_c?' #35 - │ └─ item: optional '_integer_filter_c' #34 - │ └─ item: union #33 - │ ├─ variant_0: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_1: struct #32 - │ └─ [not]: either '_integer_filter' #31 - │ ├─ variant_0: integer #23 - │ ├─ variant_1: struct #26 - │ │ └─ [equals]: integer #23 - │ ├─ variant_2: struct #27 - │ │ └─ [not]: integer #23 - │ ├─ variant_3: struct #28 - │ │ ├─ [lt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [gt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [lte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ └─ [gte]: optional #24 - │ │ └─ item: integer #23 - │ ├─ variant_4: struct #29 - │ │ └─ [in]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_5: struct #30 - │ └─ [notIn]: list #25 - │ └─ item: integer #23 - ├─ [AND]: optional '_39__38_QueryRecordWhereUniqueInput[]?' #39 - │ └─ item: list '_38_QueryRecordWhereUniqueInput[]' #38 - │ └─ item: &QueryRecordWhereUniqueInput #37 - ├─ [OR]: optional '_39__38_QueryRecordWhereUniqueInput[]?' #39 - │ └─ item: list '_38_QueryRecordWhereUniqueInput[]' #38 - │ └─ item: &QueryRecordWhereUniqueInput #37 - └─ [NOT]: optional '_40_QueryRecordWhereUniqueInput?' #40 - └─ item: &QueryRecordWhereUniqueInput #37 + └─ [name]: optional '_22__string_filter_c?' #22 + └─ item: optional '_string_filter_c' #20 + └─ item: union #19 + ├─ variant_0: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_1: struct #18 + └─ [not]: union '_string_filter' #17 + ├─ variant_0: string #5 + ├─ variant_1: struct #8 + │ └─ [equals]: string #5 + ├─ variant_2: struct #9 + │ └─ [not]: string #5 + ├─ variant_3: struct #10 + │ └─ [in]: list #7 + │ └─ item: string #5 + ├─ variant_4: struct #11 + │ └─ [notIn]: list #7 + │ └─ item: string #5 + ├─ variant_5: struct #14 + │ ├─ [contains]: string #5 + │ └─ [mode]: optional #13 + │ └─ item: string #12 enum{ '"insensitive"' } + ├─ variant_6: struct #15 + │ └─ [search]: string #5 + └─ variant_7: struct #16 + ├─ [endsWith]: optional #6 + │ └─ item: string #5 + └─ [startsWith]: optional #6 + └─ item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Record out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Record out.snap index e11417f3c..0f3831f86 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Record out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique Record out.snap @@ -1,11 +1,11 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: optional '_45_RecordWithNestedCount?' #45 └─ item: struct 'RecordWithNestedCount' #44 + ├─ [age]: optional #3 + │ └─ item: integer #2 ├─ [id]: string #0 - ├─ [name]: string #1 - └─ [age]: optional #3 - └─ item: integer #2 + └─ [name]: string #1 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique User inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique User inp.snap index 8f178b4ac..0c3524cff 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique User inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique User inp.snap @@ -1,10 +1,18 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #77 └─ [where]: optional '_76_QueryUserWhereUniqueInput?' #76 └─ item: struct 'QueryUserWhereUniqueInput' #75 + ├─ [AND]: optional '_73__72_QueryUserWhereUniqueInput[]?' #73 + │ └─ item: list '_72_QueryUserWhereUniqueInput[]' #72 + │ └─ item: &QueryUserWhereUniqueInput #71 + ├─ [NOT]: optional '_74_QueryUserWhereUniqueInput?' #74 + │ └─ item: &QueryUserWhereUniqueInput #71 + ├─ [OR]: optional '_73__72_QueryUserWhereUniqueInput[]?' #73 + │ └─ item: list '_72_QueryUserWhereUniqueInput[]' #72 + │ └─ item: &QueryUserWhereUniqueInput #71 ├─ [id]: optional '_55__integer_filter_c?' #55 │ └─ item: optional '_integer_filter_c' #34 │ └─ item: union #33 @@ -15,13 +23,13 @@ root: struct #77 │ │ ├─ variant_2: struct #27 │ │ │ └─ [not]: integer #23 │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 │ │ │ ├─ [gt]: optional #24 │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 + │ │ │ └─ [lte]: optional #24 │ │ │ └─ item: integer #23 │ │ ├─ variant_4: struct #29 │ │ │ └─ [in]: list #25 @@ -37,13 +45,13 @@ root: struct #77 │ ├─ variant_2: struct #27 │ │ └─ [not]: integer #23 │ ├─ variant_3: struct #28 - │ │ ├─ [lt]: optional #24 - │ │ │ └─ item: integer #23 │ │ ├─ [gt]: optional #24 │ │ │ └─ item: integer #23 - │ │ ├─ [lte]: optional #24 + │ │ ├─ [gte]: optional #24 │ │ │ └─ item: integer #23 - │ │ └─ [gte]: optional #24 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 │ │ └─ item: integer #23 │ ├─ variant_4: struct #29 │ │ └─ [in]: list #25 @@ -73,9 +81,9 @@ root: struct #77 │ │ ├─ variant_6: struct #15 │ │ │ └─ [search]: string #5 │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 + │ │ ├─ [endsWith]: optional #6 │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 + │ │ └─ [startsWith]: optional #6 │ │ └─ item: string #5 │ └─ variant_1: struct #18 │ └─ [not]: union '_string_filter' #17 @@ -97,321 +105,313 @@ root: struct #77 │ ├─ variant_6: struct #15 │ │ └─ [search]: string #5 │ └─ variant_7: struct #16 - │ ├─ [startsWith]: optional #6 + │ ├─ [endsWith]: optional #6 │ │ └─ item: string #5 - │ └─ [endsWith]: optional #6 + │ └─ [startsWith]: optional #6 │ └─ item: string #5 - ├─ [posts]: optional #69 - │ └─ item: union #68 - │ ├─ variant_0: struct #63 - │ │ └─ [every]: optional '_62_PostWhere__skip_50_UserWhere?' #62 - │ │ └─ item: struct 'PostWhere__skip_50_UserWhere' #61 - │ │ ├─ [id]: optional '_57__integer_filter_c?' #57 - │ │ │ └─ item: optional '_integer_filter_c' #34 - │ │ │ └─ item: union #33 - │ │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_1: struct #32 - │ │ │ └─ [not]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ [title]: optional '_58__string_filter_c?' #58 - │ │ │ └─ item: optional '_string_filter_c' #20 - │ │ │ └─ item: union #19 - │ │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ │ ├─ variant_0: string #5 - │ │ │ │ ├─ variant_1: struct #8 - │ │ │ │ │ └─ [equals]: string #5 - │ │ │ │ ├─ variant_2: struct #9 - │ │ │ │ │ └─ [not]: string #5 - │ │ │ │ ├─ variant_3: struct #10 - │ │ │ │ │ └─ [in]: list #7 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ ├─ variant_4: struct #11 - │ │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ ├─ variant_5: struct #14 - │ │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #15 - │ │ │ │ │ └─ [search]: string #5 - │ │ │ │ └─ variant_7: struct #16 - │ │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ └─ [endsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ variant_1: struct #18 - │ │ │ └─ [not]: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [author]: optional '_60_UserWhere?' #60 - │ │ └─ item: &UserWhere #59 - │ ├─ variant_1: struct #65 - │ │ └─ [some]: optional '_64_PostWhere__skip_50_UserWhere?' #64 - │ │ └─ item: struct 'PostWhere__skip_50_UserWhere' #61 - │ │ ├─ [id]: optional '_57__integer_filter_c?' #57 - │ │ │ └─ item: optional '_integer_filter_c' #34 - │ │ │ └─ item: union #33 - │ │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_1: struct #32 - │ │ │ └─ [not]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ [title]: optional '_58__string_filter_c?' #58 - │ │ │ └─ item: optional '_string_filter_c' #20 - │ │ │ └─ item: union #19 - │ │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ │ ├─ variant_0: string #5 - │ │ │ │ ├─ variant_1: struct #8 - │ │ │ │ │ └─ [equals]: string #5 - │ │ │ │ ├─ variant_2: struct #9 - │ │ │ │ │ └─ [not]: string #5 - │ │ │ │ ├─ variant_3: struct #10 - │ │ │ │ │ └─ [in]: list #7 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ ├─ variant_4: struct #11 - │ │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ ├─ variant_5: struct #14 - │ │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #15 - │ │ │ │ │ └─ [search]: string #5 - │ │ │ │ └─ variant_7: struct #16 - │ │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ └─ [endsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ variant_1: struct #18 - │ │ │ └─ [not]: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [author]: optional '_60_UserWhere?' #60 - │ │ └─ item: &UserWhere #59 - │ └─ variant_2: struct #67 - │ └─ [none]: optional '_66_PostWhere__skip_50_UserWhere?' #66 - │ └─ item: struct 'PostWhere__skip_50_UserWhere' #61 - │ ├─ [id]: optional '_57__integer_filter_c?' #57 - │ │ └─ item: optional '_integer_filter_c' #34 - │ │ └─ item: union #33 - │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_1: struct #32 - │ │ └─ [not]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ ├─ [title]: optional '_58__string_filter_c?' #58 - │ │ └─ item: optional '_string_filter_c' #20 - │ │ └─ item: union #19 - │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ variant_1: struct #18 - │ │ └─ [not]: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [author]: optional '_60_UserWhere?' #60 - │ └─ item: &UserWhere #59 - ├─ [AND]: optional '_73__72_QueryUserWhereUniqueInput[]?' #73 - │ └─ item: list '_72_QueryUserWhereUniqueInput[]' #72 - │ └─ item: &QueryUserWhereUniqueInput #71 - ├─ [OR]: optional '_73__72_QueryUserWhereUniqueInput[]?' #73 - │ └─ item: list '_72_QueryUserWhereUniqueInput[]' #72 - │ └─ item: &QueryUserWhereUniqueInput #71 - └─ [NOT]: optional '_74_QueryUserWhereUniqueInput?' #74 - └─ item: &QueryUserWhereUniqueInput #71 + └─ [posts]: optional #69 + └─ item: union #68 + ├─ variant_0: struct #63 + │ └─ [every]: optional '_62_PostWhere__skip_50_UserWhere?' #62 + │ └─ item: struct 'PostWhere__skip_50_UserWhere' #61 + │ ├─ [author]: optional '_60_UserWhere?' #60 + │ │ └─ item: &UserWhere #59 + │ ├─ [id]: optional '_57__integer_filter_c?' #57 + │ │ └─ item: optional '_integer_filter_c' #34 + │ │ └─ item: union #33 + │ │ ├─ variant_0: either '_integer_filter' #31 + │ │ │ ├─ variant_0: integer #23 + │ │ │ ├─ variant_1: struct #26 + │ │ │ │ └─ [equals]: integer #23 + │ │ │ ├─ variant_2: struct #27 + │ │ │ │ └─ [not]: integer #23 + │ │ │ ├─ variant_3: struct #28 + │ │ │ │ ├─ [gt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [gte]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [lt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ └─ [lte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ variant_4: struct #29 + │ │ │ │ └─ [in]: list #25 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ variant_5: struct #30 + │ │ │ └─ [notIn]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_1: struct #32 + │ │ └─ [not]: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ [title]: optional '_58__string_filter_c?' #58 + │ └─ item: optional '_string_filter_c' #20 + │ └─ item: union #19 + │ ├─ variant_0: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ variant_1: struct #18 + │ └─ [not]: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + ├─ variant_1: struct #65 + │ └─ [some]: optional '_64_PostWhere__skip_50_UserWhere?' #64 + │ └─ item: struct 'PostWhere__skip_50_UserWhere' #61 + │ ├─ [author]: optional '_60_UserWhere?' #60 + │ │ └─ item: &UserWhere #59 + │ ├─ [id]: optional '_57__integer_filter_c?' #57 + │ │ └─ item: optional '_integer_filter_c' #34 + │ │ └─ item: union #33 + │ │ ├─ variant_0: either '_integer_filter' #31 + │ │ │ ├─ variant_0: integer #23 + │ │ │ ├─ variant_1: struct #26 + │ │ │ │ └─ [equals]: integer #23 + │ │ │ ├─ variant_2: struct #27 + │ │ │ │ └─ [not]: integer #23 + │ │ │ ├─ variant_3: struct #28 + │ │ │ │ ├─ [gt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [gte]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [lt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ └─ [lte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ variant_4: struct #29 + │ │ │ │ └─ [in]: list #25 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ variant_5: struct #30 + │ │ │ └─ [notIn]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_1: struct #32 + │ │ └─ [not]: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ [title]: optional '_58__string_filter_c?' #58 + │ └─ item: optional '_string_filter_c' #20 + │ └─ item: union #19 + │ ├─ variant_0: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ variant_1: struct #18 + │ └─ [not]: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_2: struct #67 + └─ [none]: optional '_66_PostWhere__skip_50_UserWhere?' #66 + └─ item: struct 'PostWhere__skip_50_UserWhere' #61 + ├─ [author]: optional '_60_UserWhere?' #60 + │ └─ item: &UserWhere #59 + ├─ [id]: optional '_57__integer_filter_c?' #57 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 + └─ [title]: optional '_58__string_filter_c?' #58 + └─ item: optional '_string_filter_c' #20 + └─ item: union #19 + ├─ variant_0: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_1: struct #18 + └─ [not]: union '_string_filter' #17 + ├─ variant_0: string #5 + ├─ variant_1: struct #8 + │ └─ [equals]: string #5 + ├─ variant_2: struct #9 + │ └─ [not]: string #5 + ├─ variant_3: struct #10 + │ └─ [in]: list #7 + │ └─ item: string #5 + ├─ variant_4: struct #11 + │ └─ [notIn]: list #7 + │ └─ item: string #5 + ├─ variant_5: struct #14 + │ ├─ [contains]: string #5 + │ └─ [mode]: optional #13 + │ └─ item: string #12 enum{ '"insensitive"' } + ├─ variant_6: struct #15 + │ └─ [search]: string #5 + └─ variant_7: struct #16 + ├─ [endsWith]: optional #6 + │ └─ item: string #5 + └─ [startsWith]: optional #6 + └─ item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique User out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique User out.snap index bf1a8e4ce..f39704f21 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique User out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__find_unique User out.snap @@ -1,16 +1,16 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: optional '_84_UserWithNestedCount?' #84 └─ item: struct 'UserWithNestedCount' #83 + ├─ [_count]: struct #82 + │ └─ [posts]: optional '_Count' #81 + │ └─ item: integer #80 ├─ [id]: integer #46 ├─ [name]: string #47 - ├─ [posts]: list '_79_PostWithNestedCount_excluding___rel_Post_User_1[]' #79 - │ └─ item: struct 'PostWithNestedCount_excluding___rel_Post_User_1' #78 - │ ├─ [id]: integer #51 - │ └─ [title]: string #52 - └─ [_count]: struct #82 - └─ [posts]: optional '_Count' #81 - └─ item: integer #80 + └─ [posts]: list '_79_PostWithNestedCount_excluding___rel_Post_User_1[]' #79 + └─ item: struct 'PostWithNestedCount_excluding___rel_Post_User_1' #78 + ├─ [id]: integer #51 + └─ [title]: string #52 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Post inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Post inp.snap index e54e49cf3..596d7b5eb 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Post inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Post inp.snap @@ -1,251 +1,704 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct '_Post_QueryInput_group_by' #266 -├─ [where]: optional '_222_QueryPostWhereInput?' #222 -│ └─ item: struct 'QueryPostWhereInput' #221 -│ ├─ [id]: optional '_201__integer_filter_c?' #201 -│ │ └─ item: optional '_integer_filter_c' #34 -│ │ └─ item: union #33 -│ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ ├─ variant_0: integer #23 -│ │ │ ├─ variant_1: struct #26 -│ │ │ │ └─ [equals]: integer #23 -│ │ │ ├─ variant_2: struct #27 -│ │ │ │ └─ [not]: integer #23 -│ │ │ ├─ variant_3: struct #28 -│ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ [gte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ variant_4: struct #29 -│ │ │ │ └─ [in]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_5: struct #30 -│ │ │ └─ [notIn]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_1: struct #32 -│ │ └─ [not]: either '_integer_filter' #31 -│ │ ├─ variant_0: integer #23 -│ │ ├─ variant_1: struct #26 -│ │ │ └─ [equals]: integer #23 -│ │ ├─ variant_2: struct #27 -│ │ │ └─ [not]: integer #23 -│ │ ├─ variant_3: struct #28 -│ │ │ ├─ [lt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [gt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [lte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ [gte]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ variant_4: struct #29 -│ │ │ └─ [in]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_5: struct #30 -│ │ └─ [notIn]: list #25 -│ │ └─ item: integer #23 -│ ├─ [title]: optional '_202__string_filter_c?' #202 -│ │ └─ item: optional '_string_filter_c' #20 -│ │ └─ item: union #19 -│ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ variant_1: struct #18 -│ │ └─ [not]: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ ├─ [author]: optional '_215_UserWhere__skip_122_PostWhere?' #215 -│ │ └─ item: struct 'UserWhere__skip_122_PostWhere' #214 -│ │ ├─ [id]: optional '_203__integer_filter_c?' #203 -│ │ │ └─ item: optional '_integer_filter_c' #34 -│ │ │ └─ item: union #33 -│ │ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_5: struct #30 -│ │ │ │ └─ [notIn]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_1: struct #32 -│ │ │ └─ [not]: either '_integer_filter' #31 -│ │ │ ├─ variant_0: integer #23 -│ │ │ ├─ variant_1: struct #26 -│ │ │ │ └─ [equals]: integer #23 -│ │ │ ├─ variant_2: struct #27 -│ │ │ │ └─ [not]: integer #23 -│ │ │ ├─ variant_3: struct #28 -│ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ [gte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ variant_4: struct #29 -│ │ │ │ └─ [in]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_5: struct #30 -│ │ │ └─ [notIn]: list #25 -│ │ │ └─ item: integer #23 -│ │ ├─ [name]: optional '_204__string_filter_c?' #204 -│ │ │ └─ item: optional '_string_filter_c' #20 -│ │ │ └─ item: union #19 -│ │ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ │ ├─ variant_0: string #5 -│ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ └─ [not]: string #5 -│ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ └─ [search]: string #5 -│ │ │ │ └─ variant_7: struct #16 -│ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ variant_1: struct #18 -│ │ │ └─ [not]: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [posts]: optional #213 -│ │ └─ item: union #212 -│ │ ├─ variant_0: struct #207 -│ │ │ └─ [every]: optional '_206_PostWhere?' #206 -│ │ │ └─ item: &PostWhere #205 -│ │ ├─ variant_1: struct #209 -│ │ │ └─ [some]: optional '_208_PostWhere?' #208 -│ │ │ └─ item: &PostWhere #205 -│ │ └─ variant_2: struct #211 -│ │ └─ [none]: optional '_210_PostWhere?' #210 -│ │ └─ item: &PostWhere #205 -│ ├─ [AND]: optional '_219__218_QueryPostWhereInput[]?' #219 -│ │ └─ item: list '_218_QueryPostWhereInput[]' #218 -│ │ └─ item: &QueryPostWhereInput #217 -│ ├─ [OR]: optional '_219__218_QueryPostWhereInput[]?' #219 -│ │ └─ item: list '_218_QueryPostWhereInput[]' #218 -│ │ └─ item: &QueryPostWhereInput #217 -│ └─ [NOT]: optional '_220_QueryPostWhereInput?' #220 -│ └─ item: &QueryPostWhereInput #217 +├─ [by]: list '_Post_GroupingFields' #241 +│ └─ item: string #240 enum{ '"id"', '"title"' } +├─ [cursor]: optional '_239__Post_Cursor?' #239 +│ └─ item: union '_Post_Cursor' #238 +│ ├─ variant_0: struct #236 +│ │ └─ [id]: integer #119 +│ └─ variant_1: struct #237 +│ └─ [title]: string #120 +├─ [having]: optional '_265__Post_Having?' #265 +│ └─ item: union '_Post_Having' #264 +│ ├─ variant_0: struct 'PostWhere__agg' #257 +│ │ ├─ [author]: optional '_256_UserWhere__agg__skip_122_PostWhere__agg?' #256 +│ │ │ └─ item: struct 'UserWhere__agg__skip_122_PostWhere__agg' #255 +│ │ │ ├─ [id]: optional '_244__integer_filter_with_aggregates_c?' #244 +│ │ │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 +│ │ │ │ └─ item: union #88 +│ │ │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_1: struct #81 +│ │ │ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_2: struct #82 +│ │ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_3: struct #83 +│ │ │ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ │ │ ├─ variant_0: float #72 +│ │ │ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ │ │ └─ [not]: float #72 +│ │ │ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ └─ variant_5: struct #79 +│ │ │ │ │ │ └─ [notIn]: list #74 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ variant_4: struct #84 +│ │ │ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #85 +│ │ │ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_1: struct #87 +│ │ │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 +│ │ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_1: struct #81 +│ │ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_2: struct #82 +│ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_3: struct #83 +│ │ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ │ ├─ variant_0: float #72 +│ │ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ │ └─ [not]: float #72 +│ │ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ variant_5: struct #79 +│ │ │ │ │ └─ [notIn]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #84 +│ │ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #85 +│ │ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ [name]: optional '_245__string_filter_c?' #245 +│ │ │ │ └─ item: optional '_string_filter_c' #20 +│ │ │ │ └─ item: union #19 +│ │ │ │ ├─ variant_0: union '_string_filter' #17 +│ │ │ │ │ ├─ variant_0: string #5 +│ │ │ │ │ ├─ variant_1: struct #8 +│ │ │ │ │ │ └─ [equals]: string #5 +│ │ │ │ │ ├─ variant_2: struct #9 +│ │ │ │ │ │ └─ [not]: string #5 +│ │ │ │ │ ├─ variant_3: struct #10 +│ │ │ │ │ │ └─ [in]: list #7 +│ │ │ │ │ │ └─ item: string #5 +│ │ │ │ │ ├─ variant_4: struct #11 +│ │ │ │ │ │ └─ [notIn]: list #7 +│ │ │ │ │ │ └─ item: string #5 +│ │ │ │ │ ├─ variant_5: struct #14 +│ │ │ │ │ │ ├─ [contains]: string #5 +│ │ │ │ │ │ └─ [mode]: optional #13 +│ │ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #15 +│ │ │ │ │ │ └─ [search]: string #5 +│ │ │ │ │ └─ variant_7: struct #16 +│ │ │ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ │ │ └─ item: string #5 +│ │ │ │ │ └─ [startsWith]: optional #6 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ └─ variant_1: struct #18 +│ │ │ │ └─ [not]: union '_string_filter' #17 +│ │ │ │ ├─ variant_0: string #5 +│ │ │ │ ├─ variant_1: struct #8 +│ │ │ │ │ └─ [equals]: string #5 +│ │ │ │ ├─ variant_2: struct #9 +│ │ │ │ │ └─ [not]: string #5 +│ │ │ │ ├─ variant_3: struct #10 +│ │ │ │ │ └─ [in]: list #7 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ ├─ variant_4: struct #11 +│ │ │ │ │ └─ [notIn]: list #7 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ ├─ variant_5: struct #14 +│ │ │ │ │ ├─ [contains]: string #5 +│ │ │ │ │ └─ [mode]: optional #13 +│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #15 +│ │ │ │ │ └─ [search]: string #5 +│ │ │ │ └─ variant_7: struct #16 +│ │ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ └─ [startsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ [posts]: optional #254 +│ │ │ └─ item: union #253 +│ │ │ ├─ variant_0: struct #248 +│ │ │ │ └─ [every]: optional '_247_PostWhere__agg?' #247 +│ │ │ │ └─ item: &PostWhere__agg #246 +│ │ │ ├─ variant_1: struct #250 +│ │ │ │ └─ [some]: optional '_249_PostWhere__agg?' #249 +│ │ │ │ └─ item: &PostWhere__agg #246 +│ │ │ └─ variant_2: struct #252 +│ │ │ └─ [none]: optional '_251_PostWhere__agg?' #251 +│ │ │ └─ item: &PostWhere__agg #246 +│ │ ├─ [id]: optional '_242__integer_filter_with_aggregates_c?' #242 +│ │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 +│ │ │ └─ item: union #88 +│ │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 +│ │ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_1: struct #81 +│ │ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_2: struct #82 +│ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_3: struct #83 +│ │ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ │ ├─ variant_0: float #72 +│ │ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ │ └─ [not]: float #72 +│ │ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ variant_5: struct #79 +│ │ │ │ │ └─ [notIn]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #84 +│ │ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #85 +│ │ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_1: struct #87 +│ │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 +│ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_1: struct #81 +│ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_2: struct #82 +│ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_3: struct #83 +│ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ ├─ variant_0: float #72 +│ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ └─ [not]: float #72 +│ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ └─ variant_5: struct #79 +│ │ │ │ └─ [notIn]: list #74 +│ │ │ │ └─ item: float #72 +│ │ │ ├─ variant_4: struct #84 +│ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_5: struct #85 +│ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ ├─ variant_0: integer #23 +│ │ │ ├─ variant_1: struct #26 +│ │ │ │ └─ [equals]: integer #23 +│ │ │ ├─ variant_2: struct #27 +│ │ │ │ └─ [not]: integer #23 +│ │ │ ├─ variant_3: struct #28 +│ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ [lte]: optional #24 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_4: struct #29 +│ │ │ │ └─ [in]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_5: struct #30 +│ │ │ └─ [notIn]: list #25 +│ │ │ └─ item: integer #23 +│ │ └─ [title]: optional '_243__string_filter_c?' #243 +│ │ └─ item: optional '_string_filter_c' #20 +│ │ └─ item: union #19 +│ │ ├─ variant_0: union '_string_filter' #17 +│ │ │ ├─ variant_0: string #5 +│ │ │ ├─ variant_1: struct #8 +│ │ │ │ └─ [equals]: string #5 +│ │ │ ├─ variant_2: struct #9 +│ │ │ │ └─ [not]: string #5 +│ │ │ ├─ variant_3: struct #10 +│ │ │ │ └─ [in]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_4: struct #11 +│ │ │ │ └─ [notIn]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_5: struct #14 +│ │ │ │ ├─ [contains]: string #5 +│ │ │ │ └─ [mode]: optional #13 +│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #15 +│ │ │ │ └─ [search]: string #5 +│ │ │ └─ variant_7: struct #16 +│ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ [startsWith]: optional #6 +│ │ │ └─ item: string #5 +│ │ └─ variant_1: struct #18 +│ │ └─ [not]: union '_string_filter' #17 +│ │ ├─ variant_0: string #5 +│ │ ├─ variant_1: struct #8 +│ │ │ └─ [equals]: string #5 +│ │ ├─ variant_2: struct #9 +│ │ │ └─ [not]: string #5 +│ │ ├─ variant_3: struct #10 +│ │ │ └─ [in]: list #7 +│ │ │ └─ item: string #5 +│ │ ├─ variant_4: struct #11 +│ │ │ └─ [notIn]: list #7 +│ │ │ └─ item: string #5 +│ │ ├─ variant_5: struct #14 +│ │ │ ├─ [contains]: string #5 +│ │ │ └─ [mode]: optional #13 +│ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #15 +│ │ │ └─ [search]: string #5 +│ │ └─ variant_7: struct #16 +│ │ ├─ [endsWith]: optional #6 +│ │ │ └─ item: string #5 +│ │ └─ [startsWith]: optional #6 +│ │ └─ item: string #5 +│ ├─ variant_1: struct #260 +│ │ └─ [AND]: list '_259__Post_Having[]' #259 +│ │ └─ item: &_Post_Having #258 +│ ├─ variant_2: struct #262 +│ │ └─ [OR]: list '_261__Post_Having[]' #261 +│ │ └─ item: &_Post_Having #258 +│ └─ variant_3: struct #263 +│ └─ [NOT]: &_Post_Having #258 ├─ [orderBy]: optional '_233__Post_OrderBy_with_aggregates?' #233 │ └─ item: list '_Post_OrderBy_with_aggregates' #232 │ └─ item: struct #231 +│ ├─ [_avg]: optional #226 +│ │ └─ item: struct #225 +│ │ └─ [id]: optional '_Sort' #47 +│ │ └─ item: union #46 +│ │ ├─ variant_0: struct #45 +│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ ├─ [_count]: optional #224 │ │ └─ item: struct #223 -│ │ ├─ [id]: optional '_Sort' #47 +│ │ ├─ [author]: optional '_Sort' #47 │ │ │ └─ item: union #46 │ │ │ ├─ variant_0: struct #45 │ │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ ├─ [title]: optional '_Sort' #47 +│ │ ├─ [id]: optional '_Sort' #47 │ │ │ └─ item: union #46 │ │ │ ├─ variant_0: struct #45 │ │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ └─ [author]: optional '_Sort' #47 -│ │ └─ item: union #46 -│ │ ├─ variant_0: struct #45 -│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_avg]: optional #226 -│ │ └─ item: struct #225 -│ │ └─ [id]: optional '_Sort' #47 +│ │ └─ [title]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_sum]: optional #226 +│ ├─ [_max]: optional #226 │ │ └─ item: struct #225 │ │ └─ [id]: optional '_Sort' #47 │ │ └─ item: union #46 @@ -259,706 +712,253 @@ root: struct '_Post_QueryInput_group_by' #266 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_max]: optional #226 +│ ├─ [_sum]: optional #226 │ │ └─ item: struct #225 │ │ └─ [id]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ ├─ [author]: optional '_230__User_OrderBy_excluding___rel_Post_User_1?' #230 +│ │ └─ item: list '_User_OrderBy_excluding___rel_Post_User_1' #229 +│ │ └─ item: struct #228 +│ │ ├─ [id]: optional '_Sort' #47 +│ │ │ └─ item: union #46 +│ │ │ ├─ variant_0: struct #45 +│ │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ │ └─ [name]: optional '_Sort' #47 +│ │ └─ item: union #46 +│ │ ├─ variant_0: struct #45 +│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ ├─ [id]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [title]: optional '_Sort' #47 -│ │ └─ item: union #46 -│ │ ├─ variant_0: struct #45 -│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └─ [author]: optional '_230__User_OrderBy_excluding___rel_Post_User_1?' #230 -│ └─ item: list '_User_OrderBy_excluding___rel_Post_User_1' #229 -│ └─ item: struct #228 -│ ├─ [id]: optional '_Sort' #47 -│ │ └─ item: union #46 -│ │ ├─ variant_0: struct #45 -│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └─ [name]: optional '_Sort' #47 -│ └─ item: union #46 -│ ├─ variant_0: struct #45 -│ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -├─ [take]: optional '_234__Take?' #234 -│ └─ item: integer '_Take' #59 +│ └─ [title]: optional '_Sort' #47 +│ └─ item: union #46 +│ ├─ variant_0: struct #45 +│ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } ├─ [skip]: optional '_235__Skip?' #235 │ └─ item: integer '_Skip' #61 -├─ [cursor]: optional '_239__Post_Cursor?' #239 -│ └─ item: union '_Post_Cursor' #238 -│ ├─ variant_0: struct #236 -│ │ └─ [id]: integer #119 -│ └─ variant_1: struct #237 -│ └─ [title]: string #120 -├─ [by]: list '_Post_GroupingFields' #241 -│ └─ item: string #240 enum{ '"id"', '"title"' } -└─ [having]: optional '_265__Post_Having?' #265 - └─ item: union '_Post_Having' #264 - ├─ variant_0: struct 'PostWhere__agg' #257 - │ ├─ [id]: optional '_242__integer_filter_with_aggregates_c?' #242 - │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 - │ │ └─ item: union #88 - │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 - │ │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_1: struct #81 - │ │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_2: struct #82 - │ │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_3: struct #83 - │ │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ │ ├─ variant_0: float #72 - │ │ │ │ ├─ variant_1: struct #75 - │ │ │ │ │ └─ [equals]: float #72 - │ │ │ │ ├─ variant_2: struct #76 - │ │ │ │ │ └─ [not]: float #72 - │ │ │ │ ├─ variant_3: struct #77 - │ │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ variant_4: struct #78 - │ │ │ │ │ └─ [in]: list #74 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ variant_5: struct #79 - │ │ │ │ └─ [notIn]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #84 - │ │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #85 - │ │ │ └─ [_max]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_1: struct #87 - │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 - │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_1: struct #81 - │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_2: struct #82 - │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_3: struct #83 - │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ ├─ variant_0: float #72 - │ │ │ ├─ variant_1: struct #75 - │ │ │ │ └─ [equals]: float #72 - │ │ │ ├─ variant_2: struct #76 - │ │ │ │ └─ [not]: float #72 - │ │ │ ├─ variant_3: struct #77 - │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #78 - │ │ │ │ └─ [in]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ └─ variant_5: struct #79 - │ │ │ └─ [notIn]: list #74 - │ │ │ └─ item: float #72 - │ │ ├─ variant_4: struct #84 - │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #85 - │ │ └─ [_max]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ ├─ [title]: optional '_243__string_filter_c?' #243 - │ │ └─ item: optional '_string_filter_c' #20 - │ │ └─ item: union #19 - │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ variant_1: struct #18 - │ │ └─ [not]: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [author]: optional '_256_UserWhere__agg__skip_122_PostWhere__agg?' #256 - │ └─ item: struct 'UserWhere__agg__skip_122_PostWhere__agg' #255 - │ ├─ [id]: optional '_244__integer_filter_with_aggregates_c?' #244 - │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 - │ │ └─ item: union #88 - │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 - │ │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_1: struct #81 - │ │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_2: struct #82 - │ │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_3: struct #83 - │ │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ │ ├─ variant_0: float #72 - │ │ │ │ ├─ variant_1: struct #75 - │ │ │ │ │ └─ [equals]: float #72 - │ │ │ │ ├─ variant_2: struct #76 - │ │ │ │ │ └─ [not]: float #72 - │ │ │ │ ├─ variant_3: struct #77 - │ │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ variant_4: struct #78 - │ │ │ │ │ └─ [in]: list #74 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ variant_5: struct #79 - │ │ │ │ └─ [notIn]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #84 - │ │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #85 - │ │ │ └─ [_max]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_1: struct #87 - │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 - │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_1: struct #81 - │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_2: struct #82 - │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_3: struct #83 - │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ ├─ variant_0: float #72 - │ │ │ ├─ variant_1: struct #75 - │ │ │ │ └─ [equals]: float #72 - │ │ │ ├─ variant_2: struct #76 - │ │ │ │ └─ [not]: float #72 - │ │ │ ├─ variant_3: struct #77 - │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #78 - │ │ │ │ └─ [in]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ └─ variant_5: struct #79 - │ │ │ └─ [notIn]: list #74 - │ │ │ └─ item: float #72 - │ │ ├─ variant_4: struct #84 - │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #85 - │ │ └─ [_max]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ ├─ [name]: optional '_245__string_filter_c?' #245 - │ │ └─ item: optional '_string_filter_c' #20 - │ │ └─ item: union #19 - │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ variant_1: struct #18 - │ │ └─ [not]: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [posts]: optional #254 - │ └─ item: union #253 - │ ├─ variant_0: struct #248 - │ │ └─ [every]: optional '_247_PostWhere__agg?' #247 - │ │ └─ item: &PostWhere__agg #246 - │ ├─ variant_1: struct #250 - │ │ └─ [some]: optional '_249_PostWhere__agg?' #249 - │ │ └─ item: &PostWhere__agg #246 - │ └─ variant_2: struct #252 - │ └─ [none]: optional '_251_PostWhere__agg?' #251 - │ └─ item: &PostWhere__agg #246 - ├─ variant_1: struct #260 - │ └─ [AND]: list '_259__Post_Having[]' #259 - │ └─ item: &_Post_Having #258 - ├─ variant_2: struct #262 - │ └─ [OR]: list '_261__Post_Having[]' #261 - │ └─ item: &_Post_Having #258 - └─ variant_3: struct #263 - └─ [NOT]: &_Post_Having #258 +├─ [take]: optional '_234__Take?' #234 +│ └─ item: integer '_Take' #59 +└─ [where]: optional '_222_QueryPostWhereInput?' #222 + └─ item: struct 'QueryPostWhereInput' #221 + ├─ [AND]: optional '_219__218_QueryPostWhereInput[]?' #219 + │ └─ item: list '_218_QueryPostWhereInput[]' #218 + │ └─ item: &QueryPostWhereInput #217 + ├─ [NOT]: optional '_220_QueryPostWhereInput?' #220 + │ └─ item: &QueryPostWhereInput #217 + ├─ [OR]: optional '_219__218_QueryPostWhereInput[]?' #219 + │ └─ item: list '_218_QueryPostWhereInput[]' #218 + │ └─ item: &QueryPostWhereInput #217 + ├─ [author]: optional '_215_UserWhere__skip_122_PostWhere?' #215 + │ └─ item: struct 'UserWhere__skip_122_PostWhere' #214 + │ ├─ [id]: optional '_203__integer_filter_c?' #203 + │ │ └─ item: optional '_integer_filter_c' #34 + │ │ └─ item: union #33 + │ │ ├─ variant_0: either '_integer_filter' #31 + │ │ │ ├─ variant_0: integer #23 + │ │ │ ├─ variant_1: struct #26 + │ │ │ │ └─ [equals]: integer #23 + │ │ │ ├─ variant_2: struct #27 + │ │ │ │ └─ [not]: integer #23 + │ │ │ ├─ variant_3: struct #28 + │ │ │ │ ├─ [gt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [gte]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [lt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ └─ [lte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ variant_4: struct #29 + │ │ │ │ └─ [in]: list #25 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ variant_5: struct #30 + │ │ │ └─ [notIn]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_1: struct #32 + │ │ └─ [not]: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ ├─ [name]: optional '_204__string_filter_c?' #204 + │ │ └─ item: optional '_string_filter_c' #20 + │ │ └─ item: union #19 + │ │ ├─ variant_0: union '_string_filter' #17 + │ │ │ ├─ variant_0: string #5 + │ │ │ ├─ variant_1: struct #8 + │ │ │ │ └─ [equals]: string #5 + │ │ │ ├─ variant_2: struct #9 + │ │ │ │ └─ [not]: string #5 + │ │ │ ├─ variant_3: struct #10 + │ │ │ │ └─ [in]: list #7 + │ │ │ │ └─ item: string #5 + │ │ │ ├─ variant_4: struct #11 + │ │ │ │ └─ [notIn]: list #7 + │ │ │ │ └─ item: string #5 + │ │ │ ├─ variant_5: struct #14 + │ │ │ │ ├─ [contains]: string #5 + │ │ │ │ └─ [mode]: optional #13 + │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ │ ├─ variant_6: struct #15 + │ │ │ │ └─ [search]: string #5 + │ │ │ └─ variant_7: struct #16 + │ │ │ ├─ [endsWith]: optional #6 + │ │ │ │ └─ item: string #5 + │ │ │ └─ [startsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ variant_1: struct #18 + │ │ └─ [not]: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [posts]: optional #213 + │ └─ item: union #212 + │ ├─ variant_0: struct #207 + │ │ └─ [every]: optional '_206_PostWhere?' #206 + │ │ └─ item: &PostWhere #205 + │ ├─ variant_1: struct #209 + │ │ └─ [some]: optional '_208_PostWhere?' #208 + │ │ └─ item: &PostWhere #205 + │ └─ variant_2: struct #211 + │ └─ [none]: optional '_210_PostWhere?' #210 + │ └─ item: &PostWhere #205 + ├─ [id]: optional '_201__integer_filter_c?' #201 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 + └─ [title]: optional '_202__string_filter_c?' #202 + └─ item: optional '_string_filter_c' #20 + └─ item: union #19 + ├─ variant_0: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_1: struct #18 + └─ [not]: union '_string_filter' #17 + ├─ variant_0: string #5 + ├─ variant_1: struct #8 + │ └─ [equals]: string #5 + ├─ variant_2: struct #9 + │ └─ [not]: string #5 + ├─ variant_3: struct #10 + │ └─ [in]: list #7 + │ └─ item: string #5 + ├─ variant_4: struct #11 + │ └─ [notIn]: list #7 + │ └─ item: string #5 + ├─ variant_5: struct #14 + │ ├─ [contains]: string #5 + │ └─ [mode]: optional #13 + │ └─ item: string #12 enum{ '"insensitive"' } + ├─ variant_6: struct #15 + │ └─ [search]: string #5 + └─ variant_7: struct #16 + ├─ [endsWith]: optional #6 + │ └─ item: string #5 + └─ [startsWith]: optional #6 + └─ item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Post out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Post out.snap index 8636ba139..71e42788c 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Post out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Post out.snap @@ -1,31 +1,31 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: list '_Post_GroupByResult' #279 └─ item: struct #278 - ├─ [id]: integer #119 - ├─ [title]: string #120 - ├─ [author]: &User #121 + ├─ [_avg]: struct '_Post_SelectNumbers__1' #272 + │ └─ [id]: optional #271 + │ └─ item: float #270 ├─ [_count]: struct '_Post_AggrCount' #269 │ ├─ [_all]: optional #268 │ │ └─ item: integer #267 - │ ├─ [id]: optional #268 + │ ├─ [author]: optional #268 │ │ └─ item: integer #267 - │ ├─ [title]: optional #268 + │ ├─ [id]: optional #268 │ │ └─ item: integer #267 - │ └─ [author]: optional #268 + │ └─ [title]: optional #268 │ └─ item: integer #267 - ├─ [_avg]: struct '_Post_SelectNumbers__1' #272 - │ └─ [id]: optional #271 - │ └─ item: float #270 - ├─ [_sum]: struct '_Post_SelectNumbers_' #277 + ├─ [_max]: struct '_Post_SelectNumbers_' #277 │ └─ [id]: optional #276 │ └─ item: integer #275 ├─ [_min]: struct '_Post_SelectNumbers_' #277 │ └─ [id]: optional #276 │ └─ item: integer #275 - └─ [_max]: struct '_Post_SelectNumbers_' #277 - └─ [id]: optional #276 - └─ item: integer #275 + ├─ [_sum]: struct '_Post_SelectNumbers_' #277 + │ └─ [id]: optional #276 + │ └─ item: integer #275 + ├─ [author]: &User #121 + ├─ [id]: integer #119 + └─ [title]: string #120 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Record inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Record inp.snap index a1c3a2b2f..916314996 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Record inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Record inp.snap @@ -1,624 +1,624 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct '_Record_QueryInput_group_by' #100 -├─ [where]: optional '_42_QueryRecordWhereInput?' #42 -│ └─ item: struct 'QueryRecordWhereInput' #41 -│ ├─ [id]: optional '_21__string_filter_c?' #21 -│ │ └─ item: optional '_string_filter_c' #20 -│ │ └─ item: union #19 -│ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ variant_1: struct #18 -│ │ └─ [not]: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ ├─ [name]: optional '_22__string_filter_c?' #22 -│ │ └─ item: optional '_string_filter_c' #20 -│ │ └─ item: union #19 -│ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ variant_1: struct #18 -│ │ └─ [not]: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ ├─ [age]: optional '_35__integer_filter_c?' #35 -│ │ └─ item: optional '_integer_filter_c' #34 -│ │ └─ item: union #33 -│ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ ├─ variant_0: integer #23 -│ │ │ ├─ variant_1: struct #26 -│ │ │ │ └─ [equals]: integer #23 -│ │ │ ├─ variant_2: struct #27 -│ │ │ │ └─ [not]: integer #23 -│ │ │ ├─ variant_3: struct #28 -│ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ [gte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ variant_4: struct #29 -│ │ │ │ └─ [in]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_5: struct #30 -│ │ │ └─ [notIn]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_1: struct #32 -│ │ └─ [not]: either '_integer_filter' #31 -│ │ ├─ variant_0: integer #23 -│ │ ├─ variant_1: struct #26 -│ │ │ └─ [equals]: integer #23 -│ │ ├─ variant_2: struct #27 -│ │ │ └─ [not]: integer #23 -│ │ ├─ variant_3: struct #28 -│ │ │ ├─ [lt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [gt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [lte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ [gte]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ variant_4: struct #29 -│ │ │ └─ [in]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_5: struct #30 -│ │ └─ [notIn]: list #25 -│ │ └─ item: integer #23 -│ ├─ [AND]: optional '_39__38_QueryRecordWhereInput[]?' #39 -│ │ └─ item: list '_38_QueryRecordWhereInput[]' #38 -│ │ └─ item: &QueryRecordWhereInput #37 -│ ├─ [OR]: optional '_39__38_QueryRecordWhereInput[]?' #39 -│ │ └─ item: list '_38_QueryRecordWhereInput[]' #38 -│ │ └─ item: &QueryRecordWhereInput #37 -│ └─ [NOT]: optional '_40_QueryRecordWhereInput?' #40 -│ └─ item: &QueryRecordWhereInput #37 +├─ [by]: list '_Record_GroupingFields' #69 +│ └─ item: string #68 enum{ '"id"', '"name"', '"age"' } +├─ [cursor]: optional '_67__Record_Cursor?' #67 +│ └─ item: union '_Record_Cursor' #66 +│ ├─ variant_0: struct #63 +│ │ └─ [id]: string #0 +│ ├─ variant_1: struct #64 +│ │ └─ [name]: string #1 +│ └─ variant_2: struct #65 +│ └─ [age]: integer #2 +├─ [having]: optional '_99__Record_Having?' #99 +│ └─ item: union '_Record_Having' #98 +│ ├─ variant_0: struct 'RecordWhere__agg' #91 +│ │ ├─ [age]: optional '_90__integer_filter_with_aggregates_c?' #90 +│ │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 +│ │ │ └─ item: union #88 +│ │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 +│ │ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_1: struct #81 +│ │ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_2: struct #82 +│ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_3: struct #83 +│ │ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ │ ├─ variant_0: float #72 +│ │ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ │ └─ [not]: float #72 +│ │ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ variant_5: struct #79 +│ │ │ │ │ └─ [notIn]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #84 +│ │ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #85 +│ │ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_1: struct #87 +│ │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 +│ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_1: struct #81 +│ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_2: struct #82 +│ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_3: struct #83 +│ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ ├─ variant_0: float #72 +│ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ └─ [not]: float #72 +│ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ └─ variant_5: struct #79 +│ │ │ │ └─ [notIn]: list #74 +│ │ │ │ └─ item: float #72 +│ │ │ ├─ variant_4: struct #84 +│ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_5: struct #85 +│ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ ├─ variant_0: integer #23 +│ │ │ ├─ variant_1: struct #26 +│ │ │ │ └─ [equals]: integer #23 +│ │ │ ├─ variant_2: struct #27 +│ │ │ │ └─ [not]: integer #23 +│ │ │ ├─ variant_3: struct #28 +│ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ [lte]: optional #24 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_4: struct #29 +│ │ │ │ └─ [in]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_5: struct #30 +│ │ │ └─ [notIn]: list #25 +│ │ │ └─ item: integer #23 +│ │ ├─ [id]: optional '_70__string_filter_c?' #70 +│ │ │ └─ item: optional '_string_filter_c' #20 +│ │ │ └─ item: union #19 +│ │ │ ├─ variant_0: union '_string_filter' #17 +│ │ │ │ ├─ variant_0: string #5 +│ │ │ │ ├─ variant_1: struct #8 +│ │ │ │ │ └─ [equals]: string #5 +│ │ │ │ ├─ variant_2: struct #9 +│ │ │ │ │ └─ [not]: string #5 +│ │ │ │ ├─ variant_3: struct #10 +│ │ │ │ │ └─ [in]: list #7 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ ├─ variant_4: struct #11 +│ │ │ │ │ └─ [notIn]: list #7 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ ├─ variant_5: struct #14 +│ │ │ │ │ ├─ [contains]: string #5 +│ │ │ │ │ └─ [mode]: optional #13 +│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #15 +│ │ │ │ │ └─ [search]: string #5 +│ │ │ │ └─ variant_7: struct #16 +│ │ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ └─ [startsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ variant_1: struct #18 +│ │ │ └─ [not]: union '_string_filter' #17 +│ │ │ ├─ variant_0: string #5 +│ │ │ ├─ variant_1: struct #8 +│ │ │ │ └─ [equals]: string #5 +│ │ │ ├─ variant_2: struct #9 +│ │ │ │ └─ [not]: string #5 +│ │ │ ├─ variant_3: struct #10 +│ │ │ │ └─ [in]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_4: struct #11 +│ │ │ │ └─ [notIn]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_5: struct #14 +│ │ │ │ ├─ [contains]: string #5 +│ │ │ │ └─ [mode]: optional #13 +│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #15 +│ │ │ │ └─ [search]: string #5 +│ │ │ └─ variant_7: struct #16 +│ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ [startsWith]: optional #6 +│ │ │ └─ item: string #5 +│ │ └─ [name]: optional '_71__string_filter_c?' #71 +│ │ └─ item: optional '_string_filter_c' #20 +│ │ └─ item: union #19 +│ │ ├─ variant_0: union '_string_filter' #17 +│ │ │ ├─ variant_0: string #5 +│ │ │ ├─ variant_1: struct #8 +│ │ │ │ └─ [equals]: string #5 +│ │ │ ├─ variant_2: struct #9 +│ │ │ │ └─ [not]: string #5 +│ │ │ ├─ variant_3: struct #10 +│ │ │ │ └─ [in]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_4: struct #11 +│ │ │ │ └─ [notIn]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_5: struct #14 +│ │ │ │ ├─ [contains]: string #5 +│ │ │ │ └─ [mode]: optional #13 +│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #15 +│ │ │ │ └─ [search]: string #5 +│ │ │ └─ variant_7: struct #16 +│ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ [startsWith]: optional #6 +│ │ │ └─ item: string #5 +│ │ └─ variant_1: struct #18 +│ │ └─ [not]: union '_string_filter' #17 +│ │ ├─ variant_0: string #5 +│ │ ├─ variant_1: struct #8 +│ │ │ └─ [equals]: string #5 +│ │ ├─ variant_2: struct #9 +│ │ │ └─ [not]: string #5 +│ │ ├─ variant_3: struct #10 +│ │ │ └─ [in]: list #7 +│ │ │ └─ item: string #5 +│ │ ├─ variant_4: struct #11 +│ │ │ └─ [notIn]: list #7 +│ │ │ └─ item: string #5 +│ │ ├─ variant_5: struct #14 +│ │ │ ├─ [contains]: string #5 +│ │ │ └─ [mode]: optional #13 +│ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #15 +│ │ │ └─ [search]: string #5 +│ │ └─ variant_7: struct #16 +│ │ ├─ [endsWith]: optional #6 +│ │ │ └─ item: string #5 +│ │ └─ [startsWith]: optional #6 +│ │ └─ item: string #5 +│ ├─ variant_1: struct #94 +│ │ └─ [AND]: list '_93__Record_Having[]' #93 +│ │ └─ item: &_Record_Having #92 +│ ├─ variant_2: struct #96 +│ │ └─ [OR]: list '_95__Record_Having[]' #95 +│ │ └─ item: &_Record_Having #92 +│ └─ variant_3: struct #97 +│ └─ [NOT]: &_Record_Having #92 ├─ [orderBy]: optional '_58__Record_OrderBy_with_aggregates?' #58 │ └─ item: list '_Record_OrderBy_with_aggregates' #57 │ └─ item: struct #56 +│ ├─ [_avg]: optional #54 +│ │ └─ item: struct #53 +│ │ └─ [age]: optional '_Sort_nullable' #50 +│ │ └─ item: union #49 +│ │ ├─ variant_0: struct #48 +│ │ │ ├─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } +│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ ├─ [_count]: optional #52 │ │ └─ item: struct #51 -│ │ ├─ [id]: optional '_Sort' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: struct #45 +│ │ ├─ [age]: optional '_Sort_nullable' #50 +│ │ │ └─ item: union #49 +│ │ │ ├─ variant_0: struct #48 +│ │ │ │ ├─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } │ │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ ├─ [name]: optional '_Sort' #47 +│ │ ├─ [id]: optional '_Sort' #47 │ │ │ └─ item: union #46 │ │ │ ├─ variant_0: struct #45 │ │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ └─ [age]: optional '_Sort_nullable' #50 -│ │ └─ item: union #49 -│ │ ├─ variant_0: struct #48 -│ │ │ ├─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ │ └─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } +│ │ └─ [name]: optional '_Sort' #47 +│ │ └─ item: union #46 +│ │ ├─ variant_0: struct #45 +│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_avg]: optional #54 -│ │ └─ item: struct #53 -│ │ └─ [age]: optional '_Sort_nullable' #50 -│ │ └─ item: union #49 -│ │ ├─ variant_0: struct #48 -│ │ │ ├─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ │ └─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } -│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_sum]: optional #54 +│ ├─ [_max]: optional #54 │ │ └─ item: struct #53 │ │ └─ [age]: optional '_Sort_nullable' #50 │ │ └─ item: union #49 │ │ ├─ variant_0: struct #48 -│ │ │ ├─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ │ └─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } +│ │ │ ├─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } +│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ ├─ [_min]: optional #54 │ │ └─ item: struct #53 │ │ └─ [age]: optional '_Sort_nullable' #50 │ │ └─ item: union #49 │ │ ├─ variant_0: struct #48 -│ │ │ ├─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ │ └─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } +│ │ │ ├─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } +│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_max]: optional #54 +│ ├─ [_sum]: optional #54 │ │ └─ item: struct #53 │ │ └─ [age]: optional '_Sort_nullable' #50 │ │ └─ item: union #49 │ │ ├─ variant_0: struct #48 -│ │ │ ├─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ │ └─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } +│ │ │ ├─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } +│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [id]: optional '_Sort' #47 -│ │ └─ item: union #46 -│ │ ├─ variant_0: struct #45 +│ ├─ [age]: optional '_Sort_nullable' #50 +│ │ └─ item: union #49 +│ │ ├─ variant_0: struct #48 +│ │ │ ├─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [name]: optional '_Sort' #47 +│ ├─ [id]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └─ [age]: optional '_Sort_nullable' #50 -│ └─ item: union #49 -│ ├─ variant_0: struct #48 -│ │ ├─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ └─ [nulls]: string '_NullsOrder' #44 enum{ '"first"', '"last"' } +│ └─ [name]: optional '_Sort' #47 +│ └─ item: union #46 +│ ├─ variant_0: struct #45 +│ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -├─ [take]: optional '_60__Take?' #60 -│ └─ item: integer '_Take' #59 ├─ [skip]: optional '_62__Skip?' #62 │ └─ item: integer '_Skip' #61 -├─ [cursor]: optional '_67__Record_Cursor?' #67 -│ └─ item: union '_Record_Cursor' #66 -│ ├─ variant_0: struct #63 -│ │ └─ [id]: string #0 -│ ├─ variant_1: struct #64 -│ │ └─ [name]: string #1 -│ └─ variant_2: struct #65 -│ └─ [age]: integer #2 -├─ [by]: list '_Record_GroupingFields' #69 -│ └─ item: string #68 enum{ '"id"', '"name"', '"age"' } -└─ [having]: optional '_99__Record_Having?' #99 - └─ item: union '_Record_Having' #98 - ├─ variant_0: struct 'RecordWhere__agg' #91 - │ ├─ [id]: optional '_70__string_filter_c?' #70 - │ │ └─ item: optional '_string_filter_c' #20 - │ │ └─ item: union #19 - │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ variant_1: struct #18 - │ │ └─ [not]: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ ├─ [name]: optional '_71__string_filter_c?' #71 - │ │ └─ item: optional '_string_filter_c' #20 - │ │ └─ item: union #19 - │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ variant_1: struct #18 - │ │ └─ [not]: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [age]: optional '_90__integer_filter_with_aggregates_c?' #90 - │ └─ item: optional '_integer_filter_with_aggregates_c' #89 - │ └─ item: union #88 - │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 - │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_1: struct #81 - │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_2: struct #82 - │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_3: struct #83 - │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ ├─ variant_0: float #72 - │ │ │ ├─ variant_1: struct #75 - │ │ │ │ └─ [equals]: float #72 - │ │ │ ├─ variant_2: struct #76 - │ │ │ │ └─ [not]: float #72 - │ │ │ ├─ variant_3: struct #77 - │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #78 - │ │ │ │ └─ [in]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ └─ variant_5: struct #79 - │ │ │ └─ [notIn]: list #74 - │ │ │ └─ item: float #72 - │ │ ├─ variant_4: struct #84 - │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #85 - │ │ └─ [_max]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_1: struct #87 - │ └─ [not]: union '_integer_filter_with_aggregates' #86 - │ ├─ variant_0: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ ├─ variant_1: struct #81 - │ │ └─ [_count]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ ├─ variant_2: struct #82 - │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ ├─ variant_3: struct #83 - │ │ └─ [_avg]: either '_float_filter' #80 - │ │ ├─ variant_0: float #72 - │ │ ├─ variant_1: struct #75 - │ │ │ └─ [equals]: float #72 - │ │ ├─ variant_2: struct #76 - │ │ │ └─ [not]: float #72 - │ │ ├─ variant_3: struct #77 - │ │ │ ├─ [lt]: optional #73 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ [gt]: optional #73 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ [lte]: optional #73 - │ │ │ │ └─ item: float #72 - │ │ │ └─ [gte]: optional #73 - │ │ │ └─ item: float #72 - │ │ ├─ variant_4: struct #78 - │ │ │ └─ [in]: list #74 - │ │ │ └─ item: float #72 - │ │ └─ variant_5: struct #79 - │ │ └─ [notIn]: list #74 - │ │ └─ item: float #72 - │ ├─ variant_4: struct #84 - │ │ └─ [_min]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_5: struct #85 - │ └─ [_max]: either '_integer_filter' #31 - │ ├─ variant_0: integer #23 - │ ├─ variant_1: struct #26 - │ │ └─ [equals]: integer #23 - │ ├─ variant_2: struct #27 - │ │ └─ [not]: integer #23 - │ ├─ variant_3: struct #28 - │ │ ├─ [lt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [gt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [lte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ └─ [gte]: optional #24 - │ │ └─ item: integer #23 - │ ├─ variant_4: struct #29 - │ │ └─ [in]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_5: struct #30 - │ └─ [notIn]: list #25 - │ └─ item: integer #23 - ├─ variant_1: struct #94 - │ └─ [AND]: list '_93__Record_Having[]' #93 - │ └─ item: &_Record_Having #92 - ├─ variant_2: struct #96 - │ └─ [OR]: list '_95__Record_Having[]' #95 - │ └─ item: &_Record_Having #92 - └─ variant_3: struct #97 - └─ [NOT]: &_Record_Having #92 +├─ [take]: optional '_60__Take?' #60 +│ └─ item: integer '_Take' #59 +└─ [where]: optional '_42_QueryRecordWhereInput?' #42 + └─ item: struct 'QueryRecordWhereInput' #41 + ├─ [AND]: optional '_39__38_QueryRecordWhereInput[]?' #39 + │ └─ item: list '_38_QueryRecordWhereInput[]' #38 + │ └─ item: &QueryRecordWhereInput #37 + ├─ [NOT]: optional '_40_QueryRecordWhereInput?' #40 + │ └─ item: &QueryRecordWhereInput #37 + ├─ [OR]: optional '_39__38_QueryRecordWhereInput[]?' #39 + │ └─ item: list '_38_QueryRecordWhereInput[]' #38 + │ └─ item: &QueryRecordWhereInput #37 + ├─ [age]: optional '_35__integer_filter_c?' #35 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 + ├─ [id]: optional '_21__string_filter_c?' #21 + │ └─ item: optional '_string_filter_c' #20 + │ └─ item: union #19 + │ ├─ variant_0: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ variant_1: struct #18 + │ └─ [not]: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ [name]: optional '_22__string_filter_c?' #22 + └─ item: optional '_string_filter_c' #20 + └─ item: union #19 + ├─ variant_0: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_1: struct #18 + └─ [not]: union '_string_filter' #17 + ├─ variant_0: string #5 + ├─ variant_1: struct #8 + │ └─ [equals]: string #5 + ├─ variant_2: struct #9 + │ └─ [not]: string #5 + ├─ variant_3: struct #10 + │ └─ [in]: list #7 + │ └─ item: string #5 + ├─ variant_4: struct #11 + │ └─ [notIn]: list #7 + │ └─ item: string #5 + ├─ variant_5: struct #14 + │ ├─ [contains]: string #5 + │ └─ [mode]: optional #13 + │ └─ item: string #12 enum{ '"insensitive"' } + ├─ variant_6: struct #15 + │ └─ [search]: string #5 + └─ variant_7: struct #16 + ├─ [endsWith]: optional #6 + │ └─ item: string #5 + └─ [startsWith]: optional #6 + └─ item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Record out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Record out.snap index 0f37c8731..2131de609 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Record out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by Record out.snap @@ -1,32 +1,32 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: "tree::PrintOptions::new().indent_size(3).print(out)" --- root: list '_Record_GroupByResult' #113 └─ item: struct #112 - ├─ [id]: string #0 - ├─ [name]: string #1 - ├─ [age]: optional #3 - │ └─ item: integer #2 + ├─ [_avg]: struct '_Record_SelectNumbers__1' #106 + │ └─ [age]: optional #105 + │ └─ item: float #104 ├─ [_count]: struct '_Record_AggrCount' #103 │ ├─ [_all]: optional #102 │ │ └─ item: integer #101 - │ ├─ [id]: optional #102 + │ ├─ [age]: optional #102 │ │ └─ item: integer #101 - │ ├─ [name]: optional #102 + │ ├─ [id]: optional #102 │ │ └─ item: integer #101 - │ └─ [age]: optional #102 + │ └─ [name]: optional #102 │ └─ item: integer #101 - ├─ [_avg]: struct '_Record_SelectNumbers__1' #106 - │ └─ [age]: optional #105 - │ └─ item: float #104 - ├─ [_sum]: struct '_Record_SelectNumbers_' #111 + ├─ [_max]: struct '_Record_SelectNumbers_' #111 │ └─ [age]: optional #110 │ └─ item: integer #109 ├─ [_min]: struct '_Record_SelectNumbers_' #111 │ └─ [age]: optional #110 │ └─ item: integer #109 - └─ [_max]: struct '_Record_SelectNumbers_' #111 - └─ [age]: optional #110 - └─ item: integer #109 + ├─ [_sum]: struct '_Record_SelectNumbers_' #111 + │ └─ [age]: optional #110 + │ └─ item: integer #109 + ├─ [age]: optional #3 + │ └─ item: integer #2 + ├─ [id]: string #0 + └─ [name]: string #1 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by User inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by User inp.snap index 04c36f450..faf0a4ef9 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by User inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by User inp.snap @@ -1,422 +1,1326 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct '_User_QueryInput_group_by' #187 -├─ [where]: optional '_144_QueryUserWhereInput?' #144 -│ └─ item: struct 'QueryUserWhereInput' #143 -│ ├─ [id]: optional '_123__integer_filter_c?' #123 -│ │ └─ item: optional '_integer_filter_c' #34 -│ │ └─ item: union #33 -│ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ ├─ variant_0: integer #23 -│ │ │ ├─ variant_1: struct #26 -│ │ │ │ └─ [equals]: integer #23 -│ │ │ ├─ variant_2: struct #27 -│ │ │ │ └─ [not]: integer #23 -│ │ │ ├─ variant_3: struct #28 -│ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ [gte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ variant_4: struct #29 -│ │ │ │ └─ [in]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_5: struct #30 -│ │ │ └─ [notIn]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_1: struct #32 -│ │ └─ [not]: either '_integer_filter' #31 -│ │ ├─ variant_0: integer #23 -│ │ ├─ variant_1: struct #26 -│ │ │ └─ [equals]: integer #23 -│ │ ├─ variant_2: struct #27 -│ │ │ └─ [not]: integer #23 -│ │ ├─ variant_3: struct #28 -│ │ │ ├─ [lt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [gt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [lte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ [gte]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ variant_4: struct #29 -│ │ │ └─ [in]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_5: struct #30 -│ │ └─ [notIn]: list #25 -│ │ └─ item: integer #23 -│ ├─ [name]: optional '_124__string_filter_c?' #124 -│ │ └─ item: optional '_string_filter_c' #20 -│ │ └─ item: union #19 -│ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ variant_1: struct #18 -│ │ └─ [not]: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ ├─ [posts]: optional #137 -│ │ └─ item: union #136 -│ │ ├─ variant_0: struct #131 -│ │ │ └─ [every]: optional '_130_PostWhere__skip_118_UserWhere?' #130 -│ │ │ └─ item: struct 'PostWhere__skip_118_UserWhere' #129 -│ │ │ ├─ [id]: optional '_125__integer_filter_c?' #125 -│ │ │ │ └─ item: optional '_integer_filter_c' #34 -│ │ │ │ └─ item: union #33 -│ │ │ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ variant_5: struct #30 -│ │ │ │ │ └─ [notIn]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_1: struct #32 -│ │ │ │ └─ [not]: either '_integer_filter' #31 -│ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_5: struct #30 -│ │ │ │ └─ [notIn]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [title]: optional '_126__string_filter_c?' #126 -│ │ │ │ └─ item: optional '_string_filter_c' #20 -│ │ │ │ └─ item: union #19 -│ │ │ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ │ │ ├─ variant_0: string #5 -│ │ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ │ └─ [not]: string #5 -│ │ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ │ └─ [search]: string #5 -│ │ │ │ │ └─ variant_7: struct #16 -│ │ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ variant_1: struct #18 -│ │ │ │ └─ [not]: union '_string_filter' #17 -│ │ │ │ ├─ variant_0: string #5 -│ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ └─ [not]: string #5 -│ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ └─ [search]: string #5 -│ │ │ │ └─ variant_7: struct #16 -│ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [author]: optional '_128_UserWhere?' #128 -│ │ │ └─ item: &UserWhere #127 -│ │ ├─ variant_1: struct #133 -│ │ │ └─ [some]: optional '_132_PostWhere__skip_118_UserWhere?' #132 -│ │ │ └─ item: struct 'PostWhere__skip_118_UserWhere' #129 -│ │ │ ├─ [id]: optional '_125__integer_filter_c?' #125 -│ │ │ │ └─ item: optional '_integer_filter_c' #34 -│ │ │ │ └─ item: union #33 -│ │ │ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ variant_5: struct #30 -│ │ │ │ │ └─ [notIn]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_1: struct #32 -│ │ │ │ └─ [not]: either '_integer_filter' #31 -│ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_5: struct #30 -│ │ │ │ └─ [notIn]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [title]: optional '_126__string_filter_c?' #126 -│ │ │ │ └─ item: optional '_string_filter_c' #20 -│ │ │ │ └─ item: union #19 -│ │ │ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ │ │ ├─ variant_0: string #5 -│ │ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ │ └─ [not]: string #5 -│ │ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ │ └─ [search]: string #5 -│ │ │ │ │ └─ variant_7: struct #16 -│ │ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ │ └─ item: string #5 -│ │ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ variant_1: struct #18 -│ │ │ │ └─ [not]: union '_string_filter' #17 -│ │ │ │ ├─ variant_0: string #5 -│ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ └─ [not]: string #5 -│ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ └─ [search]: string #5 -│ │ │ │ └─ variant_7: struct #16 -│ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [author]: optional '_128_UserWhere?' #128 -│ │ │ └─ item: &UserWhere #127 -│ │ └─ variant_2: struct #135 -│ │ └─ [none]: optional '_134_PostWhere__skip_118_UserWhere?' #134 -│ │ └─ item: struct 'PostWhere__skip_118_UserWhere' #129 -│ │ ├─ [id]: optional '_125__integer_filter_c?' #125 -│ │ │ └─ item: optional '_integer_filter_c' #34 -│ │ │ └─ item: union #33 -│ │ │ ├─ variant_0: either '_integer_filter' #31 -│ │ │ │ ├─ variant_0: integer #23 -│ │ │ │ ├─ variant_1: struct #26 -│ │ │ │ │ └─ [equals]: integer #23 -│ │ │ │ ├─ variant_2: struct #27 -│ │ │ │ │ └─ [not]: integer #23 -│ │ │ │ ├─ variant_3: struct #28 -│ │ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ │ └─ item: integer #23 -│ │ │ │ │ └─ [gte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ variant_4: struct #29 -│ │ │ │ │ └─ [in]: list #25 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ variant_5: struct #30 -│ │ │ │ └─ [notIn]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_1: struct #32 -│ │ │ └─ [not]: either '_integer_filter' #31 -│ │ │ ├─ variant_0: integer #23 -│ │ │ ├─ variant_1: struct #26 -│ │ │ │ └─ [equals]: integer #23 -│ │ │ ├─ variant_2: struct #27 -│ │ │ │ └─ [not]: integer #23 -│ │ │ ├─ variant_3: struct #28 -│ │ │ │ ├─ [lt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [gt]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ ├─ [lte]: optional #24 -│ │ │ │ │ └─ item: integer #23 -│ │ │ │ └─ [gte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ variant_4: struct #29 -│ │ │ │ └─ [in]: list #25 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ variant_5: struct #30 -│ │ │ └─ [notIn]: list #25 -│ │ │ └─ item: integer #23 -│ │ ├─ [title]: optional '_126__string_filter_c?' #126 -│ │ │ └─ item: optional '_string_filter_c' #20 -│ │ │ └─ item: union #19 -│ │ │ ├─ variant_0: union '_string_filter' #17 -│ │ │ │ ├─ variant_0: string #5 -│ │ │ │ ├─ variant_1: struct #8 -│ │ │ │ │ └─ [equals]: string #5 -│ │ │ │ ├─ variant_2: struct #9 -│ │ │ │ │ └─ [not]: string #5 -│ │ │ │ ├─ variant_3: struct #10 -│ │ │ │ │ └─ [in]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_4: struct #11 -│ │ │ │ │ └─ [notIn]: list #7 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ ├─ variant_5: struct #14 -│ │ │ │ │ ├─ [contains]: string #5 -│ │ │ │ │ └─ [mode]: optional #13 -│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #15 -│ │ │ │ │ └─ [search]: string #5 -│ │ │ │ └─ variant_7: struct #16 -│ │ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ │ └─ item: string #5 -│ │ │ │ └─ [endsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ variant_1: struct #18 -│ │ │ └─ [not]: union '_string_filter' #17 -│ │ │ ├─ variant_0: string #5 -│ │ │ ├─ variant_1: struct #8 -│ │ │ │ └─ [equals]: string #5 -│ │ │ ├─ variant_2: struct #9 -│ │ │ │ └─ [not]: string #5 -│ │ │ ├─ variant_3: struct #10 -│ │ │ │ └─ [in]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_4: struct #11 -│ │ │ │ └─ [notIn]: list #7 -│ │ │ │ └─ item: string #5 -│ │ │ ├─ variant_5: struct #14 -│ │ │ │ ├─ [contains]: string #5 -│ │ │ │ └─ [mode]: optional #13 -│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #15 -│ │ │ │ └─ [search]: string #5 -│ │ │ └─ variant_7: struct #16 -│ │ │ ├─ [startsWith]: optional #6 -│ │ │ │ └─ item: string #5 -│ │ │ └─ [endsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [author]: optional '_128_UserWhere?' #128 -│ │ └─ item: &UserWhere #127 -│ ├─ [AND]: optional '_141__140_QueryUserWhereInput[]?' #141 -│ │ └─ item: list '_140_QueryUserWhereInput[]' #140 -│ │ └─ item: &QueryUserWhereInput #139 -│ ├─ [OR]: optional '_141__140_QueryUserWhereInput[]?' #141 -│ │ └─ item: list '_140_QueryUserWhereInput[]' #140 -│ │ └─ item: &QueryUserWhereInput #139 -│ └─ [NOT]: optional '_142_QueryUserWhereInput?' #142 -│ └─ item: &QueryUserWhereInput #139 +├─ [by]: list '_User_GroupingFields' #162 +│ └─ item: string #161 enum{ '"id"', '"name"' } +├─ [cursor]: optional '_160__User_Cursor?' #160 +│ └─ item: union '_User_Cursor' #159 +│ ├─ variant_0: struct #157 +│ │ └─ [id]: integer #114 +│ └─ variant_1: struct #158 +│ └─ [name]: string #115 +├─ [having]: optional '_186__User_Having?' #186 +│ └─ item: union '_User_Having' #185 +│ ├─ variant_0: struct 'UserWhere__agg' #178 +│ │ ├─ [id]: optional '_163__integer_filter_with_aggregates_c?' #163 +│ │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 +│ │ │ └─ item: union #88 +│ │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 +│ │ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_1: struct #81 +│ │ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_2: struct #82 +│ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_3: struct #83 +│ │ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ │ ├─ variant_0: float #72 +│ │ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ │ └─ [not]: float #72 +│ │ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ variant_5: struct #79 +│ │ │ │ │ └─ [notIn]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #84 +│ │ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #85 +│ │ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_1: struct #87 +│ │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 +│ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_1: struct #81 +│ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_2: struct #82 +│ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_3: struct #83 +│ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ ├─ variant_0: float #72 +│ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ └─ [not]: float #72 +│ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ └─ variant_5: struct #79 +│ │ │ │ └─ [notIn]: list #74 +│ │ │ │ └─ item: float #72 +│ │ │ ├─ variant_4: struct #84 +│ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_5: struct #85 +│ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ ├─ variant_0: integer #23 +│ │ │ ├─ variant_1: struct #26 +│ │ │ │ └─ [equals]: integer #23 +│ │ │ ├─ variant_2: struct #27 +│ │ │ │ └─ [not]: integer #23 +│ │ │ ├─ variant_3: struct #28 +│ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ [lte]: optional #24 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_4: struct #29 +│ │ │ │ └─ [in]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_5: struct #30 +│ │ │ └─ [notIn]: list #25 +│ │ │ └─ item: integer #23 +│ │ ├─ [name]: optional '_164__string_filter_c?' #164 +│ │ │ └─ item: optional '_string_filter_c' #20 +│ │ │ └─ item: union #19 +│ │ │ ├─ variant_0: union '_string_filter' #17 +│ │ │ │ ├─ variant_0: string #5 +│ │ │ │ ├─ variant_1: struct #8 +│ │ │ │ │ └─ [equals]: string #5 +│ │ │ │ ├─ variant_2: struct #9 +│ │ │ │ │ └─ [not]: string #5 +│ │ │ │ ├─ variant_3: struct #10 +│ │ │ │ │ └─ [in]: list #7 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ ├─ variant_4: struct #11 +│ │ │ │ │ └─ [notIn]: list #7 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ ├─ variant_5: struct #14 +│ │ │ │ │ ├─ [contains]: string #5 +│ │ │ │ │ └─ [mode]: optional #13 +│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #15 +│ │ │ │ │ └─ [search]: string #5 +│ │ │ │ └─ variant_7: struct #16 +│ │ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ └─ [startsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ variant_1: struct #18 +│ │ │ └─ [not]: union '_string_filter' #17 +│ │ │ ├─ variant_0: string #5 +│ │ │ ├─ variant_1: struct #8 +│ │ │ │ └─ [equals]: string #5 +│ │ │ ├─ variant_2: struct #9 +│ │ │ │ └─ [not]: string #5 +│ │ │ ├─ variant_3: struct #10 +│ │ │ │ └─ [in]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_4: struct #11 +│ │ │ │ └─ [notIn]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_5: struct #14 +│ │ │ │ ├─ [contains]: string #5 +│ │ │ │ └─ [mode]: optional #13 +│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #15 +│ │ │ │ └─ [search]: string #5 +│ │ │ └─ variant_7: struct #16 +│ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ [startsWith]: optional #6 +│ │ │ └─ item: string #5 +│ │ └─ [posts]: optional #177 +│ │ └─ item: union #176 +│ │ ├─ variant_0: struct #171 +│ │ │ └─ [every]: optional '_170_PostWhere__agg__skip_118_UserWhere__agg?' #170 +│ │ │ └─ item: struct 'PostWhere__agg__skip_118_UserWhere__agg' #169 +│ │ │ ├─ [author]: optional '_168_UserWhere__agg?' #168 +│ │ │ │ └─ item: &UserWhere__agg #167 +│ │ │ ├─ [id]: optional '_165__integer_filter_with_aggregates_c?' #165 +│ │ │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 +│ │ │ │ └─ item: union #88 +│ │ │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_1: struct #81 +│ │ │ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_2: struct #82 +│ │ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_3: struct #83 +│ │ │ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ │ │ ├─ variant_0: float #72 +│ │ │ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ │ │ └─ [not]: float #72 +│ │ │ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ └─ variant_5: struct #79 +│ │ │ │ │ │ └─ [notIn]: list #74 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ variant_4: struct #84 +│ │ │ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #85 +│ │ │ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_1: struct #87 +│ │ │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 +│ │ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_1: struct #81 +│ │ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_2: struct #82 +│ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_3: struct #83 +│ │ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ │ ├─ variant_0: float #72 +│ │ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ │ └─ [not]: float #72 +│ │ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ variant_5: struct #79 +│ │ │ │ │ └─ [notIn]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #84 +│ │ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #85 +│ │ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ [title]: optional '_166__string_filter_c?' #166 +│ │ │ └─ item: optional '_string_filter_c' #20 +│ │ │ └─ item: union #19 +│ │ │ ├─ variant_0: union '_string_filter' #17 +│ │ │ │ ├─ variant_0: string #5 +│ │ │ │ ├─ variant_1: struct #8 +│ │ │ │ │ └─ [equals]: string #5 +│ │ │ │ ├─ variant_2: struct #9 +│ │ │ │ │ └─ [not]: string #5 +│ │ │ │ ├─ variant_3: struct #10 +│ │ │ │ │ └─ [in]: list #7 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ ├─ variant_4: struct #11 +│ │ │ │ │ └─ [notIn]: list #7 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ ├─ variant_5: struct #14 +│ │ │ │ │ ├─ [contains]: string #5 +│ │ │ │ │ └─ [mode]: optional #13 +│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #15 +│ │ │ │ │ └─ [search]: string #5 +│ │ │ │ └─ variant_7: struct #16 +│ │ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ └─ [startsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ variant_1: struct #18 +│ │ │ └─ [not]: union '_string_filter' #17 +│ │ │ ├─ variant_0: string #5 +│ │ │ ├─ variant_1: struct #8 +│ │ │ │ └─ [equals]: string #5 +│ │ │ ├─ variant_2: struct #9 +│ │ │ │ └─ [not]: string #5 +│ │ │ ├─ variant_3: struct #10 +│ │ │ │ └─ [in]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_4: struct #11 +│ │ │ │ └─ [notIn]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_5: struct #14 +│ │ │ │ ├─ [contains]: string #5 +│ │ │ │ └─ [mode]: optional #13 +│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #15 +│ │ │ │ └─ [search]: string #5 +│ │ │ └─ variant_7: struct #16 +│ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ [startsWith]: optional #6 +│ │ │ └─ item: string #5 +│ │ ├─ variant_1: struct #173 +│ │ │ └─ [some]: optional '_172_PostWhere__agg__skip_118_UserWhere__agg?' #172 +│ │ │ └─ item: struct 'PostWhere__agg__skip_118_UserWhere__agg' #169 +│ │ │ ├─ [author]: optional '_168_UserWhere__agg?' #168 +│ │ │ │ └─ item: &UserWhere__agg #167 +│ │ │ ├─ [id]: optional '_165__integer_filter_with_aggregates_c?' #165 +│ │ │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 +│ │ │ │ └─ item: union #88 +│ │ │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_1: struct #81 +│ │ │ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_2: struct #82 +│ │ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_3: struct #83 +│ │ │ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ │ │ ├─ variant_0: float #72 +│ │ │ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ │ │ └─ [not]: float #72 +│ │ │ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ └─ variant_5: struct #79 +│ │ │ │ │ │ └─ [notIn]: list #74 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ variant_4: struct #84 +│ │ │ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #85 +│ │ │ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_1: struct #87 +│ │ │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 +│ │ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_1: struct #81 +│ │ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_2: struct #82 +│ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_3: struct #83 +│ │ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ │ ├─ variant_0: float #72 +│ │ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ │ └─ [not]: float #72 +│ │ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ variant_5: struct #79 +│ │ │ │ │ └─ [notIn]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #84 +│ │ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #85 +│ │ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ [title]: optional '_166__string_filter_c?' #166 +│ │ │ └─ item: optional '_string_filter_c' #20 +│ │ │ └─ item: union #19 +│ │ │ ├─ variant_0: union '_string_filter' #17 +│ │ │ │ ├─ variant_0: string #5 +│ │ │ │ ├─ variant_1: struct #8 +│ │ │ │ │ └─ [equals]: string #5 +│ │ │ │ ├─ variant_2: struct #9 +│ │ │ │ │ └─ [not]: string #5 +│ │ │ │ ├─ variant_3: struct #10 +│ │ │ │ │ └─ [in]: list #7 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ ├─ variant_4: struct #11 +│ │ │ │ │ └─ [notIn]: list #7 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ ├─ variant_5: struct #14 +│ │ │ │ │ ├─ [contains]: string #5 +│ │ │ │ │ └─ [mode]: optional #13 +│ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #15 +│ │ │ │ │ └─ [search]: string #5 +│ │ │ │ └─ variant_7: struct #16 +│ │ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ │ └─ item: string #5 +│ │ │ │ └─ [startsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ variant_1: struct #18 +│ │ │ └─ [not]: union '_string_filter' #17 +│ │ │ ├─ variant_0: string #5 +│ │ │ ├─ variant_1: struct #8 +│ │ │ │ └─ [equals]: string #5 +│ │ │ ├─ variant_2: struct #9 +│ │ │ │ └─ [not]: string #5 +│ │ │ ├─ variant_3: struct #10 +│ │ │ │ └─ [in]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_4: struct #11 +│ │ │ │ └─ [notIn]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_5: struct #14 +│ │ │ │ ├─ [contains]: string #5 +│ │ │ │ └─ [mode]: optional #13 +│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #15 +│ │ │ │ └─ [search]: string #5 +│ │ │ └─ variant_7: struct #16 +│ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ [startsWith]: optional #6 +│ │ │ └─ item: string #5 +│ │ └─ variant_2: struct #175 +│ │ └─ [none]: optional '_174_PostWhere__agg__skip_118_UserWhere__agg?' #174 +│ │ └─ item: struct 'PostWhere__agg__skip_118_UserWhere__agg' #169 +│ │ ├─ [author]: optional '_168_UserWhere__agg?' #168 +│ │ │ └─ item: &UserWhere__agg #167 +│ │ ├─ [id]: optional '_165__integer_filter_with_aggregates_c?' #165 +│ │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 +│ │ │ └─ item: union #88 +│ │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 +│ │ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_1: struct #81 +│ │ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_2: struct #82 +│ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_3: struct #83 +│ │ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ │ ├─ variant_0: float #72 +│ │ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ │ └─ [not]: float #72 +│ │ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ variant_5: struct #79 +│ │ │ │ │ └─ [notIn]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #84 +│ │ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ variant_5: struct #30 +│ │ │ │ │ └─ [notIn]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #85 +│ │ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_1: struct #87 +│ │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 +│ │ │ ├─ variant_0: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_1: struct #81 +│ │ │ │ └─ [_count]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_2: struct #82 +│ │ │ │ └─ [_sum]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_3: struct #83 +│ │ │ │ └─ [_avg]: either '_float_filter' #80 +│ │ │ │ ├─ variant_0: float #72 +│ │ │ │ ├─ variant_1: struct #75 +│ │ │ │ │ └─ [equals]: float #72 +│ │ │ │ ├─ variant_2: struct #76 +│ │ │ │ │ └─ [not]: float #72 +│ │ │ │ ├─ variant_3: struct #77 +│ │ │ │ │ ├─ [gt]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ [gte]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ ├─ [lt]: optional #73 +│ │ │ │ │ │ └─ item: float #72 +│ │ │ │ │ └─ [lte]: optional #73 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ ├─ variant_4: struct #78 +│ │ │ │ │ └─ [in]: list #74 +│ │ │ │ │ └─ item: float #72 +│ │ │ │ └─ variant_5: struct #79 +│ │ │ │ └─ [notIn]: list #74 +│ │ │ │ └─ item: float #72 +│ │ │ ├─ variant_4: struct #84 +│ │ │ │ └─ [_min]: either '_integer_filter' #31 +│ │ │ │ ├─ variant_0: integer #23 +│ │ │ │ ├─ variant_1: struct #26 +│ │ │ │ │ └─ [equals]: integer #23 +│ │ │ │ ├─ variant_2: struct #27 +│ │ │ │ │ └─ [not]: integer #23 +│ │ │ │ ├─ variant_3: struct #28 +│ │ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ │ └─ item: integer #23 +│ │ │ │ │ └─ [lte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ variant_4: struct #29 +│ │ │ │ │ └─ [in]: list #25 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ variant_5: struct #30 +│ │ │ │ └─ [notIn]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_5: struct #85 +│ │ │ └─ [_max]: either '_integer_filter' #31 +│ │ │ ├─ variant_0: integer #23 +│ │ │ ├─ variant_1: struct #26 +│ │ │ │ └─ [equals]: integer #23 +│ │ │ ├─ variant_2: struct #27 +│ │ │ │ └─ [not]: integer #23 +│ │ │ ├─ variant_3: struct #28 +│ │ │ │ ├─ [gt]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ [gte]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ ├─ [lt]: optional #24 +│ │ │ │ │ └─ item: integer #23 +│ │ │ │ └─ [lte]: optional #24 +│ │ │ │ └─ item: integer #23 +│ │ │ ├─ variant_4: struct #29 +│ │ │ │ └─ [in]: list #25 +│ │ │ │ └─ item: integer #23 +│ │ │ └─ variant_5: struct #30 +│ │ │ └─ [notIn]: list #25 +│ │ │ └─ item: integer #23 +│ │ └─ [title]: optional '_166__string_filter_c?' #166 +│ │ └─ item: optional '_string_filter_c' #20 +│ │ └─ item: union #19 +│ │ ├─ variant_0: union '_string_filter' #17 +│ │ │ ├─ variant_0: string #5 +│ │ │ ├─ variant_1: struct #8 +│ │ │ │ └─ [equals]: string #5 +│ │ │ ├─ variant_2: struct #9 +│ │ │ │ └─ [not]: string #5 +│ │ │ ├─ variant_3: struct #10 +│ │ │ │ └─ [in]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_4: struct #11 +│ │ │ │ └─ [notIn]: list #7 +│ │ │ │ └─ item: string #5 +│ │ │ ├─ variant_5: struct #14 +│ │ │ │ ├─ [contains]: string #5 +│ │ │ │ └─ [mode]: optional #13 +│ │ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #15 +│ │ │ │ └─ [search]: string #5 +│ │ │ └─ variant_7: struct #16 +│ │ │ ├─ [endsWith]: optional #6 +│ │ │ │ └─ item: string #5 +│ │ │ └─ [startsWith]: optional #6 +│ │ │ └─ item: string #5 +│ │ └─ variant_1: struct #18 +│ │ └─ [not]: union '_string_filter' #17 +│ │ ├─ variant_0: string #5 +│ │ ├─ variant_1: struct #8 +│ │ │ └─ [equals]: string #5 +│ │ ├─ variant_2: struct #9 +│ │ │ └─ [not]: string #5 +│ │ ├─ variant_3: struct #10 +│ │ │ └─ [in]: list #7 +│ │ │ └─ item: string #5 +│ │ ├─ variant_4: struct #11 +│ │ │ └─ [notIn]: list #7 +│ │ │ └─ item: string #5 +│ │ ├─ variant_5: struct #14 +│ │ │ ├─ [contains]: string #5 +│ │ │ └─ [mode]: optional #13 +│ │ │ └─ item: string #12 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #15 +│ │ │ └─ [search]: string #5 +│ │ └─ variant_7: struct #16 +│ │ ├─ [endsWith]: optional #6 +│ │ │ └─ item: string #5 +│ │ └─ [startsWith]: optional #6 +│ │ └─ item: string #5 +│ ├─ variant_1: struct #181 +│ │ └─ [AND]: list '_180__User_Having[]' #180 +│ │ └─ item: &_User_Having #179 +│ ├─ variant_2: struct #183 +│ │ └─ [OR]: list '_182__User_Having[]' #182 +│ │ └─ item: &_User_Having #179 +│ └─ variant_3: struct #184 +│ └─ [NOT]: &_User_Having #179 ├─ [orderBy]: optional '_154__User_OrderBy_with_aggregates?' #154 │ └─ item: list '_User_OrderBy_with_aggregates' #153 │ └─ item: struct #152 +│ ├─ [_avg]: optional #148 +│ │ └─ item: struct #147 +│ │ └─ [id]: optional '_Sort' #47 +│ │ └─ item: union #46 +│ │ ├─ variant_0: struct #45 +│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ ├─ [_count]: optional #146 │ │ └─ item: struct #145 │ │ ├─ [id]: optional '_Sort' #47 @@ -434,14 +1338,7 @@ root: struct '_User_QueryInput_group_by' #187 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_avg]: optional #148 -│ │ └─ item: struct #147 -│ │ └─ [id]: optional '_Sort' #47 -│ │ └─ item: union #46 -│ │ ├─ variant_0: struct #45 -│ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_sum]: optional #148 +│ ├─ [_max]: optional #148 │ │ └─ item: struct #147 │ │ └─ [id]: optional '_Sort' #47 │ │ └─ item: union #46 @@ -455,7 +1352,7 @@ root: struct '_User_QueryInput_group_by' #187 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_max]: optional #148 +│ ├─ [_sum]: optional #148 │ │ └─ item: struct #147 │ │ └─ [id]: optional '_Sort' #47 │ │ └─ item: union #46 @@ -474,17 +1371,17 @@ root: struct '_User_QueryInput_group_by' #187 │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ └─ [posts]: optional '_SortByAggregates' #151 │ └─ item: struct #150 -│ ├─ [_count]: optional '_Sort' #47 +│ ├─ [_avg]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_avg]: optional '_Sort' #47 +│ ├─ [_count]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_sum]: optional '_Sort' #47 +│ ├─ [_max]: optional '_Sort' #47 │ │ └─ item: union #46 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } @@ -494,1321 +1391,424 @@ root: struct '_User_QueryInput_group_by' #187 │ │ ├─ variant_0: struct #45 │ │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └─ [_max]: optional '_Sort' #47 +│ └─ [_sum]: optional '_Sort' #47 │ └─ item: union #46 │ ├─ variant_0: struct #45 │ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -├─ [take]: optional '_155__Take?' #155 -│ └─ item: integer '_Take' #59 ├─ [skip]: optional '_156__Skip?' #156 │ └─ item: integer '_Skip' #61 -├─ [cursor]: optional '_160__User_Cursor?' #160 -│ └─ item: union '_User_Cursor' #159 -│ ├─ variant_0: struct #157 -│ │ └─ [id]: integer #114 -│ └─ variant_1: struct #158 -│ └─ [name]: string #115 -├─ [by]: list '_User_GroupingFields' #162 -│ └─ item: string #161 enum{ '"id"', '"name"' } -└─ [having]: optional '_186__User_Having?' #186 - └─ item: union '_User_Having' #185 - ├─ variant_0: struct 'UserWhere__agg' #178 - │ ├─ [id]: optional '_163__integer_filter_with_aggregates_c?' #163 - │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 - │ │ └─ item: union #88 - │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 - │ │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_1: struct #81 - │ │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_2: struct #82 - │ │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_3: struct #83 - │ │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ │ ├─ variant_0: float #72 - │ │ │ │ ├─ variant_1: struct #75 - │ │ │ │ │ └─ [equals]: float #72 - │ │ │ │ ├─ variant_2: struct #76 - │ │ │ │ │ └─ [not]: float #72 - │ │ │ │ ├─ variant_3: struct #77 - │ │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ variant_4: struct #78 - │ │ │ │ │ └─ [in]: list #74 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ variant_5: struct #79 - │ │ │ │ └─ [notIn]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #84 - │ │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #85 - │ │ │ └─ [_max]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_1: struct #87 - │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 - │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_1: struct #81 - │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_2: struct #82 - │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_3: struct #83 - │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ ├─ variant_0: float #72 - │ │ │ ├─ variant_1: struct #75 - │ │ │ │ └─ [equals]: float #72 - │ │ │ ├─ variant_2: struct #76 - │ │ │ │ └─ [not]: float #72 - │ │ │ ├─ variant_3: struct #77 - │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #78 - │ │ │ │ └─ [in]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ └─ variant_5: struct #79 - │ │ │ └─ [notIn]: list #74 - │ │ │ └─ item: float #72 - │ │ ├─ variant_4: struct #84 - │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #85 - │ │ └─ [_max]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ ├─ [name]: optional '_164__string_filter_c?' #164 - │ │ └─ item: optional '_string_filter_c' #20 - │ │ └─ item: union #19 - │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ variant_1: struct #18 - │ │ └─ [not]: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [posts]: optional #177 - │ └─ item: union #176 - │ ├─ variant_0: struct #171 - │ │ └─ [every]: optional '_170_PostWhere__agg__skip_118_UserWhere__agg?' #170 - │ │ └─ item: struct 'PostWhere__agg__skip_118_UserWhere__agg' #169 - │ │ ├─ [id]: optional '_165__integer_filter_with_aggregates_c?' #165 - │ │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 - │ │ │ └─ item: union #88 - │ │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 - │ │ │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_1: struct #81 - │ │ │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_2: struct #82 - │ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_3: struct #83 - │ │ │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ │ │ ├─ variant_0: float #72 - │ │ │ │ │ ├─ variant_1: struct #75 - │ │ │ │ │ │ └─ [equals]: float #72 - │ │ │ │ │ ├─ variant_2: struct #76 - │ │ │ │ │ │ └─ [not]: float #72 - │ │ │ │ │ ├─ variant_3: struct #77 - │ │ │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ variant_4: struct #78 - │ │ │ │ │ │ └─ [in]: list #74 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ └─ variant_5: struct #79 - │ │ │ │ │ └─ [notIn]: list #74 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ variant_4: struct #84 - │ │ │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #85 - │ │ │ │ └─ [_max]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_1: struct #87 - │ │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 - │ │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_1: struct #81 - │ │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_2: struct #82 - │ │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_3: struct #83 - │ │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ │ ├─ variant_0: float #72 - │ │ │ │ ├─ variant_1: struct #75 - │ │ │ │ │ └─ [equals]: float #72 - │ │ │ │ ├─ variant_2: struct #76 - │ │ │ │ │ └─ [not]: float #72 - │ │ │ │ ├─ variant_3: struct #77 - │ │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ variant_4: struct #78 - │ │ │ │ │ └─ [in]: list #74 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ variant_5: struct #79 - │ │ │ │ └─ [notIn]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #84 - │ │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #85 - │ │ │ └─ [_max]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ [title]: optional '_166__string_filter_c?' #166 - │ │ │ └─ item: optional '_string_filter_c' #20 - │ │ │ └─ item: union #19 - │ │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ │ ├─ variant_0: string #5 - │ │ │ │ ├─ variant_1: struct #8 - │ │ │ │ │ └─ [equals]: string #5 - │ │ │ │ ├─ variant_2: struct #9 - │ │ │ │ │ └─ [not]: string #5 - │ │ │ │ ├─ variant_3: struct #10 - │ │ │ │ │ └─ [in]: list #7 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ ├─ variant_4: struct #11 - │ │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ ├─ variant_5: struct #14 - │ │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #15 - │ │ │ │ │ └─ [search]: string #5 - │ │ │ │ └─ variant_7: struct #16 - │ │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ └─ [endsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ variant_1: struct #18 - │ │ │ └─ [not]: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [author]: optional '_168_UserWhere__agg?' #168 - │ │ └─ item: &UserWhere__agg #167 - │ ├─ variant_1: struct #173 - │ │ └─ [some]: optional '_172_PostWhere__agg__skip_118_UserWhere__agg?' #172 - │ │ └─ item: struct 'PostWhere__agg__skip_118_UserWhere__agg' #169 - │ │ ├─ [id]: optional '_165__integer_filter_with_aggregates_c?' #165 - │ │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 - │ │ │ └─ item: union #88 - │ │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 - │ │ │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_1: struct #81 - │ │ │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_2: struct #82 - │ │ │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_3: struct #83 - │ │ │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ │ │ ├─ variant_0: float #72 - │ │ │ │ │ ├─ variant_1: struct #75 - │ │ │ │ │ │ └─ [equals]: float #72 - │ │ │ │ │ ├─ variant_2: struct #76 - │ │ │ │ │ │ └─ [not]: float #72 - │ │ │ │ │ ├─ variant_3: struct #77 - │ │ │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ variant_4: struct #78 - │ │ │ │ │ │ └─ [in]: list #74 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ └─ variant_5: struct #79 - │ │ │ │ │ └─ [notIn]: list #74 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ variant_4: struct #84 - │ │ │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #85 - │ │ │ │ └─ [_max]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_1: struct #87 - │ │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 - │ │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_1: struct #81 - │ │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_2: struct #82 - │ │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_3: struct #83 - │ │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ │ ├─ variant_0: float #72 - │ │ │ │ ├─ variant_1: struct #75 - │ │ │ │ │ └─ [equals]: float #72 - │ │ │ │ ├─ variant_2: struct #76 - │ │ │ │ │ └─ [not]: float #72 - │ │ │ │ ├─ variant_3: struct #77 - │ │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ variant_4: struct #78 - │ │ │ │ │ └─ [in]: list #74 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ variant_5: struct #79 - │ │ │ │ └─ [notIn]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #84 - │ │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #85 - │ │ │ └─ [_max]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ [title]: optional '_166__string_filter_c?' #166 - │ │ │ └─ item: optional '_string_filter_c' #20 - │ │ │ └─ item: union #19 - │ │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ │ ├─ variant_0: string #5 - │ │ │ │ ├─ variant_1: struct #8 - │ │ │ │ │ └─ [equals]: string #5 - │ │ │ │ ├─ variant_2: struct #9 - │ │ │ │ │ └─ [not]: string #5 - │ │ │ │ ├─ variant_3: struct #10 - │ │ │ │ │ └─ [in]: list #7 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ ├─ variant_4: struct #11 - │ │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ ├─ variant_5: struct #14 - │ │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #15 - │ │ │ │ │ └─ [search]: string #5 - │ │ │ │ └─ variant_7: struct #16 - │ │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ │ └─ item: string #5 - │ │ │ │ └─ [endsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ variant_1: struct #18 - │ │ │ └─ [not]: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [author]: optional '_168_UserWhere__agg?' #168 - │ │ └─ item: &UserWhere__agg #167 - │ └─ variant_2: struct #175 - │ └─ [none]: optional '_174_PostWhere__agg__skip_118_UserWhere__agg?' #174 - │ └─ item: struct 'PostWhere__agg__skip_118_UserWhere__agg' #169 - │ ├─ [id]: optional '_165__integer_filter_with_aggregates_c?' #165 - │ │ └─ item: optional '_integer_filter_with_aggregates_c' #89 - │ │ └─ item: union #88 - │ │ ├─ variant_0: union '_integer_filter_with_aggregates' #86 - │ │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_1: struct #81 - │ │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_2: struct #82 - │ │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_3: struct #83 - │ │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ │ ├─ variant_0: float #72 - │ │ │ │ ├─ variant_1: struct #75 - │ │ │ │ │ └─ [equals]: float #72 - │ │ │ │ ├─ variant_2: struct #76 - │ │ │ │ │ └─ [not]: float #72 - │ │ │ │ ├─ variant_3: struct #77 - │ │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ │ └─ item: float #72 - │ │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ variant_4: struct #78 - │ │ │ │ │ └─ [in]: list #74 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ variant_5: struct #79 - │ │ │ │ └─ [notIn]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #84 - │ │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ │ ├─ variant_0: integer #23 - │ │ │ │ ├─ variant_1: struct #26 - │ │ │ │ │ └─ [equals]: integer #23 - │ │ │ │ ├─ variant_2: struct #27 - │ │ │ │ │ └─ [not]: integer #23 - │ │ │ │ ├─ variant_3: struct #28 - │ │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ │ └─ item: integer #23 - │ │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ variant_4: struct #29 - │ │ │ │ │ └─ [in]: list #25 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ variant_5: struct #30 - │ │ │ │ └─ [notIn]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #85 - │ │ │ └─ [_max]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_1: struct #87 - │ │ └─ [not]: union '_integer_filter_with_aggregates' #86 - │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_1: struct #81 - │ │ │ └─ [_count]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_2: struct #82 - │ │ │ └─ [_sum]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_3: struct #83 - │ │ │ └─ [_avg]: either '_float_filter' #80 - │ │ │ ├─ variant_0: float #72 - │ │ │ ├─ variant_1: struct #75 - │ │ │ │ └─ [equals]: float #72 - │ │ │ ├─ variant_2: struct #76 - │ │ │ │ └─ [not]: float #72 - │ │ │ ├─ variant_3: struct #77 - │ │ │ │ ├─ [lt]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ [gt]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ ├─ [lte]: optional #73 - │ │ │ │ │ └─ item: float #72 - │ │ │ │ └─ [gte]: optional #73 - │ │ │ │ └─ item: float #72 - │ │ │ ├─ variant_4: struct #78 - │ │ │ │ └─ [in]: list #74 - │ │ │ │ └─ item: float #72 - │ │ │ └─ variant_5: struct #79 - │ │ │ └─ [notIn]: list #74 - │ │ │ └─ item: float #72 - │ │ ├─ variant_4: struct #84 - │ │ │ └─ [_min]: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #85 - │ │ └─ [_max]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ ├─ [title]: optional '_166__string_filter_c?' #166 - │ │ └─ item: optional '_string_filter_c' #20 - │ │ └─ item: union #19 - │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ variant_1: struct #18 - │ │ └─ [not]: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [author]: optional '_168_UserWhere__agg?' #168 - │ └─ item: &UserWhere__agg #167 - ├─ variant_1: struct #181 - │ └─ [AND]: list '_180__User_Having[]' #180 - │ └─ item: &_User_Having #179 - ├─ variant_2: struct #183 - │ └─ [OR]: list '_182__User_Having[]' #182 - │ └─ item: &_User_Having #179 - └─ variant_3: struct #184 - └─ [NOT]: &_User_Having #179 +├─ [take]: optional '_155__Take?' #155 +│ └─ item: integer '_Take' #59 +└─ [where]: optional '_144_QueryUserWhereInput?' #144 + └─ item: struct 'QueryUserWhereInput' #143 + ├─ [AND]: optional '_141__140_QueryUserWhereInput[]?' #141 + │ └─ item: list '_140_QueryUserWhereInput[]' #140 + │ └─ item: &QueryUserWhereInput #139 + ├─ [NOT]: optional '_142_QueryUserWhereInput?' #142 + │ └─ item: &QueryUserWhereInput #139 + ├─ [OR]: optional '_141__140_QueryUserWhereInput[]?' #141 + │ └─ item: list '_140_QueryUserWhereInput[]' #140 + │ └─ item: &QueryUserWhereInput #139 + ├─ [id]: optional '_123__integer_filter_c?' #123 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 + ├─ [name]: optional '_124__string_filter_c?' #124 + │ └─ item: optional '_string_filter_c' #20 + │ └─ item: union #19 + │ ├─ variant_0: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ variant_1: struct #18 + │ └─ [not]: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ [posts]: optional #137 + └─ item: union #136 + ├─ variant_0: struct #131 + │ └─ [every]: optional '_130_PostWhere__skip_118_UserWhere?' #130 + │ └─ item: struct 'PostWhere__skip_118_UserWhere' #129 + │ ├─ [author]: optional '_128_UserWhere?' #128 + │ │ └─ item: &UserWhere #127 + │ ├─ [id]: optional '_125__integer_filter_c?' #125 + │ │ └─ item: optional '_integer_filter_c' #34 + │ │ └─ item: union #33 + │ │ ├─ variant_0: either '_integer_filter' #31 + │ │ │ ├─ variant_0: integer #23 + │ │ │ ├─ variant_1: struct #26 + │ │ │ │ └─ [equals]: integer #23 + │ │ │ ├─ variant_2: struct #27 + │ │ │ │ └─ [not]: integer #23 + │ │ │ ├─ variant_3: struct #28 + │ │ │ │ ├─ [gt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [gte]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [lt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ └─ [lte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ variant_4: struct #29 + │ │ │ │ └─ [in]: list #25 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ variant_5: struct #30 + │ │ │ └─ [notIn]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_1: struct #32 + │ │ └─ [not]: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ [title]: optional '_126__string_filter_c?' #126 + │ └─ item: optional '_string_filter_c' #20 + │ └─ item: union #19 + │ ├─ variant_0: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ variant_1: struct #18 + │ └─ [not]: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + ├─ variant_1: struct #133 + │ └─ [some]: optional '_132_PostWhere__skip_118_UserWhere?' #132 + │ └─ item: struct 'PostWhere__skip_118_UserWhere' #129 + │ ├─ [author]: optional '_128_UserWhere?' #128 + │ │ └─ item: &UserWhere #127 + │ ├─ [id]: optional '_125__integer_filter_c?' #125 + │ │ └─ item: optional '_integer_filter_c' #34 + │ │ └─ item: union #33 + │ │ ├─ variant_0: either '_integer_filter' #31 + │ │ │ ├─ variant_0: integer #23 + │ │ │ ├─ variant_1: struct #26 + │ │ │ │ └─ [equals]: integer #23 + │ │ │ ├─ variant_2: struct #27 + │ │ │ │ └─ [not]: integer #23 + │ │ │ ├─ variant_3: struct #28 + │ │ │ │ ├─ [gt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [gte]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ ├─ [lt]: optional #24 + │ │ │ │ │ └─ item: integer #23 + │ │ │ │ └─ [lte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ variant_4: struct #29 + │ │ │ │ └─ [in]: list #25 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ variant_5: struct #30 + │ │ │ └─ [notIn]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_1: struct #32 + │ │ └─ [not]: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ [title]: optional '_126__string_filter_c?' #126 + │ └─ item: optional '_string_filter_c' #20 + │ └─ item: union #19 + │ ├─ variant_0: union '_string_filter' #17 + │ │ ├─ variant_0: string #5 + │ │ ├─ variant_1: struct #8 + │ │ │ └─ [equals]: string #5 + │ │ ├─ variant_2: struct #9 + │ │ │ └─ [not]: string #5 + │ │ ├─ variant_3: struct #10 + │ │ │ └─ [in]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_4: struct #11 + │ │ │ └─ [notIn]: list #7 + │ │ │ └─ item: string #5 + │ │ ├─ variant_5: struct #14 + │ │ │ ├─ [contains]: string #5 + │ │ │ └─ [mode]: optional #13 + │ │ │ └─ item: string #12 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #15 + │ │ │ └─ [search]: string #5 + │ │ └─ variant_7: struct #16 + │ │ ├─ [endsWith]: optional #6 + │ │ │ └─ item: string #5 + │ │ └─ [startsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ variant_1: struct #18 + │ └─ [not]: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_2: struct #135 + └─ [none]: optional '_134_PostWhere__skip_118_UserWhere?' #134 + └─ item: struct 'PostWhere__skip_118_UserWhere' #129 + ├─ [author]: optional '_128_UserWhere?' #128 + │ └─ item: &UserWhere #127 + ├─ [id]: optional '_125__integer_filter_c?' #125 + │ └─ item: optional '_integer_filter_c' #34 + │ └─ item: union #33 + │ ├─ variant_0: either '_integer_filter' #31 + │ │ ├─ variant_0: integer #23 + │ │ ├─ variant_1: struct #26 + │ │ │ └─ [equals]: integer #23 + │ │ ├─ variant_2: struct #27 + │ │ │ └─ [not]: integer #23 + │ │ ├─ variant_3: struct #28 + │ │ │ ├─ [gt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [gte]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ ├─ [lt]: optional #24 + │ │ │ │ └─ item: integer #23 + │ │ │ └─ [lte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ variant_4: struct #29 + │ │ │ └─ [in]: list #25 + │ │ │ └─ item: integer #23 + │ │ └─ variant_5: struct #30 + │ │ └─ [notIn]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_1: struct #32 + │ └─ [not]: either '_integer_filter' #31 + │ ├─ variant_0: integer #23 + │ ├─ variant_1: struct #26 + │ │ └─ [equals]: integer #23 + │ ├─ variant_2: struct #27 + │ │ └─ [not]: integer #23 + │ ├─ variant_3: struct #28 + │ │ ├─ [gt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [gte]: optional #24 + │ │ │ └─ item: integer #23 + │ │ ├─ [lt]: optional #24 + │ │ │ └─ item: integer #23 + │ │ └─ [lte]: optional #24 + │ │ └─ item: integer #23 + │ ├─ variant_4: struct #29 + │ │ └─ [in]: list #25 + │ │ └─ item: integer #23 + │ └─ variant_5: struct #30 + │ └─ [notIn]: list #25 + │ └─ item: integer #23 + └─ [title]: optional '_126__string_filter_c?' #126 + └─ item: optional '_string_filter_c' #20 + └─ item: union #19 + ├─ variant_0: union '_string_filter' #17 + │ ├─ variant_0: string #5 + │ ├─ variant_1: struct #8 + │ │ └─ [equals]: string #5 + │ ├─ variant_2: struct #9 + │ │ └─ [not]: string #5 + │ ├─ variant_3: struct #10 + │ │ └─ [in]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_4: struct #11 + │ │ └─ [notIn]: list #7 + │ │ └─ item: string #5 + │ ├─ variant_5: struct #14 + │ │ ├─ [contains]: string #5 + │ │ └─ [mode]: optional #13 + │ │ └─ item: string #12 enum{ '"insensitive"' } + │ ├─ variant_6: struct #15 + │ │ └─ [search]: string #5 + │ └─ variant_7: struct #16 + │ ├─ [endsWith]: optional #6 + │ │ └─ item: string #5 + │ └─ [startsWith]: optional #6 + │ └─ item: string #5 + └─ variant_1: struct #18 + └─ [not]: union '_string_filter' #17 + ├─ variant_0: string #5 + ├─ variant_1: struct #8 + │ └─ [equals]: string #5 + ├─ variant_2: struct #9 + │ └─ [not]: string #5 + ├─ variant_3: struct #10 + │ └─ [in]: list #7 + │ └─ item: string #5 + ├─ variant_4: struct #11 + │ └─ [notIn]: list #7 + │ └─ item: string #5 + ├─ variant_5: struct #14 + │ ├─ [contains]: string #5 + │ └─ [mode]: optional #13 + │ └─ item: string #12 enum{ '"insensitive"' } + ├─ variant_6: struct #15 + │ └─ [search]: string #5 + └─ variant_7: struct #16 + ├─ [endsWith]: optional #6 + │ └─ item: string #5 + └─ [startsWith]: optional #6 + └─ item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by User out.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by User out.snap index 923f54a8b..3aca63dfb 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by User out.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__group_by User out.snap @@ -1,13 +1,12 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: list '_User_GroupByResult' #200 └─ item: struct #199 - ├─ [id]: integer #114 - ├─ [name]: string #115 - ├─ [posts]: list '_117_Post[]' #117 - │ └─ item: &Post #116 + ├─ [_avg]: struct '_User_SelectNumbers__1' #193 + │ └─ [id]: optional #192 + │ └─ item: float #191 ├─ [_count]: struct '_User_AggrCount' #190 │ ├─ [_all]: optional #189 │ │ └─ item: integer #188 @@ -17,16 +16,17 @@ root: list '_User_GroupByResult' #200 │ │ └─ item: integer #188 │ └─ [posts]: optional #189 │ └─ item: integer #188 - ├─ [_avg]: struct '_User_SelectNumbers__1' #193 - │ └─ [id]: optional #192 - │ └─ item: float #191 - ├─ [_sum]: struct '_User_SelectNumbers_' #198 + ├─ [_max]: struct '_User_SelectNumbers_' #198 │ └─ [id]: optional #197 │ └─ item: integer #196 ├─ [_min]: struct '_User_SelectNumbers_' #198 │ └─ [id]: optional #197 │ └─ item: integer #196 - └─ [_max]: struct '_User_SelectNumbers_' #198 - └─ [id]: optional #197 - └─ item: integer #196 + ├─ [_sum]: struct '_User_SelectNumbers_' #198 + │ └─ [id]: optional #197 + │ └─ item: integer #196 + ├─ [id]: integer #114 + ├─ [name]: string #115 + └─ [posts]: list '_117_Post[]' #117 + └─ item: &Post #116 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many Post inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many Post inp.snap index c6f55e616..ad574ef46 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many Post inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many Post inp.snap @@ -1,9 +1,843 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #182 ├─ [data]: struct '_Post_UpdateInput' #175 +│ ├─ [author]: optional #174 +│ │ └─ item: union #173 +│ │ ├─ variant_0: struct #159 +│ │ │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #157 +│ │ │ ├─ [id]: integer #57 +│ │ │ └─ [name]: string #58 +│ │ ├─ variant_1: struct #160 +│ │ │ └─ [connect]: struct 'UserWhere' #140 +│ │ │ ├─ [id]: optional '_125__integer_filter_c?' #125 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_126__string_filter_c?' #126 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #139 +│ │ │ └─ item: union #138 +│ │ │ ├─ variant_0: struct #133 +│ │ │ │ └─ [every]: optional '_132_PostWhere__skip_61_UserWhere?' #132 +│ │ │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 +│ │ │ │ ├─ [author]: optional '_130_UserWhere?' #130 +│ │ │ │ │ └─ item: &UserWhere #129 +│ │ │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ [title]: optional '_128__string_filter_c?' #128 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_1: struct #135 +│ │ │ │ └─ [some]: optional '_134_PostWhere__skip_61_UserWhere?' #134 +│ │ │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 +│ │ │ │ ├─ [author]: optional '_130_UserWhere?' #130 +│ │ │ │ │ └─ item: &UserWhere #129 +│ │ │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ [title]: optional '_128__string_filter_c?' #128 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_2: struct #137 +│ │ │ └─ [none]: optional '_136_PostWhere__skip_61_UserWhere?' #136 +│ │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 +│ │ │ ├─ [author]: optional '_130_UserWhere?' #130 +│ │ │ │ └─ item: &UserWhere #129 +│ │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ └─ [title]: optional '_128__string_filter_c?' #128 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ ├─ variant_2: struct #161 +│ │ │ └─ [connectOrCreate]: struct #158 +│ │ │ ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #157 +│ │ │ │ ├─ [id]: integer #57 +│ │ │ │ └─ [name]: string #58 +│ │ │ └─ [where]: struct 'UserWhere' #140 +│ │ │ ├─ [id]: optional '_125__integer_filter_c?' #125 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_126__string_filter_c?' #126 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #139 +│ │ │ └─ item: union #138 +│ │ │ ├─ variant_0: struct #133 +│ │ │ │ └─ [every]: optional '_132_PostWhere__skip_61_UserWhere?' #132 +│ │ │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 +│ │ │ │ ├─ [author]: optional '_130_UserWhere?' #130 +│ │ │ │ │ └─ item: &UserWhere #129 +│ │ │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ [title]: optional '_128__string_filter_c?' #128 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_1: struct #135 +│ │ │ │ └─ [some]: optional '_134_PostWhere__skip_61_UserWhere?' #134 +│ │ │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 +│ │ │ │ ├─ [author]: optional '_130_UserWhere?' #130 +│ │ │ │ │ └─ item: &UserWhere #129 +│ │ │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ [title]: optional '_128__string_filter_c?' #128 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_2: struct #137 +│ │ │ └─ [none]: optional '_136_PostWhere__skip_61_UserWhere?' #136 +│ │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 +│ │ │ ├─ [author]: optional '_130_UserWhere?' #130 +│ │ │ │ └─ item: &UserWhere #129 +│ │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ └─ [title]: optional '_128__string_filter_c?' #128 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_3: struct #172 +│ │ └─ [update]: struct '_User_UpdateInput_excluding___rel_Post_User_1' #171 +│ │ ├─ [id]: optional #167 +│ │ │ └─ item: union #166 +│ │ │ ├─ variant_0: integer #57 +│ │ │ ├─ variant_1: struct #162 +│ │ │ │ └─ [set]: integer #57 +│ │ │ ├─ variant_2: struct #163 +│ │ │ │ └─ [multiply]: integer #57 +│ │ │ ├─ variant_3: struct #164 +│ │ │ │ └─ [decrement]: integer #57 +│ │ │ └─ variant_4: struct #165 +│ │ │ └─ [increment]: integer #57 +│ │ └─ [name]: optional #170 +│ │ └─ item: union #169 +│ │ ├─ variant_0: string #58 +│ │ └─ variant_1: struct #168 +│ │ └─ [set]: string #58 │ ├─ [id]: optional #153 │ │ └─ item: union #152 │ │ ├─ variant_0: integer #62 @@ -15,943 +849,21 @@ root: struct #182 │ │ │ └─ [decrement]: integer #62 │ │ └─ variant_4: struct #151 │ │ └─ [increment]: integer #62 -│ ├─ [title]: optional #156 -│ │ └─ item: union #155 -│ │ ├─ variant_0: string #63 -│ │ └─ variant_1: struct #154 -│ │ └─ [set]: string #63 -│ └─ [author]: optional #174 -│ └─ item: union #173 -│ ├─ variant_0: struct #159 -│ │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #157 -│ │ ├─ [id]: integer #57 -│ │ └─ [name]: string #58 -│ ├─ variant_1: struct #160 -│ │ └─ [connect]: struct 'UserWhere' #140 -│ │ ├─ [id]: optional '_125__integer_filter_c?' #125 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [name]: optional '_126__string_filter_c?' #126 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [posts]: optional #139 -│ │ └─ item: union #138 -│ │ ├─ variant_0: struct #133 -│ │ │ └─ [every]: optional '_132_PostWhere__skip_61_UserWhere?' #132 -│ │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 -│ │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_128__string_filter_c?' #128 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_130_UserWhere?' #130 -│ │ │ └─ item: &UserWhere #129 -│ │ ├─ variant_1: struct #135 -│ │ │ └─ [some]: optional '_134_PostWhere__skip_61_UserWhere?' #134 -│ │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 -│ │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_128__string_filter_c?' #128 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_130_UserWhere?' #130 -│ │ │ └─ item: &UserWhere #129 -│ │ └─ variant_2: struct #137 -│ │ └─ [none]: optional '_136_PostWhere__skip_61_UserWhere?' #136 -│ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 -│ │ ├─ [id]: optional '_127__integer_filter_c?' #127 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [title]: optional '_128__string_filter_c?' #128 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [author]: optional '_130_UserWhere?' #130 -│ │ └─ item: &UserWhere #129 -│ ├─ variant_2: struct #161 -│ │ └─ [connectOrCreate]: struct #158 -│ │ ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #157 -│ │ │ ├─ [id]: integer #57 -│ │ │ └─ [name]: string #58 -│ │ └─ [where]: struct 'UserWhere' #140 -│ │ ├─ [id]: optional '_125__integer_filter_c?' #125 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [name]: optional '_126__string_filter_c?' #126 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [posts]: optional #139 -│ │ └─ item: union #138 -│ │ ├─ variant_0: struct #133 -│ │ │ └─ [every]: optional '_132_PostWhere__skip_61_UserWhere?' #132 -│ │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 -│ │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_128__string_filter_c?' #128 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_130_UserWhere?' #130 -│ │ │ └─ item: &UserWhere #129 -│ │ ├─ variant_1: struct #135 -│ │ │ └─ [some]: optional '_134_PostWhere__skip_61_UserWhere?' #134 -│ │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 -│ │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_128__string_filter_c?' #128 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_130_UserWhere?' #130 -│ │ │ └─ item: &UserWhere #129 -│ │ └─ variant_2: struct #137 -│ │ └─ [none]: optional '_136_PostWhere__skip_61_UserWhere?' #136 -│ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 -│ │ ├─ [id]: optional '_127__integer_filter_c?' #127 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [title]: optional '_128__string_filter_c?' #128 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [author]: optional '_130_UserWhere?' #130 -│ │ └─ item: &UserWhere #129 -│ └─ variant_3: struct #172 -│ └─ [update]: struct '_User_UpdateInput_excluding___rel_Post_User_1' #171 -│ ├─ [id]: optional #167 -│ │ └─ item: union #166 -│ │ ├─ variant_0: integer #57 -│ │ ├─ variant_1: struct #162 -│ │ │ └─ [set]: integer #57 -│ │ ├─ variant_2: struct #163 -│ │ │ └─ [multiply]: integer #57 -│ │ ├─ variant_3: struct #164 -│ │ │ └─ [decrement]: integer #57 -│ │ └─ variant_4: struct #165 -│ │ └─ [increment]: integer #57 -│ └─ [name]: optional #170 -│ └─ item: union #169 -│ ├─ variant_0: string #58 -│ └─ variant_1: struct #168 -│ └─ [set]: string #58 +│ └─ [title]: optional #156 +│ └─ item: union #155 +│ ├─ variant_0: string #63 +│ └─ variant_1: struct #154 +│ └─ [set]: string #63 └─ [where]: optional '_181_QueryPostWhereInput?' #181 └─ item: struct 'QueryPostWhereInput' #180 - ├─ [id]: optional '_79__integer_filter_c?' #79 - │ └─ item: optional '_integer_filter_c' #47 - │ └─ item: union #46 - │ ├─ variant_0: either '_integer_filter' #44 - │ │ ├─ variant_0: integer #36 - │ │ ├─ variant_1: struct #39 - │ │ │ └─ [equals]: integer #36 - │ │ ├─ variant_2: struct #40 - │ │ │ └─ [not]: integer #36 - │ │ ├─ variant_3: struct #41 - │ │ │ ├─ [lt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [gt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [lte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ [gte]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ variant_4: struct #42 - │ │ │ └─ [in]: list #38 - │ │ │ └─ item: integer #36 - │ │ └─ variant_5: struct #43 - │ │ └─ [notIn]: list #38 - │ │ └─ item: integer #36 - │ └─ variant_1: struct #45 - │ └─ [not]: either '_integer_filter' #44 - │ ├─ variant_0: integer #36 - │ ├─ variant_1: struct #39 - │ │ └─ [equals]: integer #36 - │ ├─ variant_2: struct #40 - │ │ └─ [not]: integer #36 - │ ├─ variant_3: struct #41 - │ │ ├─ [lt]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ [gt]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ [lte]: optional #37 - │ │ │ └─ item: integer #36 - │ │ └─ [gte]: optional #37 - │ │ └─ item: integer #36 - │ ├─ variant_4: struct #42 - │ │ └─ [in]: list #38 - │ │ └─ item: integer #36 - │ └─ variant_5: struct #43 - │ └─ [notIn]: list #38 - │ └─ item: integer #36 - ├─ [title]: optional '_80__string_filter_c?' #80 - │ └─ item: optional '_string_filter_c' #33 - │ └─ item: union #32 - │ ├─ variant_0: union '_string_filter' #30 - │ │ ├─ variant_0: string #18 - │ │ ├─ variant_1: struct #21 - │ │ │ └─ [equals]: string #18 - │ │ ├─ variant_2: struct #22 - │ │ │ └─ [not]: string #18 - │ │ ├─ variant_3: struct #23 - │ │ │ └─ [in]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_4: struct #24 - │ │ │ └─ [notIn]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_5: struct #27 - │ │ │ ├─ [contains]: string #18 - │ │ │ └─ [mode]: optional #26 - │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #28 - │ │ │ └─ [search]: string #18 - │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 - │ │ └─ item: string #18 - │ └─ variant_1: struct #31 - │ └─ [not]: union '_string_filter' #30 - │ ├─ variant_0: string #18 - │ ├─ variant_1: struct #21 - │ │ └─ [equals]: string #18 - │ ├─ variant_2: struct #22 - │ │ └─ [not]: string #18 - │ ├─ variant_3: struct #23 - │ │ └─ [in]: list #20 - │ │ └─ item: string #18 - │ ├─ variant_4: struct #24 - │ │ └─ [notIn]: list #20 - │ │ └─ item: string #18 - │ ├─ variant_5: struct #27 - │ │ ├─ [contains]: string #18 - │ │ └─ [mode]: optional #26 - │ │ └─ item: string #25 enum{ '"insensitive"' } - │ ├─ variant_6: struct #28 - │ │ └─ [search]: string #18 - │ └─ variant_7: struct #29 - │ ├─ [startsWith]: optional #19 - │ │ └─ item: string #18 - │ └─ [endsWith]: optional #19 - │ └─ item: string #18 + ├─ [AND]: optional '_178__177_QueryPostWhereInput[]?' #178 + │ └─ item: list '_177_QueryPostWhereInput[]' #177 + │ └─ item: &QueryPostWhereInput #176 + ├─ [NOT]: optional '_179_QueryPostWhereInput?' #179 + │ └─ item: &QueryPostWhereInput #176 + ├─ [OR]: optional '_178__177_QueryPostWhereInput[]?' #178 + │ └─ item: list '_177_QueryPostWhereInput[]' #177 + │ └─ item: &QueryPostWhereInput #176 ├─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 │ ├─ [id]: optional '_81__integer_filter_c?' #81 @@ -964,13 +876,13 @@ root: struct #182 │ │ │ ├─ variant_2: struct #40 │ │ │ │ └─ [not]: integer #36 │ │ │ ├─ variant_3: struct #41 - │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [lte]: optional #37 + │ │ │ │ ├─ [gte]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ [gte]: optional #37 + │ │ │ │ └─ [lte]: optional #37 │ │ │ │ └─ item: integer #36 │ │ │ ├─ variant_4: struct #42 │ │ │ │ └─ [in]: list #38 @@ -986,13 +898,13 @@ root: struct #182 │ │ ├─ variant_2: struct #40 │ │ │ └─ [not]: integer #36 │ │ ├─ variant_3: struct #41 - │ │ │ ├─ [lt]: optional #37 - │ │ │ │ └─ item: integer #36 │ │ │ ├─ [gt]: optional #37 │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [lte]: optional #37 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 │ │ │ │ └─ item: integer #36 - │ │ │ └─ [gte]: optional #37 + │ │ │ └─ [lte]: optional #37 │ │ │ └─ item: integer #36 │ │ ├─ variant_4: struct #42 │ │ │ └─ [in]: list #38 @@ -1022,9 +934,9 @@ root: struct #182 │ │ │ ├─ variant_6: struct #28 │ │ │ │ └─ [search]: string #18 │ │ │ └─ variant_7: struct #29 - │ │ │ ├─ [startsWith]: optional #19 + │ │ │ ├─ [endsWith]: optional #19 │ │ │ │ └─ item: string #18 - │ │ │ └─ [endsWith]: optional #19 + │ │ │ └─ [startsWith]: optional #19 │ │ │ └─ item: string #18 │ │ └─ variant_1: struct #31 │ │ └─ [not]: union '_string_filter' #30 @@ -1046,9 +958,9 @@ root: struct #182 │ │ ├─ variant_6: struct #28 │ │ │ └─ [search]: string #18 │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 + │ │ ├─ [endsWith]: optional #19 │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 + │ │ └─ [startsWith]: optional #19 │ │ └─ item: string #18 │ └─ [posts]: optional #91 │ └─ item: union #90 @@ -1061,12 +973,100 @@ root: struct #182 │ └─ variant_2: struct #89 │ └─ [none]: optional '_88_PostWhere?' #88 │ └─ item: &PostWhere #83 - ├─ [AND]: optional '_178__177_QueryPostWhereInput[]?' #178 - │ └─ item: list '_177_QueryPostWhereInput[]' #177 - │ └─ item: &QueryPostWhereInput #176 - ├─ [OR]: optional '_178__177_QueryPostWhereInput[]?' #178 - │ └─ item: list '_177_QueryPostWhereInput[]' #177 - │ └─ item: &QueryPostWhereInput #176 - └─ [NOT]: optional '_179_QueryPostWhereInput?' #179 - └─ item: &QueryPostWhereInput #176 + ├─ [id]: optional '_79__integer_filter_c?' #79 + │ └─ item: optional '_integer_filter_c' #47 + │ └─ item: union #46 + │ ├─ variant_0: either '_integer_filter' #44 + │ │ ├─ variant_0: integer #36 + │ │ ├─ variant_1: struct #39 + │ │ │ └─ [equals]: integer #36 + │ │ ├─ variant_2: struct #40 + │ │ │ └─ [not]: integer #36 + │ │ ├─ variant_3: struct #41 + │ │ │ ├─ [gt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ variant_4: struct #42 + │ │ │ └─ [in]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_5: struct #43 + │ │ └─ [notIn]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_1: struct #45 + │ └─ [not]: either '_integer_filter' #44 + │ ├─ variant_0: integer #36 + │ ├─ variant_1: struct #39 + │ │ └─ [equals]: integer #36 + │ ├─ variant_2: struct #40 + │ │ └─ [not]: integer #36 + │ ├─ variant_3: struct #41 + │ │ ├─ [gt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [gte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [lt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ └─ [lte]: optional #37 + │ │ └─ item: integer #36 + │ ├─ variant_4: struct #42 + │ │ └─ [in]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_5: struct #43 + │ └─ [notIn]: list #38 + │ └─ item: integer #36 + └─ [title]: optional '_80__string_filter_c?' #80 + └─ item: optional '_string_filter_c' #33 + └─ item: union #32 + ├─ variant_0: union '_string_filter' #30 + │ ├─ variant_0: string #18 + │ ├─ variant_1: struct #21 + │ │ └─ [equals]: string #18 + │ ├─ variant_2: struct #22 + │ │ └─ [not]: string #18 + │ ├─ variant_3: struct #23 + │ │ └─ [in]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_4: struct #24 + │ │ └─ [notIn]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_5: struct #27 + │ │ ├─ [contains]: string #18 + │ │ └─ [mode]: optional #26 + │ │ └─ item: string #25 enum{ '"insensitive"' } + │ ├─ variant_6: struct #28 + │ │ └─ [search]: string #18 + │ └─ variant_7: struct #29 + │ ├─ [endsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ [startsWith]: optional #19 + │ └─ item: string #18 + └─ variant_1: struct #31 + └─ [not]: union '_string_filter' #30 + ├─ variant_0: string #18 + ├─ variant_1: struct #21 + │ └─ [equals]: string #18 + ├─ variant_2: struct #22 + │ └─ [not]: string #18 + ├─ variant_3: struct #23 + │ └─ [in]: list #20 + │ └─ item: string #18 + ├─ variant_4: struct #24 + │ └─ [notIn]: list #20 + │ └─ item: string #18 + ├─ variant_5: struct #27 + │ ├─ [contains]: string #18 + │ └─ [mode]: optional #26 + │ └─ item: string #25 enum{ '"insensitive"' } + ├─ variant_6: struct #28 + │ └─ [search]: string #18 + └─ variant_7: struct #29 + ├─ [endsWith]: optional #19 + │ └─ item: string #18 + └─ [startsWith]: optional #19 + └─ item: string #18 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many Record inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many Record inp.snap index e2e97bc93..73375c088 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many Record inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many Record inp.snap @@ -1,34 +1,88 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #56 ├─ [data]: struct '_Record_UpdateInput' #17 +│ ├─ [age]: optional #16 +│ │ └─ item: union #15 +│ │ ├─ variant_0: optional #3 +│ │ │ └─ item: integer #2 +│ │ ├─ variant_1: struct #11 +│ │ │ └─ [set]: optional #3 +│ │ │ └─ item: integer #2 +│ │ ├─ variant_2: struct #12 +│ │ │ └─ [multiply]: integer #2 +│ │ ├─ variant_3: struct #13 +│ │ │ └─ [decrement]: integer #2 +│ │ └─ variant_4: struct #14 +│ │ └─ [increment]: integer #2 │ ├─ [id]: optional #7 │ │ └─ item: union #6 │ │ ├─ variant_0: string #0 │ │ └─ variant_1: struct #5 │ │ └─ [set]: string #0 -│ ├─ [name]: optional #10 -│ │ └─ item: union #9 -│ │ ├─ variant_0: string #1 -│ │ └─ variant_1: struct #8 -│ │ └─ [set]: string #1 -│ └─ [age]: optional #16 -│ └─ item: union #15 -│ ├─ variant_0: optional #3 -│ │ └─ item: integer #2 -│ ├─ variant_1: struct #11 -│ │ └─ [set]: optional #3 -│ │ └─ item: integer #2 -│ ├─ variant_2: struct #12 -│ │ └─ [multiply]: integer #2 -│ ├─ variant_3: struct #13 -│ │ └─ [decrement]: integer #2 -│ └─ variant_4: struct #14 -│ └─ [increment]: integer #2 +│ └─ [name]: optional #10 +│ └─ item: union #9 +│ ├─ variant_0: string #1 +│ └─ variant_1: struct #8 +│ └─ [set]: string #1 └─ [where]: optional '_55_QueryRecordWhereInput?' #55 └─ item: struct 'QueryRecordWhereInput' #54 + ├─ [AND]: optional '_52__51_QueryRecordWhereInput[]?' #52 + │ └─ item: list '_51_QueryRecordWhereInput[]' #51 + │ └─ item: &QueryRecordWhereInput #50 + ├─ [NOT]: optional '_53_QueryRecordWhereInput?' #53 + │ └─ item: &QueryRecordWhereInput #50 + ├─ [OR]: optional '_52__51_QueryRecordWhereInput[]?' #52 + │ └─ item: list '_51_QueryRecordWhereInput[]' #51 + │ └─ item: &QueryRecordWhereInput #50 + ├─ [age]: optional '_48__integer_filter_c?' #48 + │ └─ item: optional '_integer_filter_c' #47 + │ └─ item: union #46 + │ ├─ variant_0: either '_integer_filter' #44 + │ │ ├─ variant_0: integer #36 + │ │ ├─ variant_1: struct #39 + │ │ │ └─ [equals]: integer #36 + │ │ ├─ variant_2: struct #40 + │ │ │ └─ [not]: integer #36 + │ │ ├─ variant_3: struct #41 + │ │ │ ├─ [gt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ variant_4: struct #42 + │ │ │ └─ [in]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_5: struct #43 + │ │ └─ [notIn]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_1: struct #45 + │ └─ [not]: either '_integer_filter' #44 + │ ├─ variant_0: integer #36 + │ ├─ variant_1: struct #39 + │ │ └─ [equals]: integer #36 + │ ├─ variant_2: struct #40 + │ │ └─ [not]: integer #36 + │ ├─ variant_3: struct #41 + │ │ ├─ [gt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [gte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [lt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ └─ [lte]: optional #37 + │ │ └─ item: integer #36 + │ ├─ variant_4: struct #42 + │ │ └─ [in]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_5: struct #43 + │ └─ [notIn]: list #38 + │ └─ item: integer #36 ├─ [id]: optional '_34__string_filter_c?' #34 │ └─ item: optional '_string_filter_c' #33 │ └─ item: union #32 @@ -51,9 +105,9 @@ root: struct #56 │ │ ├─ variant_6: struct #28 │ │ │ └─ [search]: string #18 │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 + │ │ ├─ [endsWith]: optional #19 │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 + │ │ └─ [startsWith]: optional #19 │ │ └─ item: string #18 │ └─ variant_1: struct #31 │ └─ [not]: union '_string_filter' #30 @@ -75,112 +129,58 @@ root: struct #56 │ ├─ variant_6: struct #28 │ │ └─ [search]: string #18 │ └─ variant_7: struct #29 - │ ├─ [startsWith]: optional #19 + │ ├─ [endsWith]: optional #19 │ │ └─ item: string #18 - │ └─ [endsWith]: optional #19 + │ └─ [startsWith]: optional #19 │ └─ item: string #18 - ├─ [name]: optional '_35__string_filter_c?' #35 - │ └─ item: optional '_string_filter_c' #33 - │ └─ item: union #32 - │ ├─ variant_0: union '_string_filter' #30 - │ │ ├─ variant_0: string #18 - │ │ ├─ variant_1: struct #21 - │ │ │ └─ [equals]: string #18 - │ │ ├─ variant_2: struct #22 - │ │ │ └─ [not]: string #18 - │ │ ├─ variant_3: struct #23 - │ │ │ └─ [in]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_4: struct #24 - │ │ │ └─ [notIn]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_5: struct #27 - │ │ │ ├─ [contains]: string #18 - │ │ │ └─ [mode]: optional #26 - │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #28 - │ │ │ └─ [search]: string #18 - │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 - │ │ └─ item: string #18 - │ └─ variant_1: struct #31 - │ └─ [not]: union '_string_filter' #30 - │ ├─ variant_0: string #18 - │ ├─ variant_1: struct #21 - │ │ └─ [equals]: string #18 - │ ├─ variant_2: struct #22 - │ │ └─ [not]: string #18 - │ ├─ variant_3: struct #23 - │ │ └─ [in]: list #20 - │ │ └─ item: string #18 - │ ├─ variant_4: struct #24 - │ │ └─ [notIn]: list #20 - │ │ └─ item: string #18 - │ ├─ variant_5: struct #27 - │ │ ├─ [contains]: string #18 - │ │ └─ [mode]: optional #26 - │ │ └─ item: string #25 enum{ '"insensitive"' } - │ ├─ variant_6: struct #28 - │ │ └─ [search]: string #18 - │ └─ variant_7: struct #29 - │ ├─ [startsWith]: optional #19 - │ │ └─ item: string #18 - │ └─ [endsWith]: optional #19 - │ └─ item: string #18 - ├─ [age]: optional '_48__integer_filter_c?' #48 - │ └─ item: optional '_integer_filter_c' #47 - │ └─ item: union #46 - │ ├─ variant_0: either '_integer_filter' #44 - │ │ ├─ variant_0: integer #36 - │ │ ├─ variant_1: struct #39 - │ │ │ └─ [equals]: integer #36 - │ │ ├─ variant_2: struct #40 - │ │ │ └─ [not]: integer #36 - │ │ ├─ variant_3: struct #41 - │ │ │ ├─ [lt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [gt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [lte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ [gte]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ variant_4: struct #42 - │ │ │ └─ [in]: list #38 - │ │ │ └─ item: integer #36 - │ │ └─ variant_5: struct #43 - │ │ └─ [notIn]: list #38 - │ │ └─ item: integer #36 - │ └─ variant_1: struct #45 - │ └─ [not]: either '_integer_filter' #44 - │ ├─ variant_0: integer #36 - │ ├─ variant_1: struct #39 - │ │ └─ [equals]: integer #36 - │ ├─ variant_2: struct #40 - │ │ └─ [not]: integer #36 - │ ├─ variant_3: struct #41 - │ │ ├─ [lt]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ [gt]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ [lte]: optional #37 - │ │ │ └─ item: integer #36 - │ │ └─ [gte]: optional #37 - │ │ └─ item: integer #36 - │ ├─ variant_4: struct #42 - │ │ └─ [in]: list #38 - │ │ └─ item: integer #36 - │ └─ variant_5: struct #43 - │ └─ [notIn]: list #38 - │ └─ item: integer #36 - ├─ [AND]: optional '_52__51_QueryRecordWhereInput[]?' #52 - │ └─ item: list '_51_QueryRecordWhereInput[]' #51 - │ └─ item: &QueryRecordWhereInput #50 - ├─ [OR]: optional '_52__51_QueryRecordWhereInput[]?' #52 - │ └─ item: list '_51_QueryRecordWhereInput[]' #51 - │ └─ item: &QueryRecordWhereInput #50 - └─ [NOT]: optional '_53_QueryRecordWhereInput?' #53 - └─ item: &QueryRecordWhereInput #50 + └─ [name]: optional '_35__string_filter_c?' #35 + └─ item: optional '_string_filter_c' #33 + └─ item: union #32 + ├─ variant_0: union '_string_filter' #30 + │ ├─ variant_0: string #18 + │ ├─ variant_1: struct #21 + │ │ └─ [equals]: string #18 + │ ├─ variant_2: struct #22 + │ │ └─ [not]: string #18 + │ ├─ variant_3: struct #23 + │ │ └─ [in]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_4: struct #24 + │ │ └─ [notIn]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_5: struct #27 + │ │ ├─ [contains]: string #18 + │ │ └─ [mode]: optional #26 + │ │ └─ item: string #25 enum{ '"insensitive"' } + │ ├─ variant_6: struct #28 + │ │ └─ [search]: string #18 + │ └─ variant_7: struct #29 + │ ├─ [endsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ [startsWith]: optional #19 + │ └─ item: string #18 + └─ variant_1: struct #31 + └─ [not]: union '_string_filter' #30 + ├─ variant_0: string #18 + ├─ variant_1: struct #21 + │ └─ [equals]: string #18 + ├─ variant_2: struct #22 + │ └─ [not]: string #18 + ├─ variant_3: struct #23 + │ └─ [in]: list #20 + │ └─ item: string #18 + ├─ variant_4: struct #24 + │ └─ [notIn]: list #20 + │ └─ item: string #18 + ├─ variant_5: struct #27 + │ ├─ [contains]: string #18 + │ └─ [mode]: optional #26 + │ └─ item: string #25 enum{ '"insensitive"' } + ├─ variant_6: struct #28 + │ └─ [search]: string #18 + └─ variant_7: struct #29 + ├─ [endsWith]: optional #19 + │ └─ item: string #18 + └─ [startsWith]: optional #19 + └─ item: string #18 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many User inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many User inp.snap index 23a5ccd41..2cc224c4c 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many User inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_many User inp.snap @@ -1,6 +1,6 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #147 ├─ [data]: struct '_User_UpdateInput' #124 @@ -36,6 +36,115 @@ root: struct #147 │ ├─ variant_1: struct #99 │ │ └─ [connect]: union #96 │ │ ├─ variant_0: struct 'PostWhere' #94 +│ │ │ ├─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 +│ │ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 +│ │ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 +│ │ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ │ └─ item: union #32 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ variant_1: struct #31 +│ │ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [posts]: optional #91 +│ │ │ │ └─ item: union #90 +│ │ │ │ ├─ variant_0: struct #85 +│ │ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 +│ │ │ │ │ └─ item: &PostWhere #83 +│ │ │ │ ├─ variant_1: struct #87 +│ │ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 +│ │ │ │ │ └─ item: &PostWhere #83 +│ │ │ │ └─ variant_2: struct #89 +│ │ │ │ └─ [none]: optional '_88_PostWhere?' #88 +│ │ │ │ └─ item: &PostWhere #83 │ │ │ ├─ [id]: optional '_79__integer_filter_c?' #79 │ │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ │ └─ item: union #46 @@ -46,13 +155,13 @@ root: struct #147 │ │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ │ └─ [in]: list #38 @@ -68,13 +177,13 @@ root: struct #147 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -82,167 +191,167 @@ root: struct #147 │ │ │ │ └─ variant_5: struct #43 │ │ │ │ └─ [notIn]: list #38 │ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_80__string_filter_c?' #80 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 -│ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 -│ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [posts]: optional #91 -│ │ │ └─ item: union #90 -│ │ │ ├─ variant_0: struct #85 -│ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 -│ │ │ │ └─ item: &PostWhere #83 -│ │ │ ├─ variant_1: struct #87 -│ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 -│ │ │ │ └─ item: &PostWhere #83 -│ │ │ └─ variant_2: struct #89 -│ │ │ └─ [none]: optional '_88_PostWhere?' #88 -│ │ │ └─ item: &PostWhere #83 +│ │ │ └─ [title]: optional '_80__string_filter_c?' #80 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 │ │ └─ variant_1: list '_95_PostWhere[]' #95 │ │ └─ item: struct 'PostWhere' #94 +│ │ ├─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 +│ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 +│ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #91 +│ │ │ └─ item: union #90 +│ │ │ ├─ variant_0: struct #85 +│ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 +│ │ │ │ └─ item: &PostWhere #83 +│ │ │ ├─ variant_1: struct #87 +│ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 +│ │ │ │ └─ item: &PostWhere #83 +│ │ │ └─ variant_2: struct #89 +│ │ │ └─ [none]: optional '_88_PostWhere?' #88 +│ │ │ └─ item: &PostWhere #83 │ │ ├─ [id]: optional '_79__integer_filter_c?' #79 │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ └─ item: union #46 @@ -253,13 +362,13 @@ root: struct #147 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -275,13 +384,13 @@ root: struct #147 │ │ │ ├─ variant_2: struct #40 │ │ │ │ └─ [not]: integer #36 │ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 +│ │ │ │ └─ [lte]: optional #37 │ │ │ │ └─ item: integer #36 │ │ │ ├─ variant_4: struct #42 │ │ │ │ └─ [in]: list #38 @@ -289,165 +398,56 @@ root: struct #147 │ │ │ └─ variant_5: struct #43 │ │ │ └─ [notIn]: list #38 │ │ │ └─ item: integer #36 -│ │ ├─ [title]: optional '_80__string_filter_c?' #80 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 -│ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 -│ │ ├─ [id]: optional '_81__integer_filter_c?' #81 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [name]: optional '_82__string_filter_c?' #82 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [posts]: optional #91 -│ │ └─ item: union #90 -│ │ ├─ variant_0: struct #85 -│ │ │ └─ [every]: optional '_84_PostWhere?' #84 -│ │ │ └─ item: &PostWhere #83 -│ │ ├─ variant_1: struct #87 -│ │ │ └─ [some]: optional '_86_PostWhere?' #86 -│ │ │ └─ item: &PostWhere #83 -│ │ └─ variant_2: struct #89 -│ │ └─ [none]: optional '_88_PostWhere?' #88 -│ │ └─ item: &PostWhere #83 +│ │ └─ [title]: optional '_80__string_filter_c?' #80 +│ │ └─ item: optional '_string_filter_c' #33 +│ │ └─ item: union #32 +│ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_1: struct #31 +│ │ └─ [not]: union '_string_filter' #30 +│ │ ├─ variant_0: string #18 +│ │ ├─ variant_1: struct #21 +│ │ │ └─ [equals]: string #18 +│ │ ├─ variant_2: struct #22 +│ │ │ └─ [not]: string #18 +│ │ ├─ variant_3: struct #23 +│ │ │ └─ [in]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_4: struct #24 +│ │ │ └─ [notIn]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_5: struct #27 +│ │ │ ├─ [contains]: string #18 +│ │ │ └─ [mode]: optional #26 +│ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #28 +│ │ │ └─ [search]: string #18 +│ │ └─ variant_7: struct #29 +│ │ ├─ [endsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ [startsWith]: optional #19 +│ │ └─ item: string #18 │ ├─ variant_2: struct #100 │ │ └─ [connectOrCreate]: struct #97 │ │ ├─ [create]: union #78 @@ -462,6 +462,115 @@ root: struct #147 │ │ │ └─ [title]: string #63 │ │ └─ [where]: union #96 │ │ ├─ variant_0: struct 'PostWhere' #94 +│ │ │ ├─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 +│ │ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 +│ │ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 +│ │ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ │ └─ item: union #32 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ variant_1: struct #31 +│ │ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [posts]: optional #91 +│ │ │ │ └─ item: union #90 +│ │ │ │ ├─ variant_0: struct #85 +│ │ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 +│ │ │ │ │ └─ item: &PostWhere #83 +│ │ │ │ ├─ variant_1: struct #87 +│ │ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 +│ │ │ │ │ └─ item: &PostWhere #83 +│ │ │ │ └─ variant_2: struct #89 +│ │ │ │ └─ [none]: optional '_88_PostWhere?' #88 +│ │ │ │ └─ item: &PostWhere #83 │ │ │ ├─ [id]: optional '_79__integer_filter_c?' #79 │ │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ │ └─ item: union #46 @@ -472,13 +581,13 @@ root: struct #147 │ │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ │ └─ [in]: list #38 @@ -494,13 +603,13 @@ root: struct #147 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -508,167 +617,167 @@ root: struct #147 │ │ │ │ └─ variant_5: struct #43 │ │ │ │ └─ [notIn]: list #38 │ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_80__string_filter_c?' #80 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 -│ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 -│ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [posts]: optional #91 -│ │ │ └─ item: union #90 -│ │ │ ├─ variant_0: struct #85 -│ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 -│ │ │ │ └─ item: &PostWhere #83 -│ │ │ ├─ variant_1: struct #87 -│ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 -│ │ │ │ └─ item: &PostWhere #83 -│ │ │ └─ variant_2: struct #89 -│ │ │ └─ [none]: optional '_88_PostWhere?' #88 -│ │ │ └─ item: &PostWhere #83 +│ │ │ └─ [title]: optional '_80__string_filter_c?' #80 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 │ │ └─ variant_1: list '_95_PostWhere[]' #95 │ │ └─ item: struct 'PostWhere' #94 +│ │ ├─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 +│ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 +│ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #91 +│ │ │ └─ item: union #90 +│ │ │ ├─ variant_0: struct #85 +│ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 +│ │ │ │ └─ item: &PostWhere #83 +│ │ │ ├─ variant_1: struct #87 +│ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 +│ │ │ │ └─ item: &PostWhere #83 +│ │ │ └─ variant_2: struct #89 +│ │ │ └─ [none]: optional '_88_PostWhere?' #88 +│ │ │ └─ item: &PostWhere #83 │ │ ├─ [id]: optional '_79__integer_filter_c?' #79 │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ └─ item: union #46 @@ -679,13 +788,13 @@ root: struct #147 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -701,13 +810,13 @@ root: struct #147 │ │ │ ├─ variant_2: struct #40 │ │ │ │ └─ [not]: integer #36 │ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 +│ │ │ │ └─ [lte]: optional #37 │ │ │ │ └─ item: integer #36 │ │ │ ├─ variant_4: struct #42 │ │ │ │ └─ [in]: list #38 @@ -715,165 +824,56 @@ root: struct #147 │ │ │ └─ variant_5: struct #43 │ │ │ └─ [notIn]: list #38 │ │ │ └─ item: integer #36 -│ │ ├─ [title]: optional '_80__string_filter_c?' #80 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 -│ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 -│ │ ├─ [id]: optional '_81__integer_filter_c?' #81 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [name]: optional '_82__string_filter_c?' #82 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [posts]: optional #91 -│ │ └─ item: union #90 -│ │ ├─ variant_0: struct #85 -│ │ │ └─ [every]: optional '_84_PostWhere?' #84 -│ │ │ └─ item: &PostWhere #83 -│ │ ├─ variant_1: struct #87 -│ │ │ └─ [some]: optional '_86_PostWhere?' #86 -│ │ │ └─ item: &PostWhere #83 -│ │ └─ variant_2: struct #89 -│ │ └─ [none]: optional '_88_PostWhere?' #88 -│ │ └─ item: &PostWhere #83 +│ │ └─ [title]: optional '_80__string_filter_c?' #80 +│ │ └─ item: optional '_string_filter_c' #33 +│ │ └─ item: union #32 +│ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_1: struct #31 +│ │ └─ [not]: union '_string_filter' #30 +│ │ ├─ variant_0: string #18 +│ │ ├─ variant_1: struct #21 +│ │ │ └─ [equals]: string #18 +│ │ ├─ variant_2: struct #22 +│ │ │ └─ [not]: string #18 +│ │ ├─ variant_3: struct #23 +│ │ │ └─ [in]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_4: struct #24 +│ │ │ └─ [notIn]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_5: struct #27 +│ │ │ ├─ [contains]: string #18 +│ │ │ └─ [mode]: optional #26 +│ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #28 +│ │ │ └─ [search]: string #18 +│ │ └─ variant_7: struct #29 +│ │ ├─ [endsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ [startsWith]: optional #19 +│ │ └─ item: string #18 │ ├─ variant_3: struct #111 │ │ └─ [update]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #110 │ │ ├─ [id]: optional #106 @@ -894,443 +894,552 @@ root: struct #147 │ │ └─ [set]: string #63 │ ├─ variant_4: struct #114 │ │ └─ [updateMany]: struct #113 -│ │ ├─ [where]: optional #112 -│ │ │ └─ item: union #96 -│ │ │ ├─ variant_0: struct 'PostWhere' #94 -│ │ │ │ ├─ [id]: optional '_79__integer_filter_c?' #79 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ │ └─ item: union #46 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_1: struct #45 -│ │ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [title]: optional '_80__string_filter_c?' #80 -│ │ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ │ └─ item: union #32 -│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ variant_1: struct #31 -│ │ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 -│ │ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 -│ │ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ │ └─ item: union #46 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_1: struct #45 -│ │ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 -│ │ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ │ └─ item: union #32 -│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ variant_1: struct #31 -│ │ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [posts]: optional #91 -│ │ │ │ └─ item: union #90 -│ │ │ │ ├─ variant_0: struct #85 -│ │ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 -│ │ │ │ │ └─ item: &PostWhere #83 -│ │ │ │ ├─ variant_1: struct #87 -│ │ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 -│ │ │ │ │ └─ item: &PostWhere #83 -│ │ │ │ └─ variant_2: struct #89 -│ │ │ │ └─ [none]: optional '_88_PostWhere?' #88 -│ │ │ │ └─ item: &PostWhere #83 -│ │ │ └─ variant_1: list '_95_PostWhere[]' #95 -│ │ │ └─ item: struct 'PostWhere' #94 -│ │ │ ├─ [id]: optional '_79__integer_filter_c?' #79 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_80__string_filter_c?' #80 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 -│ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 -│ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [posts]: optional #91 -│ │ │ └─ item: union #90 -│ │ │ ├─ variant_0: struct #85 -│ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 -│ │ │ │ └─ item: &PostWhere #83 -│ │ │ ├─ variant_1: struct #87 -│ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 -│ │ │ │ └─ item: &PostWhere #83 -│ │ │ └─ variant_2: struct #89 -│ │ │ └─ [none]: optional '_88_PostWhere?' #88 -│ │ │ └─ item: &PostWhere #83 -│ │ └─ [data]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #110 -│ │ ├─ [id]: optional #106 -│ │ │ └─ item: union #105 -│ │ │ ├─ variant_0: integer #62 -│ │ │ ├─ variant_1: struct #101 -│ │ │ │ └─ [set]: integer #62 -│ │ │ ├─ variant_2: struct #102 -│ │ │ │ └─ [multiply]: integer #62 -│ │ │ ├─ variant_3: struct #103 -│ │ │ │ └─ [decrement]: integer #62 -│ │ │ └─ variant_4: struct #104 -│ │ │ └─ [increment]: integer #62 -│ │ └─ [title]: optional #109 -│ │ └─ item: union #108 -│ │ ├─ variant_0: string #63 -│ │ └─ variant_1: struct #107 -│ │ └─ [set]: string #63 +│ │ ├─ [data]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #110 +│ │ │ ├─ [id]: optional #106 +│ │ │ │ └─ item: union #105 +│ │ │ │ ├─ variant_0: integer #62 +│ │ │ │ ├─ variant_1: struct #101 +│ │ │ │ │ └─ [set]: integer #62 +│ │ │ │ ├─ variant_2: struct #102 +│ │ │ │ │ └─ [multiply]: integer #62 +│ │ │ │ ├─ variant_3: struct #103 +│ │ │ │ │ └─ [decrement]: integer #62 +│ │ │ │ └─ variant_4: struct #104 +│ │ │ │ └─ [increment]: integer #62 +│ │ │ └─ [title]: optional #109 +│ │ │ └─ item: union #108 +│ │ │ ├─ variant_0: string #63 +│ │ │ └─ variant_1: struct #107 +│ │ │ └─ [set]: string #63 +│ │ └─ [where]: optional #112 +│ │ └─ item: union #96 +│ │ ├─ variant_0: struct 'PostWhere' #94 +│ │ │ ├─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 +│ │ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 +│ │ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 +│ │ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ │ └─ item: union #32 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ variant_1: struct #31 +│ │ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [posts]: optional #91 +│ │ │ │ └─ item: union #90 +│ │ │ │ ├─ variant_0: struct #85 +│ │ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 +│ │ │ │ │ └─ item: &PostWhere #83 +│ │ │ │ ├─ variant_1: struct #87 +│ │ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 +│ │ │ │ │ └─ item: &PostWhere #83 +│ │ │ │ └─ variant_2: struct #89 +│ │ │ │ └─ [none]: optional '_88_PostWhere?' #88 +│ │ │ │ └─ item: &PostWhere #83 +│ │ │ ├─ [id]: optional '_79__integer_filter_c?' #79 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ └─ [title]: optional '_80__string_filter_c?' #80 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_1: list '_95_PostWhere[]' #95 +│ │ └─ item: struct 'PostWhere' #94 +│ │ ├─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 +│ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 +│ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #91 +│ │ │ └─ item: union #90 +│ │ │ ├─ variant_0: struct #85 +│ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 +│ │ │ │ └─ item: &PostWhere #83 +│ │ │ ├─ variant_1: struct #87 +│ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 +│ │ │ │ └─ item: &PostWhere #83 +│ │ │ └─ variant_2: struct #89 +│ │ │ └─ [none]: optional '_88_PostWhere?' #88 +│ │ │ └─ item: &PostWhere #83 +│ │ ├─ [id]: optional '_79__integer_filter_c?' #79 +│ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ └─ item: union #46 +│ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ └─ variant_1: struct #45 +│ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ ├─ variant_0: integer #36 +│ │ │ ├─ variant_1: struct #39 +│ │ │ │ └─ [equals]: integer #36 +│ │ │ ├─ variant_2: struct #40 +│ │ │ │ └─ [not]: integer #36 +│ │ │ ├─ variant_3: struct #41 +│ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ [lte]: optional #37 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ variant_4: struct #42 +│ │ │ │ └─ [in]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ └─ variant_5: struct #43 +│ │ │ └─ [notIn]: list #38 +│ │ │ └─ item: integer #36 +│ │ └─ [title]: optional '_80__string_filter_c?' #80 +│ │ └─ item: optional '_string_filter_c' #33 +│ │ └─ item: union #32 +│ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_1: struct #31 +│ │ └─ [not]: union '_string_filter' #30 +│ │ ├─ variant_0: string #18 +│ │ ├─ variant_1: struct #21 +│ │ │ └─ [equals]: string #18 +│ │ ├─ variant_2: struct #22 +│ │ │ └─ [not]: string #18 +│ │ ├─ variant_3: struct #23 +│ │ │ └─ [in]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_4: struct #24 +│ │ │ └─ [notIn]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_5: struct #27 +│ │ │ ├─ [contains]: string #18 +│ │ │ └─ [mode]: optional #26 +│ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #28 +│ │ │ └─ [search]: string #18 +│ │ └─ variant_7: struct #29 +│ │ ├─ [endsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ [startsWith]: optional #19 +│ │ └─ item: string #18 │ ├─ variant_5: struct #117 │ │ └─ [deleteMany]: struct #116 │ │ └─ [where]: optional #115 │ │ └─ item: union #96 │ │ ├─ variant_0: struct 'PostWhere' #94 +│ │ │ ├─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 +│ │ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 +│ │ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 +│ │ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ │ └─ item: union #32 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ variant_1: struct #31 +│ │ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [posts]: optional #91 +│ │ │ │ └─ item: union #90 +│ │ │ │ ├─ variant_0: struct #85 +│ │ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 +│ │ │ │ │ └─ item: &PostWhere #83 +│ │ │ │ ├─ variant_1: struct #87 +│ │ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 +│ │ │ │ │ └─ item: &PostWhere #83 +│ │ │ │ └─ variant_2: struct #89 +│ │ │ │ └─ [none]: optional '_88_PostWhere?' #88 +│ │ │ │ └─ item: &PostWhere #83 │ │ │ ├─ [id]: optional '_79__integer_filter_c?' #79 │ │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ │ └─ item: union #46 @@ -1341,13 +1450,13 @@ root: struct #147 │ │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ │ └─ [in]: list #38 @@ -1363,13 +1472,13 @@ root: struct #147 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -1377,167 +1486,167 @@ root: struct #147 │ │ │ │ └─ variant_5: struct #43 │ │ │ │ └─ [notIn]: list #38 │ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_80__string_filter_c?' #80 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 -│ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 -│ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [posts]: optional #91 -│ │ │ └─ item: union #90 -│ │ │ ├─ variant_0: struct #85 -│ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 -│ │ │ │ └─ item: &PostWhere #83 -│ │ │ ├─ variant_1: struct #87 -│ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 -│ │ │ │ └─ item: &PostWhere #83 -│ │ │ └─ variant_2: struct #89 -│ │ │ └─ [none]: optional '_88_PostWhere?' #88 -│ │ │ └─ item: &PostWhere #83 +│ │ │ └─ [title]: optional '_80__string_filter_c?' #80 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 │ │ └─ variant_1: list '_95_PostWhere[]' #95 │ │ └─ item: struct 'PostWhere' #94 +│ │ ├─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 +│ │ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 +│ │ │ ├─ [id]: optional '_81__integer_filter_c?' #81 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_82__string_filter_c?' #82 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #91 +│ │ │ └─ item: union #90 +│ │ │ ├─ variant_0: struct #85 +│ │ │ │ └─ [every]: optional '_84_PostWhere?' #84 +│ │ │ │ └─ item: &PostWhere #83 +│ │ │ ├─ variant_1: struct #87 +│ │ │ │ └─ [some]: optional '_86_PostWhere?' #86 +│ │ │ │ └─ item: &PostWhere #83 +│ │ │ └─ variant_2: struct #89 +│ │ │ └─ [none]: optional '_88_PostWhere?' #88 +│ │ │ └─ item: &PostWhere #83 │ │ ├─ [id]: optional '_79__integer_filter_c?' #79 │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ └─ item: union #46 @@ -1548,13 +1657,13 @@ root: struct #147 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -1570,13 +1679,13 @@ root: struct #147 │ │ │ ├─ variant_2: struct #40 │ │ │ │ └─ [not]: integer #36 │ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 +│ │ │ │ └─ [lte]: optional #37 │ │ │ │ └─ item: integer #36 │ │ │ ├─ variant_4: struct #42 │ │ │ │ └─ [in]: list #38 @@ -1584,165 +1693,56 @@ root: struct #147 │ │ │ └─ variant_5: struct #43 │ │ │ └─ [notIn]: list #38 │ │ │ └─ item: integer #36 -│ │ ├─ [title]: optional '_80__string_filter_c?' #80 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [author]: optional '_93_UserWhere__skip_65_PostWhere?' #93 -│ │ └─ item: struct 'UserWhere__skip_65_PostWhere' #92 -│ │ ├─ [id]: optional '_81__integer_filter_c?' #81 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [name]: optional '_82__string_filter_c?' #82 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [posts]: optional #91 -│ │ └─ item: union #90 -│ │ ├─ variant_0: struct #85 -│ │ │ └─ [every]: optional '_84_PostWhere?' #84 -│ │ │ └─ item: &PostWhere #83 -│ │ ├─ variant_1: struct #87 -│ │ │ └─ [some]: optional '_86_PostWhere?' #86 -│ │ │ └─ item: &PostWhere #83 -│ │ └─ variant_2: struct #89 -│ │ └─ [none]: optional '_88_PostWhere?' #88 -│ │ └─ item: &PostWhere #83 +│ │ └─ [title]: optional '_80__string_filter_c?' #80 +│ │ └─ item: optional '_string_filter_c' #33 +│ │ └─ item: union #32 +│ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_1: struct #31 +│ │ └─ [not]: union '_string_filter' #30 +│ │ ├─ variant_0: string #18 +│ │ ├─ variant_1: struct #21 +│ │ │ └─ [equals]: string #18 +│ │ ├─ variant_2: struct #22 +│ │ │ └─ [not]: string #18 +│ │ ├─ variant_3: struct #23 +│ │ │ └─ [in]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_4: struct #24 +│ │ │ └─ [notIn]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_5: struct #27 +│ │ │ ├─ [contains]: string #18 +│ │ │ └─ [mode]: optional #26 +│ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #28 +│ │ │ └─ [search]: string #18 +│ │ └─ variant_7: struct #29 +│ │ ├─ [endsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ [startsWith]: optional #19 +│ │ └─ item: string #18 │ └─ variant_6: struct #121 │ └─ [createMany]: optional #120 │ └─ item: struct #119 @@ -1759,6 +1759,14 @@ root: struct #147 │ └─ [title]: string #63 └─ [where]: optional '_146_QueryUserWhereInput?' #146 └─ item: struct 'QueryUserWhereInput' #145 + ├─ [AND]: optional '_143__142_QueryUserWhereInput[]?' #143 + │ └─ item: list '_142_QueryUserWhereInput[]' #142 + │ └─ item: &QueryUserWhereInput #141 + ├─ [NOT]: optional '_144_QueryUserWhereInput?' #144 + │ └─ item: &QueryUserWhereInput #141 + ├─ [OR]: optional '_143__142_QueryUserWhereInput[]?' #143 + │ └─ item: list '_142_QueryUserWhereInput[]' #142 + │ └─ item: &QueryUserWhereInput #141 ├─ [id]: optional '_125__integer_filter_c?' #125 │ └─ item: optional '_integer_filter_c' #47 │ └─ item: union #46 @@ -1769,13 +1777,13 @@ root: struct #147 │ │ ├─ variant_2: struct #40 │ │ │ └─ [not]: integer #36 │ │ ├─ variant_3: struct #41 - │ │ │ ├─ [lt]: optional #37 - │ │ │ │ └─ item: integer #36 │ │ │ ├─ [gt]: optional #37 │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [lte]: optional #37 + │ │ │ ├─ [gte]: optional #37 │ │ │ │ └─ item: integer #36 - │ │ │ └─ [gte]: optional #37 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 │ │ │ └─ item: integer #36 │ │ ├─ variant_4: struct #42 │ │ │ └─ [in]: list #38 @@ -1791,13 +1799,13 @@ root: struct #147 │ ├─ variant_2: struct #40 │ │ └─ [not]: integer #36 │ ├─ variant_3: struct #41 - │ │ ├─ [lt]: optional #37 - │ │ │ └─ item: integer #36 │ │ ├─ [gt]: optional #37 │ │ │ └─ item: integer #36 - │ │ ├─ [lte]: optional #37 + │ │ ├─ [gte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [lt]: optional #37 │ │ │ └─ item: integer #36 - │ │ └─ [gte]: optional #37 + │ │ └─ [lte]: optional #37 │ │ └─ item: integer #36 │ ├─ variant_4: struct #42 │ │ └─ [in]: list #38 @@ -1827,9 +1835,9 @@ root: struct #147 │ │ ├─ variant_6: struct #28 │ │ │ └─ [search]: string #18 │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 + │ │ ├─ [endsWith]: optional #19 │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 + │ │ └─ [startsWith]: optional #19 │ │ └─ item: string #18 │ └─ variant_1: struct #31 │ └─ [not]: union '_string_filter' #30 @@ -1851,321 +1859,313 @@ root: struct #147 │ ├─ variant_6: struct #28 │ │ └─ [search]: string #18 │ └─ variant_7: struct #29 - │ ├─ [startsWith]: optional #19 + │ ├─ [endsWith]: optional #19 │ │ └─ item: string #18 - │ └─ [endsWith]: optional #19 + │ └─ [startsWith]: optional #19 │ └─ item: string #18 - ├─ [posts]: optional #139 - │ └─ item: union #138 - │ ├─ variant_0: struct #133 - │ │ └─ [every]: optional '_132_PostWhere__skip_61_UserWhere?' #132 - │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 - │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 - │ │ │ └─ item: optional '_integer_filter_c' #47 - │ │ │ └─ item: union #46 - │ │ │ ├─ variant_0: either '_integer_filter' #44 - │ │ │ │ ├─ variant_0: integer #36 - │ │ │ │ ├─ variant_1: struct #39 - │ │ │ │ │ └─ [equals]: integer #36 - │ │ │ │ ├─ variant_2: struct #40 - │ │ │ │ │ └─ [not]: integer #36 - │ │ │ │ ├─ variant_3: struct #41 - │ │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ ├─ [gt]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ ├─ [lte]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ └─ [gte]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ variant_4: struct #42 - │ │ │ │ │ └─ [in]: list #38 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ variant_5: struct #43 - │ │ │ │ └─ [notIn]: list #38 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ variant_1: struct #45 - │ │ │ └─ [not]: either '_integer_filter' #44 - │ │ │ ├─ variant_0: integer #36 - │ │ │ ├─ variant_1: struct #39 - │ │ │ │ └─ [equals]: integer #36 - │ │ │ ├─ variant_2: struct #40 - │ │ │ │ └─ [not]: integer #36 - │ │ │ ├─ variant_3: struct #41 - │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [gt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [lte]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ [gte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ variant_4: struct #42 - │ │ │ │ └─ [in]: list #38 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ variant_5: struct #43 - │ │ │ └─ [notIn]: list #38 - │ │ │ └─ item: integer #36 - │ │ ├─ [title]: optional '_128__string_filter_c?' #128 - │ │ │ └─ item: optional '_string_filter_c' #33 - │ │ │ └─ item: union #32 - │ │ │ ├─ variant_0: union '_string_filter' #30 - │ │ │ │ ├─ variant_0: string #18 - │ │ │ │ ├─ variant_1: struct #21 - │ │ │ │ │ └─ [equals]: string #18 - │ │ │ │ ├─ variant_2: struct #22 - │ │ │ │ │ └─ [not]: string #18 - │ │ │ │ ├─ variant_3: struct #23 - │ │ │ │ │ └─ [in]: list #20 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ ├─ variant_4: struct #24 - │ │ │ │ │ └─ [notIn]: list #20 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ ├─ variant_5: struct #27 - │ │ │ │ │ ├─ [contains]: string #18 - │ │ │ │ │ └─ [mode]: optional #26 - │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #28 - │ │ │ │ │ └─ [search]: string #18 - │ │ │ │ └─ variant_7: struct #29 - │ │ │ │ ├─ [startsWith]: optional #19 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ └─ [endsWith]: optional #19 - │ │ │ │ └─ item: string #18 - │ │ │ └─ variant_1: struct #31 - │ │ │ └─ [not]: union '_string_filter' #30 - │ │ │ ├─ variant_0: string #18 - │ │ │ ├─ variant_1: struct #21 - │ │ │ │ └─ [equals]: string #18 - │ │ │ ├─ variant_2: struct #22 - │ │ │ │ └─ [not]: string #18 - │ │ │ ├─ variant_3: struct #23 - │ │ │ │ └─ [in]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_4: struct #24 - │ │ │ │ └─ [notIn]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_5: struct #27 - │ │ │ │ ├─ [contains]: string #18 - │ │ │ │ └─ [mode]: optional #26 - │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #28 - │ │ │ │ └─ [search]: string #18 - │ │ │ └─ variant_7: struct #29 - │ │ │ ├─ [startsWith]: optional #19 - │ │ │ │ └─ item: string #18 - │ │ │ └─ [endsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ [author]: optional '_130_UserWhere?' #130 - │ │ └─ item: &UserWhere #129 - │ ├─ variant_1: struct #135 - │ │ └─ [some]: optional '_134_PostWhere__skip_61_UserWhere?' #134 - │ │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 - │ │ ├─ [id]: optional '_127__integer_filter_c?' #127 - │ │ │ └─ item: optional '_integer_filter_c' #47 - │ │ │ └─ item: union #46 - │ │ │ ├─ variant_0: either '_integer_filter' #44 - │ │ │ │ ├─ variant_0: integer #36 - │ │ │ │ ├─ variant_1: struct #39 - │ │ │ │ │ └─ [equals]: integer #36 - │ │ │ │ ├─ variant_2: struct #40 - │ │ │ │ │ └─ [not]: integer #36 - │ │ │ │ ├─ variant_3: struct #41 - │ │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ ├─ [gt]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ ├─ [lte]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ └─ [gte]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ variant_4: struct #42 - │ │ │ │ │ └─ [in]: list #38 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ variant_5: struct #43 - │ │ │ │ └─ [notIn]: list #38 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ variant_1: struct #45 - │ │ │ └─ [not]: either '_integer_filter' #44 - │ │ │ ├─ variant_0: integer #36 - │ │ │ ├─ variant_1: struct #39 - │ │ │ │ └─ [equals]: integer #36 - │ │ │ ├─ variant_2: struct #40 - │ │ │ │ └─ [not]: integer #36 - │ │ │ ├─ variant_3: struct #41 - │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [gt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [lte]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ [gte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ variant_4: struct #42 - │ │ │ │ └─ [in]: list #38 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ variant_5: struct #43 - │ │ │ └─ [notIn]: list #38 - │ │ │ └─ item: integer #36 - │ │ ├─ [title]: optional '_128__string_filter_c?' #128 - │ │ │ └─ item: optional '_string_filter_c' #33 - │ │ │ └─ item: union #32 - │ │ │ ├─ variant_0: union '_string_filter' #30 - │ │ │ │ ├─ variant_0: string #18 - │ │ │ │ ├─ variant_1: struct #21 - │ │ │ │ │ └─ [equals]: string #18 - │ │ │ │ ├─ variant_2: struct #22 - │ │ │ │ │ └─ [not]: string #18 - │ │ │ │ ├─ variant_3: struct #23 - │ │ │ │ │ └─ [in]: list #20 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ ├─ variant_4: struct #24 - │ │ │ │ │ └─ [notIn]: list #20 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ ├─ variant_5: struct #27 - │ │ │ │ │ ├─ [contains]: string #18 - │ │ │ │ │ └─ [mode]: optional #26 - │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #28 - │ │ │ │ │ └─ [search]: string #18 - │ │ │ │ └─ variant_7: struct #29 - │ │ │ │ ├─ [startsWith]: optional #19 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ └─ [endsWith]: optional #19 - │ │ │ │ └─ item: string #18 - │ │ │ └─ variant_1: struct #31 - │ │ │ └─ [not]: union '_string_filter' #30 - │ │ │ ├─ variant_0: string #18 - │ │ │ ├─ variant_1: struct #21 - │ │ │ │ └─ [equals]: string #18 - │ │ │ ├─ variant_2: struct #22 - │ │ │ │ └─ [not]: string #18 - │ │ │ ├─ variant_3: struct #23 - │ │ │ │ └─ [in]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_4: struct #24 - │ │ │ │ └─ [notIn]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_5: struct #27 - │ │ │ │ ├─ [contains]: string #18 - │ │ │ │ └─ [mode]: optional #26 - │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #28 - │ │ │ │ └─ [search]: string #18 - │ │ │ └─ variant_7: struct #29 - │ │ │ ├─ [startsWith]: optional #19 - │ │ │ │ └─ item: string #18 - │ │ │ └─ [endsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ [author]: optional '_130_UserWhere?' #130 - │ │ └─ item: &UserWhere #129 - │ └─ variant_2: struct #137 - │ └─ [none]: optional '_136_PostWhere__skip_61_UserWhere?' #136 - │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 - │ ├─ [id]: optional '_127__integer_filter_c?' #127 - │ │ └─ item: optional '_integer_filter_c' #47 - │ │ └─ item: union #46 - │ │ ├─ variant_0: either '_integer_filter' #44 - │ │ │ ├─ variant_0: integer #36 - │ │ │ ├─ variant_1: struct #39 - │ │ │ │ └─ [equals]: integer #36 - │ │ │ ├─ variant_2: struct #40 - │ │ │ │ └─ [not]: integer #36 - │ │ │ ├─ variant_3: struct #41 - │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [gt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [lte]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ [gte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ variant_4: struct #42 - │ │ │ │ └─ [in]: list #38 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ variant_5: struct #43 - │ │ │ └─ [notIn]: list #38 - │ │ │ └─ item: integer #36 - │ │ └─ variant_1: struct #45 - │ │ └─ [not]: either '_integer_filter' #44 - │ │ ├─ variant_0: integer #36 - │ │ ├─ variant_1: struct #39 - │ │ │ └─ [equals]: integer #36 - │ │ ├─ variant_2: struct #40 - │ │ │ └─ [not]: integer #36 - │ │ ├─ variant_3: struct #41 - │ │ │ ├─ [lt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [gt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [lte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ [gte]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ variant_4: struct #42 - │ │ │ └─ [in]: list #38 - │ │ │ └─ item: integer #36 - │ │ └─ variant_5: struct #43 - │ │ └─ [notIn]: list #38 - │ │ └─ item: integer #36 - │ ├─ [title]: optional '_128__string_filter_c?' #128 - │ │ └─ item: optional '_string_filter_c' #33 - │ │ └─ item: union #32 - │ │ ├─ variant_0: union '_string_filter' #30 - │ │ │ ├─ variant_0: string #18 - │ │ │ ├─ variant_1: struct #21 - │ │ │ │ └─ [equals]: string #18 - │ │ │ ├─ variant_2: struct #22 - │ │ │ │ └─ [not]: string #18 - │ │ │ ├─ variant_3: struct #23 - │ │ │ │ └─ [in]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_4: struct #24 - │ │ │ │ └─ [notIn]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_5: struct #27 - │ │ │ │ ├─ [contains]: string #18 - │ │ │ │ └─ [mode]: optional #26 - │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #28 - │ │ │ │ └─ [search]: string #18 - │ │ │ └─ variant_7: struct #29 - │ │ │ ├─ [startsWith]: optional #19 - │ │ │ │ └─ item: string #18 - │ │ │ └─ [endsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ variant_1: struct #31 - │ │ └─ [not]: union '_string_filter' #30 - │ │ ├─ variant_0: string #18 - │ │ ├─ variant_1: struct #21 - │ │ │ └─ [equals]: string #18 - │ │ ├─ variant_2: struct #22 - │ │ │ └─ [not]: string #18 - │ │ ├─ variant_3: struct #23 - │ │ │ └─ [in]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_4: struct #24 - │ │ │ └─ [notIn]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_5: struct #27 - │ │ │ ├─ [contains]: string #18 - │ │ │ └─ [mode]: optional #26 - │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #28 - │ │ │ └─ [search]: string #18 - │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 - │ │ └─ item: string #18 - │ └─ [author]: optional '_130_UserWhere?' #130 - │ └─ item: &UserWhere #129 - ├─ [AND]: optional '_143__142_QueryUserWhereInput[]?' #143 - │ └─ item: list '_142_QueryUserWhereInput[]' #142 - │ └─ item: &QueryUserWhereInput #141 - ├─ [OR]: optional '_143__142_QueryUserWhereInput[]?' #143 - │ └─ item: list '_142_QueryUserWhereInput[]' #142 - │ └─ item: &QueryUserWhereInput #141 - └─ [NOT]: optional '_144_QueryUserWhereInput?' #144 - └─ item: &QueryUserWhereInput #141 + └─ [posts]: optional #139 + └─ item: union #138 + ├─ variant_0: struct #133 + │ └─ [every]: optional '_132_PostWhere__skip_61_UserWhere?' #132 + │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 + │ ├─ [author]: optional '_130_UserWhere?' #130 + │ │ └─ item: &UserWhere #129 + │ ├─ [id]: optional '_127__integer_filter_c?' #127 + │ │ └─ item: optional '_integer_filter_c' #47 + │ │ └─ item: union #46 + │ │ ├─ variant_0: either '_integer_filter' #44 + │ │ │ ├─ variant_0: integer #36 + │ │ │ ├─ variant_1: struct #39 + │ │ │ │ └─ [equals]: integer #36 + │ │ │ ├─ variant_2: struct #40 + │ │ │ │ └─ [not]: integer #36 + │ │ │ ├─ variant_3: struct #41 + │ │ │ │ ├─ [gt]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ ├─ [gte]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ ├─ [lt]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ └─ [lte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ variant_4: struct #42 + │ │ │ │ └─ [in]: list #38 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ variant_5: struct #43 + │ │ │ └─ [notIn]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_1: struct #45 + │ │ └─ [not]: either '_integer_filter' #44 + │ │ ├─ variant_0: integer #36 + │ │ ├─ variant_1: struct #39 + │ │ │ └─ [equals]: integer #36 + │ │ ├─ variant_2: struct #40 + │ │ │ └─ [not]: integer #36 + │ │ ├─ variant_3: struct #41 + │ │ │ ├─ [gt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ variant_4: struct #42 + │ │ │ └─ [in]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_5: struct #43 + │ │ └─ [notIn]: list #38 + │ │ └─ item: integer #36 + │ └─ [title]: optional '_128__string_filter_c?' #128 + │ └─ item: optional '_string_filter_c' #33 + │ └─ item: union #32 + │ ├─ variant_0: union '_string_filter' #30 + │ │ ├─ variant_0: string #18 + │ │ ├─ variant_1: struct #21 + │ │ │ └─ [equals]: string #18 + │ │ ├─ variant_2: struct #22 + │ │ │ └─ [not]: string #18 + │ │ ├─ variant_3: struct #23 + │ │ │ └─ [in]: list #20 + │ │ │ └─ item: string #18 + │ │ ├─ variant_4: struct #24 + │ │ │ └─ [notIn]: list #20 + │ │ │ └─ item: string #18 + │ │ ├─ variant_5: struct #27 + │ │ │ ├─ [contains]: string #18 + │ │ │ └─ [mode]: optional #26 + │ │ │ └─ item: string #25 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #28 + │ │ │ └─ [search]: string #18 + │ │ └─ variant_7: struct #29 + │ │ ├─ [endsWith]: optional #19 + │ │ │ └─ item: string #18 + │ │ └─ [startsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ variant_1: struct #31 + │ └─ [not]: union '_string_filter' #30 + │ ├─ variant_0: string #18 + │ ├─ variant_1: struct #21 + │ │ └─ [equals]: string #18 + │ ├─ variant_2: struct #22 + │ │ └─ [not]: string #18 + │ ├─ variant_3: struct #23 + │ │ └─ [in]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_4: struct #24 + │ │ └─ [notIn]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_5: struct #27 + │ │ ├─ [contains]: string #18 + │ │ └─ [mode]: optional #26 + │ │ └─ item: string #25 enum{ '"insensitive"' } + │ ├─ variant_6: struct #28 + │ │ └─ [search]: string #18 + │ └─ variant_7: struct #29 + │ ├─ [endsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ [startsWith]: optional #19 + │ └─ item: string #18 + ├─ variant_1: struct #135 + │ └─ [some]: optional '_134_PostWhere__skip_61_UserWhere?' #134 + │ └─ item: struct 'PostWhere__skip_61_UserWhere' #131 + │ ├─ [author]: optional '_130_UserWhere?' #130 + │ │ └─ item: &UserWhere #129 + │ ├─ [id]: optional '_127__integer_filter_c?' #127 + │ │ └─ item: optional '_integer_filter_c' #47 + │ │ └─ item: union #46 + │ │ ├─ variant_0: either '_integer_filter' #44 + │ │ │ ├─ variant_0: integer #36 + │ │ │ ├─ variant_1: struct #39 + │ │ │ │ └─ [equals]: integer #36 + │ │ │ ├─ variant_2: struct #40 + │ │ │ │ └─ [not]: integer #36 + │ │ │ ├─ variant_3: struct #41 + │ │ │ │ ├─ [gt]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ ├─ [gte]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ ├─ [lt]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ └─ [lte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ variant_4: struct #42 + │ │ │ │ └─ [in]: list #38 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ variant_5: struct #43 + │ │ │ └─ [notIn]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_1: struct #45 + │ │ └─ [not]: either '_integer_filter' #44 + │ │ ├─ variant_0: integer #36 + │ │ ├─ variant_1: struct #39 + │ │ │ └─ [equals]: integer #36 + │ │ ├─ variant_2: struct #40 + │ │ │ └─ [not]: integer #36 + │ │ ├─ variant_3: struct #41 + │ │ │ ├─ [gt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ variant_4: struct #42 + │ │ │ └─ [in]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_5: struct #43 + │ │ └─ [notIn]: list #38 + │ │ └─ item: integer #36 + │ └─ [title]: optional '_128__string_filter_c?' #128 + │ └─ item: optional '_string_filter_c' #33 + │ └─ item: union #32 + │ ├─ variant_0: union '_string_filter' #30 + │ │ ├─ variant_0: string #18 + │ │ ├─ variant_1: struct #21 + │ │ │ └─ [equals]: string #18 + │ │ ├─ variant_2: struct #22 + │ │ │ └─ [not]: string #18 + │ │ ├─ variant_3: struct #23 + │ │ │ └─ [in]: list #20 + │ │ │ └─ item: string #18 + │ │ ├─ variant_4: struct #24 + │ │ │ └─ [notIn]: list #20 + │ │ │ └─ item: string #18 + │ │ ├─ variant_5: struct #27 + │ │ │ ├─ [contains]: string #18 + │ │ │ └─ [mode]: optional #26 + │ │ │ └─ item: string #25 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #28 + │ │ │ └─ [search]: string #18 + │ │ └─ variant_7: struct #29 + │ │ ├─ [endsWith]: optional #19 + │ │ │ └─ item: string #18 + │ │ └─ [startsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ variant_1: struct #31 + │ └─ [not]: union '_string_filter' #30 + │ ├─ variant_0: string #18 + │ ├─ variant_1: struct #21 + │ │ └─ [equals]: string #18 + │ ├─ variant_2: struct #22 + │ │ └─ [not]: string #18 + │ ├─ variant_3: struct #23 + │ │ └─ [in]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_4: struct #24 + │ │ └─ [notIn]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_5: struct #27 + │ │ ├─ [contains]: string #18 + │ │ └─ [mode]: optional #26 + │ │ └─ item: string #25 enum{ '"insensitive"' } + │ ├─ variant_6: struct #28 + │ │ └─ [search]: string #18 + │ └─ variant_7: struct #29 + │ ├─ [endsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ [startsWith]: optional #19 + │ └─ item: string #18 + └─ variant_2: struct #137 + └─ [none]: optional '_136_PostWhere__skip_61_UserWhere?' #136 + └─ item: struct 'PostWhere__skip_61_UserWhere' #131 + ├─ [author]: optional '_130_UserWhere?' #130 + │ └─ item: &UserWhere #129 + ├─ [id]: optional '_127__integer_filter_c?' #127 + │ └─ item: optional '_integer_filter_c' #47 + │ └─ item: union #46 + │ ├─ variant_0: either '_integer_filter' #44 + │ │ ├─ variant_0: integer #36 + │ │ ├─ variant_1: struct #39 + │ │ │ └─ [equals]: integer #36 + │ │ ├─ variant_2: struct #40 + │ │ │ └─ [not]: integer #36 + │ │ ├─ variant_3: struct #41 + │ │ │ ├─ [gt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ variant_4: struct #42 + │ │ │ └─ [in]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_5: struct #43 + │ │ └─ [notIn]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_1: struct #45 + │ └─ [not]: either '_integer_filter' #44 + │ ├─ variant_0: integer #36 + │ ├─ variant_1: struct #39 + │ │ └─ [equals]: integer #36 + │ ├─ variant_2: struct #40 + │ │ └─ [not]: integer #36 + │ ├─ variant_3: struct #41 + │ │ ├─ [gt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [gte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [lt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ └─ [lte]: optional #37 + │ │ └─ item: integer #36 + │ ├─ variant_4: struct #42 + │ │ └─ [in]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_5: struct #43 + │ └─ [notIn]: list #38 + │ └─ item: integer #36 + └─ [title]: optional '_128__string_filter_c?' #128 + └─ item: optional '_string_filter_c' #33 + └─ item: union #32 + ├─ variant_0: union '_string_filter' #30 + │ ├─ variant_0: string #18 + │ ├─ variant_1: struct #21 + │ │ └─ [equals]: string #18 + │ ├─ variant_2: struct #22 + │ │ └─ [not]: string #18 + │ ├─ variant_3: struct #23 + │ │ └─ [in]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_4: struct #24 + │ │ └─ [notIn]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_5: struct #27 + │ │ ├─ [contains]: string #18 + │ │ └─ [mode]: optional #26 + │ │ └─ item: string #25 enum{ '"insensitive"' } + │ ├─ variant_6: struct #28 + │ │ └─ [search]: string #18 + │ └─ variant_7: struct #29 + │ ├─ [endsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ [startsWith]: optional #19 + │ └─ item: string #18 + └─ variant_1: struct #31 + └─ [not]: union '_string_filter' #30 + ├─ variant_0: string #18 + ├─ variant_1: struct #21 + │ └─ [equals]: string #18 + ├─ variant_2: struct #22 + │ └─ [not]: string #18 + ├─ variant_3: struct #23 + │ └─ [in]: list #20 + │ └─ item: string #18 + ├─ variant_4: struct #24 + │ └─ [notIn]: list #20 + │ └─ item: string #18 + ├─ variant_5: struct #27 + │ ├─ [contains]: string #18 + │ └─ [mode]: optional #26 + │ └─ item: string #25 enum{ '"insensitive"' } + ├─ variant_6: struct #28 + │ └─ [search]: string #18 + └─ variant_7: struct #29 + ├─ [endsWith]: optional #19 + │ └─ item: string #18 + └─ [startsWith]: optional #19 + └─ item: string #18 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one Post inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one Post inp.snap index 10222fc9c..0169c24e9 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one Post inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one Post inp.snap @@ -1,9 +1,843 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #179 ├─ [data]: struct '_Post_UpdateInput' #173 +│ ├─ [author]: optional #172 +│ │ └─ item: union #171 +│ │ ├─ variant_0: struct #157 +│ │ │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #155 +│ │ │ ├─ [id]: integer #56 +│ │ │ └─ [name]: string #57 +│ │ ├─ variant_1: struct #158 +│ │ │ └─ [connect]: struct 'UserWhere' #139 +│ │ │ ├─ [id]: optional '_124__integer_filter_c?' #124 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_125__string_filter_c?' #125 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #138 +│ │ │ └─ item: union #137 +│ │ │ ├─ variant_0: struct #132 +│ │ │ │ └─ [every]: optional '_131_PostWhere__skip_60_UserWhere?' #131 +│ │ │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 +│ │ │ │ ├─ [author]: optional '_129_UserWhere?' #129 +│ │ │ │ │ └─ item: &UserWhere #128 +│ │ │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ [title]: optional '_127__string_filter_c?' #127 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_1: struct #134 +│ │ │ │ └─ [some]: optional '_133_PostWhere__skip_60_UserWhere?' #133 +│ │ │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 +│ │ │ │ ├─ [author]: optional '_129_UserWhere?' #129 +│ │ │ │ │ └─ item: &UserWhere #128 +│ │ │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ [title]: optional '_127__string_filter_c?' #127 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_2: struct #136 +│ │ │ └─ [none]: optional '_135_PostWhere__skip_60_UserWhere?' #135 +│ │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 +│ │ │ ├─ [author]: optional '_129_UserWhere?' #129 +│ │ │ │ └─ item: &UserWhere #128 +│ │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ └─ [title]: optional '_127__string_filter_c?' #127 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ ├─ variant_2: struct #159 +│ │ │ └─ [connectOrCreate]: struct #156 +│ │ │ ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #155 +│ │ │ │ ├─ [id]: integer #56 +│ │ │ │ └─ [name]: string #57 +│ │ │ └─ [where]: struct 'UserWhere' #139 +│ │ │ ├─ [id]: optional '_124__integer_filter_c?' #124 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_125__string_filter_c?' #125 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #138 +│ │ │ └─ item: union #137 +│ │ │ ├─ variant_0: struct #132 +│ │ │ │ └─ [every]: optional '_131_PostWhere__skip_60_UserWhere?' #131 +│ │ │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 +│ │ │ │ ├─ [author]: optional '_129_UserWhere?' #129 +│ │ │ │ │ └─ item: &UserWhere #128 +│ │ │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ [title]: optional '_127__string_filter_c?' #127 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_1: struct #134 +│ │ │ │ └─ [some]: optional '_133_PostWhere__skip_60_UserWhere?' #133 +│ │ │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 +│ │ │ │ ├─ [author]: optional '_129_UserWhere?' #129 +│ │ │ │ │ └─ item: &UserWhere #128 +│ │ │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ [title]: optional '_127__string_filter_c?' #127 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_2: struct #136 +│ │ │ └─ [none]: optional '_135_PostWhere__skip_60_UserWhere?' #135 +│ │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 +│ │ │ ├─ [author]: optional '_129_UserWhere?' #129 +│ │ │ │ └─ item: &UserWhere #128 +│ │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ └─ [title]: optional '_127__string_filter_c?' #127 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_3: struct #170 +│ │ └─ [update]: struct '_User_UpdateInput_excluding___rel_Post_User_1' #169 +│ │ ├─ [id]: optional #165 +│ │ │ └─ item: union #164 +│ │ │ ├─ variant_0: integer #56 +│ │ │ ├─ variant_1: struct #160 +│ │ │ │ └─ [set]: integer #56 +│ │ │ ├─ variant_2: struct #161 +│ │ │ │ └─ [multiply]: integer #56 +│ │ │ ├─ variant_3: struct #162 +│ │ │ │ └─ [decrement]: integer #56 +│ │ │ └─ variant_4: struct #163 +│ │ │ └─ [increment]: integer #56 +│ │ └─ [name]: optional #168 +│ │ └─ item: union #167 +│ │ ├─ variant_0: string #57 +│ │ └─ variant_1: struct #166 +│ │ └─ [set]: string #57 │ ├─ [id]: optional #151 │ │ └─ item: union #150 │ │ ├─ variant_0: integer #61 @@ -15,942 +849,20 @@ root: struct #179 │ │ │ └─ [decrement]: integer #61 │ │ └─ variant_4: struct #149 │ │ └─ [increment]: integer #61 -│ ├─ [title]: optional #154 -│ │ └─ item: union #153 -│ │ ├─ variant_0: string #62 -│ │ └─ variant_1: struct #152 -│ │ └─ [set]: string #62 -│ └─ [author]: optional #172 -│ └─ item: union #171 -│ ├─ variant_0: struct #157 -│ │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #155 -│ │ ├─ [id]: integer #56 -│ │ └─ [name]: string #57 -│ ├─ variant_1: struct #158 -│ │ └─ [connect]: struct 'UserWhere' #139 -│ │ ├─ [id]: optional '_124__integer_filter_c?' #124 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [name]: optional '_125__string_filter_c?' #125 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [posts]: optional #138 -│ │ └─ item: union #137 -│ │ ├─ variant_0: struct #132 -│ │ │ └─ [every]: optional '_131_PostWhere__skip_60_UserWhere?' #131 -│ │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 -│ │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_127__string_filter_c?' #127 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_129_UserWhere?' #129 -│ │ │ └─ item: &UserWhere #128 -│ │ ├─ variant_1: struct #134 -│ │ │ └─ [some]: optional '_133_PostWhere__skip_60_UserWhere?' #133 -│ │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 -│ │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_127__string_filter_c?' #127 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_129_UserWhere?' #129 -│ │ │ └─ item: &UserWhere #128 -│ │ └─ variant_2: struct #136 -│ │ └─ [none]: optional '_135_PostWhere__skip_60_UserWhere?' #135 -│ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 -│ │ ├─ [id]: optional '_126__integer_filter_c?' #126 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [title]: optional '_127__string_filter_c?' #127 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [author]: optional '_129_UserWhere?' #129 -│ │ └─ item: &UserWhere #128 -│ ├─ variant_2: struct #159 -│ │ └─ [connectOrCreate]: struct #156 -│ │ ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #155 -│ │ │ ├─ [id]: integer #56 -│ │ │ └─ [name]: string #57 -│ │ └─ [where]: struct 'UserWhere' #139 -│ │ ├─ [id]: optional '_124__integer_filter_c?' #124 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [name]: optional '_125__string_filter_c?' #125 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [posts]: optional #138 -│ │ └─ item: union #137 -│ │ ├─ variant_0: struct #132 -│ │ │ └─ [every]: optional '_131_PostWhere__skip_60_UserWhere?' #131 -│ │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 -│ │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_127__string_filter_c?' #127 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_129_UserWhere?' #129 -│ │ │ └─ item: &UserWhere #128 -│ │ ├─ variant_1: struct #134 -│ │ │ └─ [some]: optional '_133_PostWhere__skip_60_UserWhere?' #133 -│ │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 -│ │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_127__string_filter_c?' #127 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_129_UserWhere?' #129 -│ │ │ └─ item: &UserWhere #128 -│ │ └─ variant_2: struct #136 -│ │ └─ [none]: optional '_135_PostWhere__skip_60_UserWhere?' #135 -│ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 -│ │ ├─ [id]: optional '_126__integer_filter_c?' #126 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [title]: optional '_127__string_filter_c?' #127 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [author]: optional '_129_UserWhere?' #129 -│ │ └─ item: &UserWhere #128 -│ └─ variant_3: struct #170 -│ └─ [update]: struct '_User_UpdateInput_excluding___rel_Post_User_1' #169 -│ ├─ [id]: optional #165 -│ │ └─ item: union #164 -│ │ ├─ variant_0: integer #56 -│ │ ├─ variant_1: struct #160 -│ │ │ └─ [set]: integer #56 -│ │ ├─ variant_2: struct #161 -│ │ │ └─ [multiply]: integer #56 -│ │ ├─ variant_3: struct #162 -│ │ │ └─ [decrement]: integer #56 -│ │ └─ variant_4: struct #163 -│ │ └─ [increment]: integer #56 -│ └─ [name]: optional #168 -│ └─ item: union #167 -│ ├─ variant_0: string #57 -│ └─ variant_1: struct #166 -│ └─ [set]: string #57 +│ └─ [title]: optional #154 +│ └─ item: union #153 +│ ├─ variant_0: string #62 +│ └─ variant_1: struct #152 +│ └─ [set]: string #62 └─ [where]: struct 'QueryPostWhereUniqueInput' #178 - ├─ [id]: optional '_78__integer_filter_c?' #78 - │ └─ item: optional '_integer_filter_c' #47 - │ └─ item: union #46 - │ ├─ variant_0: either '_integer_filter' #44 - │ │ ├─ variant_0: integer #36 - │ │ ├─ variant_1: struct #39 - │ │ │ └─ [equals]: integer #36 - │ │ ├─ variant_2: struct #40 - │ │ │ └─ [not]: integer #36 - │ │ ├─ variant_3: struct #41 - │ │ │ ├─ [lt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [gt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [lte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ [gte]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ variant_4: struct #42 - │ │ │ └─ [in]: list #38 - │ │ │ └─ item: integer #36 - │ │ └─ variant_5: struct #43 - │ │ └─ [notIn]: list #38 - │ │ └─ item: integer #36 - │ └─ variant_1: struct #45 - │ └─ [not]: either '_integer_filter' #44 - │ ├─ variant_0: integer #36 - │ ├─ variant_1: struct #39 - │ │ └─ [equals]: integer #36 - │ ├─ variant_2: struct #40 - │ │ └─ [not]: integer #36 - │ ├─ variant_3: struct #41 - │ │ ├─ [lt]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ [gt]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ [lte]: optional #37 - │ │ │ └─ item: integer #36 - │ │ └─ [gte]: optional #37 - │ │ └─ item: integer #36 - │ ├─ variant_4: struct #42 - │ │ └─ [in]: list #38 - │ │ └─ item: integer #36 - │ └─ variant_5: struct #43 - │ └─ [notIn]: list #38 - │ └─ item: integer #36 - ├─ [title]: optional '_79__string_filter_c?' #79 - │ └─ item: optional '_string_filter_c' #33 - │ └─ item: union #32 - │ ├─ variant_0: union '_string_filter' #30 - │ │ ├─ variant_0: string #18 - │ │ ├─ variant_1: struct #21 - │ │ │ └─ [equals]: string #18 - │ │ ├─ variant_2: struct #22 - │ │ │ └─ [not]: string #18 - │ │ ├─ variant_3: struct #23 - │ │ │ └─ [in]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_4: struct #24 - │ │ │ └─ [notIn]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_5: struct #27 - │ │ │ ├─ [contains]: string #18 - │ │ │ └─ [mode]: optional #26 - │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #28 - │ │ │ └─ [search]: string #18 - │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 - │ │ └─ item: string #18 - │ └─ variant_1: struct #31 - │ └─ [not]: union '_string_filter' #30 - │ ├─ variant_0: string #18 - │ ├─ variant_1: struct #21 - │ │ └─ [equals]: string #18 - │ ├─ variant_2: struct #22 - │ │ └─ [not]: string #18 - │ ├─ variant_3: struct #23 - │ │ └─ [in]: list #20 - │ │ └─ item: string #18 - │ ├─ variant_4: struct #24 - │ │ └─ [notIn]: list #20 - │ │ └─ item: string #18 - │ ├─ variant_5: struct #27 - │ │ ├─ [contains]: string #18 - │ │ └─ [mode]: optional #26 - │ │ └─ item: string #25 enum{ '"insensitive"' } - │ ├─ variant_6: struct #28 - │ │ └─ [search]: string #18 - │ └─ variant_7: struct #29 - │ ├─ [startsWith]: optional #19 - │ │ └─ item: string #18 - │ └─ [endsWith]: optional #19 - │ └─ item: string #18 + ├─ [AND]: optional '_176__175_QueryPostWhereUniqueInput[]?' #176 + │ └─ item: list '_175_QueryPostWhereUniqueInput[]' #175 + │ └─ item: &QueryPostWhereUniqueInput #174 + ├─ [NOT]: optional '_177_QueryPostWhereUniqueInput?' #177 + │ └─ item: &QueryPostWhereUniqueInput #174 + ├─ [OR]: optional '_176__175_QueryPostWhereUniqueInput[]?' #176 + │ └─ item: list '_175_QueryPostWhereUniqueInput[]' #175 + │ └─ item: &QueryPostWhereUniqueInput #174 ├─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 │ ├─ [id]: optional '_80__integer_filter_c?' #80 @@ -963,13 +875,13 @@ root: struct #179 │ │ │ ├─ variant_2: struct #40 │ │ │ │ └─ [not]: integer #36 │ │ │ ├─ variant_3: struct #41 - │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [lte]: optional #37 + │ │ │ │ ├─ [gte]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ [gte]: optional #37 + │ │ │ │ └─ [lte]: optional #37 │ │ │ │ └─ item: integer #36 │ │ │ ├─ variant_4: struct #42 │ │ │ │ └─ [in]: list #38 @@ -985,13 +897,13 @@ root: struct #179 │ │ ├─ variant_2: struct #40 │ │ │ └─ [not]: integer #36 │ │ ├─ variant_3: struct #41 - │ │ │ ├─ [lt]: optional #37 - │ │ │ │ └─ item: integer #36 │ │ │ ├─ [gt]: optional #37 │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [lte]: optional #37 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 │ │ │ │ └─ item: integer #36 - │ │ │ └─ [gte]: optional #37 + │ │ │ └─ [lte]: optional #37 │ │ │ └─ item: integer #36 │ │ ├─ variant_4: struct #42 │ │ │ └─ [in]: list #38 @@ -1021,9 +933,9 @@ root: struct #179 │ │ │ ├─ variant_6: struct #28 │ │ │ │ └─ [search]: string #18 │ │ │ └─ variant_7: struct #29 - │ │ │ ├─ [startsWith]: optional #19 + │ │ │ ├─ [endsWith]: optional #19 │ │ │ │ └─ item: string #18 - │ │ │ └─ [endsWith]: optional #19 + │ │ │ └─ [startsWith]: optional #19 │ │ │ └─ item: string #18 │ │ └─ variant_1: struct #31 │ │ └─ [not]: union '_string_filter' #30 @@ -1045,9 +957,9 @@ root: struct #179 │ │ ├─ variant_6: struct #28 │ │ │ └─ [search]: string #18 │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 + │ │ ├─ [endsWith]: optional #19 │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 + │ │ └─ [startsWith]: optional #19 │ │ └─ item: string #18 │ └─ [posts]: optional #90 │ └─ item: union #89 @@ -1060,12 +972,100 @@ root: struct #179 │ └─ variant_2: struct #88 │ └─ [none]: optional '_87_PostWhere?' #87 │ └─ item: &PostWhere #82 - ├─ [AND]: optional '_176__175_QueryPostWhereUniqueInput[]?' #176 - │ └─ item: list '_175_QueryPostWhereUniqueInput[]' #175 - │ └─ item: &QueryPostWhereUniqueInput #174 - ├─ [OR]: optional '_176__175_QueryPostWhereUniqueInput[]?' #176 - │ └─ item: list '_175_QueryPostWhereUniqueInput[]' #175 - │ └─ item: &QueryPostWhereUniqueInput #174 - └─ [NOT]: optional '_177_QueryPostWhereUniqueInput?' #177 - └─ item: &QueryPostWhereUniqueInput #174 + ├─ [id]: optional '_78__integer_filter_c?' #78 + │ └─ item: optional '_integer_filter_c' #47 + │ └─ item: union #46 + │ ├─ variant_0: either '_integer_filter' #44 + │ │ ├─ variant_0: integer #36 + │ │ ├─ variant_1: struct #39 + │ │ │ └─ [equals]: integer #36 + │ │ ├─ variant_2: struct #40 + │ │ │ └─ [not]: integer #36 + │ │ ├─ variant_3: struct #41 + │ │ │ ├─ [gt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ variant_4: struct #42 + │ │ │ └─ [in]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_5: struct #43 + │ │ └─ [notIn]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_1: struct #45 + │ └─ [not]: either '_integer_filter' #44 + │ ├─ variant_0: integer #36 + │ ├─ variant_1: struct #39 + │ │ └─ [equals]: integer #36 + │ ├─ variant_2: struct #40 + │ │ └─ [not]: integer #36 + │ ├─ variant_3: struct #41 + │ │ ├─ [gt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [gte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [lt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ └─ [lte]: optional #37 + │ │ └─ item: integer #36 + │ ├─ variant_4: struct #42 + │ │ └─ [in]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_5: struct #43 + │ └─ [notIn]: list #38 + │ └─ item: integer #36 + └─ [title]: optional '_79__string_filter_c?' #79 + └─ item: optional '_string_filter_c' #33 + └─ item: union #32 + ├─ variant_0: union '_string_filter' #30 + │ ├─ variant_0: string #18 + │ ├─ variant_1: struct #21 + │ │ └─ [equals]: string #18 + │ ├─ variant_2: struct #22 + │ │ └─ [not]: string #18 + │ ├─ variant_3: struct #23 + │ │ └─ [in]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_4: struct #24 + │ │ └─ [notIn]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_5: struct #27 + │ │ ├─ [contains]: string #18 + │ │ └─ [mode]: optional #26 + │ │ └─ item: string #25 enum{ '"insensitive"' } + │ ├─ variant_6: struct #28 + │ │ └─ [search]: string #18 + │ └─ variant_7: struct #29 + │ ├─ [endsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ [startsWith]: optional #19 + │ └─ item: string #18 + └─ variant_1: struct #31 + └─ [not]: union '_string_filter' #30 + ├─ variant_0: string #18 + ├─ variant_1: struct #21 + │ └─ [equals]: string #18 + ├─ variant_2: struct #22 + │ └─ [not]: string #18 + ├─ variant_3: struct #23 + │ └─ [in]: list #20 + │ └─ item: string #18 + ├─ variant_4: struct #24 + │ └─ [notIn]: list #20 + │ └─ item: string #18 + ├─ variant_5: struct #27 + │ ├─ [contains]: string #18 + │ └─ [mode]: optional #26 + │ └─ item: string #25 enum{ '"insensitive"' } + ├─ variant_6: struct #28 + │ └─ [search]: string #18 + └─ variant_7: struct #29 + ├─ [endsWith]: optional #19 + │ └─ item: string #18 + └─ [startsWith]: optional #19 + └─ item: string #18 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one Record inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one Record inp.snap index 1f1846372..f5ced6e92 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one Record inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one Record inp.snap @@ -1,33 +1,87 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #55 ├─ [data]: struct '_Record_UpdateInput' #17 +│ ├─ [age]: optional #16 +│ │ └─ item: union #15 +│ │ ├─ variant_0: optional #3 +│ │ │ └─ item: integer #2 +│ │ ├─ variant_1: struct #11 +│ │ │ └─ [set]: optional #3 +│ │ │ └─ item: integer #2 +│ │ ├─ variant_2: struct #12 +│ │ │ └─ [multiply]: integer #2 +│ │ ├─ variant_3: struct #13 +│ │ │ └─ [decrement]: integer #2 +│ │ └─ variant_4: struct #14 +│ │ └─ [increment]: integer #2 │ ├─ [id]: optional #7 │ │ └─ item: union #6 │ │ ├─ variant_0: string #0 │ │ └─ variant_1: struct #5 │ │ └─ [set]: string #0 -│ ├─ [name]: optional #10 -│ │ └─ item: union #9 -│ │ ├─ variant_0: string #1 -│ │ └─ variant_1: struct #8 -│ │ └─ [set]: string #1 -│ └─ [age]: optional #16 -│ └─ item: union #15 -│ ├─ variant_0: optional #3 -│ │ └─ item: integer #2 -│ ├─ variant_1: struct #11 -│ │ └─ [set]: optional #3 -│ │ └─ item: integer #2 -│ ├─ variant_2: struct #12 -│ │ └─ [multiply]: integer #2 -│ ├─ variant_3: struct #13 -│ │ └─ [decrement]: integer #2 -│ └─ variant_4: struct #14 -│ └─ [increment]: integer #2 +│ └─ [name]: optional #10 +│ └─ item: union #9 +│ ├─ variant_0: string #1 +│ └─ variant_1: struct #8 +│ └─ [set]: string #1 └─ [where]: struct 'QueryRecordWhereUniqueInput' #54 + ├─ [AND]: optional '_52__51_QueryRecordWhereUniqueInput[]?' #52 + │ └─ item: list '_51_QueryRecordWhereUniqueInput[]' #51 + │ └─ item: &QueryRecordWhereUniqueInput #50 + ├─ [NOT]: optional '_53_QueryRecordWhereUniqueInput?' #53 + │ └─ item: &QueryRecordWhereUniqueInput #50 + ├─ [OR]: optional '_52__51_QueryRecordWhereUniqueInput[]?' #52 + │ └─ item: list '_51_QueryRecordWhereUniqueInput[]' #51 + │ └─ item: &QueryRecordWhereUniqueInput #50 + ├─ [age]: optional '_48__integer_filter_c?' #48 + │ └─ item: optional '_integer_filter_c' #47 + │ └─ item: union #46 + │ ├─ variant_0: either '_integer_filter' #44 + │ │ ├─ variant_0: integer #36 + │ │ ├─ variant_1: struct #39 + │ │ │ └─ [equals]: integer #36 + │ │ ├─ variant_2: struct #40 + │ │ │ └─ [not]: integer #36 + │ │ ├─ variant_3: struct #41 + │ │ │ ├─ [gt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ variant_4: struct #42 + │ │ │ └─ [in]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_5: struct #43 + │ │ └─ [notIn]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_1: struct #45 + │ └─ [not]: either '_integer_filter' #44 + │ ├─ variant_0: integer #36 + │ ├─ variant_1: struct #39 + │ │ └─ [equals]: integer #36 + │ ├─ variant_2: struct #40 + │ │ └─ [not]: integer #36 + │ ├─ variant_3: struct #41 + │ │ ├─ [gt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [gte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [lt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ └─ [lte]: optional #37 + │ │ └─ item: integer #36 + │ ├─ variant_4: struct #42 + │ │ └─ [in]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_5: struct #43 + │ └─ [notIn]: list #38 + │ └─ item: integer #36 ├─ [id]: optional '_34__string_filter_c?' #34 │ └─ item: optional '_string_filter_c' #33 │ └─ item: union #32 @@ -50,9 +104,9 @@ root: struct #55 │ │ ├─ variant_6: struct #28 │ │ │ └─ [search]: string #18 │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 + │ │ ├─ [endsWith]: optional #19 │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 + │ │ └─ [startsWith]: optional #19 │ │ └─ item: string #18 │ └─ variant_1: struct #31 │ └─ [not]: union '_string_filter' #30 @@ -74,112 +128,58 @@ root: struct #55 │ ├─ variant_6: struct #28 │ │ └─ [search]: string #18 │ └─ variant_7: struct #29 - │ ├─ [startsWith]: optional #19 + │ ├─ [endsWith]: optional #19 │ │ └─ item: string #18 - │ └─ [endsWith]: optional #19 + │ └─ [startsWith]: optional #19 │ └─ item: string #18 - ├─ [name]: optional '_35__string_filter_c?' #35 - │ └─ item: optional '_string_filter_c' #33 - │ └─ item: union #32 - │ ├─ variant_0: union '_string_filter' #30 - │ │ ├─ variant_0: string #18 - │ │ ├─ variant_1: struct #21 - │ │ │ └─ [equals]: string #18 - │ │ ├─ variant_2: struct #22 - │ │ │ └─ [not]: string #18 - │ │ ├─ variant_3: struct #23 - │ │ │ └─ [in]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_4: struct #24 - │ │ │ └─ [notIn]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_5: struct #27 - │ │ │ ├─ [contains]: string #18 - │ │ │ └─ [mode]: optional #26 - │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #28 - │ │ │ └─ [search]: string #18 - │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 - │ │ └─ item: string #18 - │ └─ variant_1: struct #31 - │ └─ [not]: union '_string_filter' #30 - │ ├─ variant_0: string #18 - │ ├─ variant_1: struct #21 - │ │ └─ [equals]: string #18 - │ ├─ variant_2: struct #22 - │ │ └─ [not]: string #18 - │ ├─ variant_3: struct #23 - │ │ └─ [in]: list #20 - │ │ └─ item: string #18 - │ ├─ variant_4: struct #24 - │ │ └─ [notIn]: list #20 - │ │ └─ item: string #18 - │ ├─ variant_5: struct #27 - │ │ ├─ [contains]: string #18 - │ │ └─ [mode]: optional #26 - │ │ └─ item: string #25 enum{ '"insensitive"' } - │ ├─ variant_6: struct #28 - │ │ └─ [search]: string #18 - │ └─ variant_7: struct #29 - │ ├─ [startsWith]: optional #19 - │ │ └─ item: string #18 - │ └─ [endsWith]: optional #19 - │ └─ item: string #18 - ├─ [age]: optional '_48__integer_filter_c?' #48 - │ └─ item: optional '_integer_filter_c' #47 - │ └─ item: union #46 - │ ├─ variant_0: either '_integer_filter' #44 - │ │ ├─ variant_0: integer #36 - │ │ ├─ variant_1: struct #39 - │ │ │ └─ [equals]: integer #36 - │ │ ├─ variant_2: struct #40 - │ │ │ └─ [not]: integer #36 - │ │ ├─ variant_3: struct #41 - │ │ │ ├─ [lt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [gt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [lte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ [gte]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ variant_4: struct #42 - │ │ │ └─ [in]: list #38 - │ │ │ └─ item: integer #36 - │ │ └─ variant_5: struct #43 - │ │ └─ [notIn]: list #38 - │ │ └─ item: integer #36 - │ └─ variant_1: struct #45 - │ └─ [not]: either '_integer_filter' #44 - │ ├─ variant_0: integer #36 - │ ├─ variant_1: struct #39 - │ │ └─ [equals]: integer #36 - │ ├─ variant_2: struct #40 - │ │ └─ [not]: integer #36 - │ ├─ variant_3: struct #41 - │ │ ├─ [lt]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ [gt]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ [lte]: optional #37 - │ │ │ └─ item: integer #36 - │ │ └─ [gte]: optional #37 - │ │ └─ item: integer #36 - │ ├─ variant_4: struct #42 - │ │ └─ [in]: list #38 - │ │ └─ item: integer #36 - │ └─ variant_5: struct #43 - │ └─ [notIn]: list #38 - │ └─ item: integer #36 - ├─ [AND]: optional '_52__51_QueryRecordWhereUniqueInput[]?' #52 - │ └─ item: list '_51_QueryRecordWhereUniqueInput[]' #51 - │ └─ item: &QueryRecordWhereUniqueInput #50 - ├─ [OR]: optional '_52__51_QueryRecordWhereUniqueInput[]?' #52 - │ └─ item: list '_51_QueryRecordWhereUniqueInput[]' #51 - │ └─ item: &QueryRecordWhereUniqueInput #50 - └─ [NOT]: optional '_53_QueryRecordWhereUniqueInput?' #53 - └─ item: &QueryRecordWhereUniqueInput #50 + └─ [name]: optional '_35__string_filter_c?' #35 + └─ item: optional '_string_filter_c' #33 + └─ item: union #32 + ├─ variant_0: union '_string_filter' #30 + │ ├─ variant_0: string #18 + │ ├─ variant_1: struct #21 + │ │ └─ [equals]: string #18 + │ ├─ variant_2: struct #22 + │ │ └─ [not]: string #18 + │ ├─ variant_3: struct #23 + │ │ └─ [in]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_4: struct #24 + │ │ └─ [notIn]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_5: struct #27 + │ │ ├─ [contains]: string #18 + │ │ └─ [mode]: optional #26 + │ │ └─ item: string #25 enum{ '"insensitive"' } + │ ├─ variant_6: struct #28 + │ │ └─ [search]: string #18 + │ └─ variant_7: struct #29 + │ ├─ [endsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ [startsWith]: optional #19 + │ └─ item: string #18 + └─ variant_1: struct #31 + └─ [not]: union '_string_filter' #30 + ├─ variant_0: string #18 + ├─ variant_1: struct #21 + │ └─ [equals]: string #18 + ├─ variant_2: struct #22 + │ └─ [not]: string #18 + ├─ variant_3: struct #23 + │ └─ [in]: list #20 + │ └─ item: string #18 + ├─ variant_4: struct #24 + │ └─ [notIn]: list #20 + │ └─ item: string #18 + ├─ variant_5: struct #27 + │ ├─ [contains]: string #18 + │ └─ [mode]: optional #26 + │ └─ item: string #25 enum{ '"insensitive"' } + ├─ variant_6: struct #28 + │ └─ [search]: string #18 + └─ variant_7: struct #29 + ├─ [endsWith]: optional #19 + │ └─ item: string #18 + └─ [startsWith]: optional #19 + └─ item: string #18 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one User inp.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one User inp.snap index 625cedd76..15f775894 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one User inp.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__test__update_one User inp.snap @@ -1,6 +1,6 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #145 ├─ [data]: struct '_User_UpdateInput' #123 @@ -36,6 +36,115 @@ root: struct #145 │ ├─ variant_1: struct #98 │ │ └─ [connect]: union #95 │ │ ├─ variant_0: struct 'PostWhere' #93 +│ │ │ ├─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 +│ │ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 +│ │ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 +│ │ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ │ └─ item: union #32 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ variant_1: struct #31 +│ │ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [posts]: optional #90 +│ │ │ │ └─ item: union #89 +│ │ │ │ ├─ variant_0: struct #84 +│ │ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 +│ │ │ │ │ └─ item: &PostWhere #82 +│ │ │ │ ├─ variant_1: struct #86 +│ │ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 +│ │ │ │ │ └─ item: &PostWhere #82 +│ │ │ │ └─ variant_2: struct #88 +│ │ │ │ └─ [none]: optional '_87_PostWhere?' #87 +│ │ │ │ └─ item: &PostWhere #82 │ │ │ ├─ [id]: optional '_78__integer_filter_c?' #78 │ │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ │ └─ item: union #46 @@ -46,13 +155,13 @@ root: struct #145 │ │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ │ └─ [in]: list #38 @@ -68,13 +177,13 @@ root: struct #145 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -82,167 +191,167 @@ root: struct #145 │ │ │ │ └─ variant_5: struct #43 │ │ │ │ └─ [notIn]: list #38 │ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_79__string_filter_c?' #79 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 -│ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 -│ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [posts]: optional #90 -│ │ │ └─ item: union #89 -│ │ │ ├─ variant_0: struct #84 -│ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 -│ │ │ │ └─ item: &PostWhere #82 -│ │ │ ├─ variant_1: struct #86 -│ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 -│ │ │ │ └─ item: &PostWhere #82 -│ │ │ └─ variant_2: struct #88 -│ │ │ └─ [none]: optional '_87_PostWhere?' #87 -│ │ │ └─ item: &PostWhere #82 +│ │ │ └─ [title]: optional '_79__string_filter_c?' #79 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 │ │ └─ variant_1: list '_94_PostWhere[]' #94 │ │ └─ item: struct 'PostWhere' #93 +│ │ ├─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 +│ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 +│ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #90 +│ │ │ └─ item: union #89 +│ │ │ ├─ variant_0: struct #84 +│ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 +│ │ │ │ └─ item: &PostWhere #82 +│ │ │ ├─ variant_1: struct #86 +│ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 +│ │ │ │ └─ item: &PostWhere #82 +│ │ │ └─ variant_2: struct #88 +│ │ │ └─ [none]: optional '_87_PostWhere?' #87 +│ │ │ └─ item: &PostWhere #82 │ │ ├─ [id]: optional '_78__integer_filter_c?' #78 │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ └─ item: union #46 @@ -253,13 +362,13 @@ root: struct #145 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -275,13 +384,13 @@ root: struct #145 │ │ │ ├─ variant_2: struct #40 │ │ │ │ └─ [not]: integer #36 │ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 +│ │ │ │ └─ [lte]: optional #37 │ │ │ │ └─ item: integer #36 │ │ │ ├─ variant_4: struct #42 │ │ │ │ └─ [in]: list #38 @@ -289,165 +398,56 @@ root: struct #145 │ │ │ └─ variant_5: struct #43 │ │ │ └─ [notIn]: list #38 │ │ │ └─ item: integer #36 -│ │ ├─ [title]: optional '_79__string_filter_c?' #79 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 -│ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 -│ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [name]: optional '_81__string_filter_c?' #81 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [posts]: optional #90 -│ │ └─ item: union #89 -│ │ ├─ variant_0: struct #84 -│ │ │ └─ [every]: optional '_83_PostWhere?' #83 -│ │ │ └─ item: &PostWhere #82 -│ │ ├─ variant_1: struct #86 -│ │ │ └─ [some]: optional '_85_PostWhere?' #85 -│ │ │ └─ item: &PostWhere #82 -│ │ └─ variant_2: struct #88 -│ │ └─ [none]: optional '_87_PostWhere?' #87 -│ │ └─ item: &PostWhere #82 +│ │ └─ [title]: optional '_79__string_filter_c?' #79 +│ │ └─ item: optional '_string_filter_c' #33 +│ │ └─ item: union #32 +│ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_1: struct #31 +│ │ └─ [not]: union '_string_filter' #30 +│ │ ├─ variant_0: string #18 +│ │ ├─ variant_1: struct #21 +│ │ │ └─ [equals]: string #18 +│ │ ├─ variant_2: struct #22 +│ │ │ └─ [not]: string #18 +│ │ ├─ variant_3: struct #23 +│ │ │ └─ [in]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_4: struct #24 +│ │ │ └─ [notIn]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_5: struct #27 +│ │ │ ├─ [contains]: string #18 +│ │ │ └─ [mode]: optional #26 +│ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #28 +│ │ │ └─ [search]: string #18 +│ │ └─ variant_7: struct #29 +│ │ ├─ [endsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ [startsWith]: optional #19 +│ │ └─ item: string #18 │ ├─ variant_2: struct #99 │ │ └─ [connectOrCreate]: struct #96 │ │ ├─ [create]: union #77 @@ -462,6 +462,115 @@ root: struct #145 │ │ │ └─ [title]: string #62 │ │ └─ [where]: union #95 │ │ ├─ variant_0: struct 'PostWhere' #93 +│ │ │ ├─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 +│ │ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 +│ │ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 +│ │ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ │ └─ item: union #32 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ variant_1: struct #31 +│ │ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [posts]: optional #90 +│ │ │ │ └─ item: union #89 +│ │ │ │ ├─ variant_0: struct #84 +│ │ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 +│ │ │ │ │ └─ item: &PostWhere #82 +│ │ │ │ ├─ variant_1: struct #86 +│ │ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 +│ │ │ │ │ └─ item: &PostWhere #82 +│ │ │ │ └─ variant_2: struct #88 +│ │ │ │ └─ [none]: optional '_87_PostWhere?' #87 +│ │ │ │ └─ item: &PostWhere #82 │ │ │ ├─ [id]: optional '_78__integer_filter_c?' #78 │ │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ │ └─ item: union #46 @@ -472,13 +581,13 @@ root: struct #145 │ │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ │ └─ [in]: list #38 @@ -494,13 +603,13 @@ root: struct #145 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -508,167 +617,167 @@ root: struct #145 │ │ │ │ └─ variant_5: struct #43 │ │ │ │ └─ [notIn]: list #38 │ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_79__string_filter_c?' #79 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 -│ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 -│ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [posts]: optional #90 -│ │ │ └─ item: union #89 -│ │ │ ├─ variant_0: struct #84 -│ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 -│ │ │ │ └─ item: &PostWhere #82 -│ │ │ ├─ variant_1: struct #86 -│ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 -│ │ │ │ └─ item: &PostWhere #82 -│ │ │ └─ variant_2: struct #88 -│ │ │ └─ [none]: optional '_87_PostWhere?' #87 -│ │ │ └─ item: &PostWhere #82 +│ │ │ └─ [title]: optional '_79__string_filter_c?' #79 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 │ │ └─ variant_1: list '_94_PostWhere[]' #94 │ │ └─ item: struct 'PostWhere' #93 +│ │ ├─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 +│ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 +│ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #90 +│ │ │ └─ item: union #89 +│ │ │ ├─ variant_0: struct #84 +│ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 +│ │ │ │ └─ item: &PostWhere #82 +│ │ │ ├─ variant_1: struct #86 +│ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 +│ │ │ │ └─ item: &PostWhere #82 +│ │ │ └─ variant_2: struct #88 +│ │ │ └─ [none]: optional '_87_PostWhere?' #87 +│ │ │ └─ item: &PostWhere #82 │ │ ├─ [id]: optional '_78__integer_filter_c?' #78 │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ └─ item: union #46 @@ -679,13 +788,13 @@ root: struct #145 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -701,13 +810,13 @@ root: struct #145 │ │ │ ├─ variant_2: struct #40 │ │ │ │ └─ [not]: integer #36 │ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 +│ │ │ │ └─ [lte]: optional #37 │ │ │ │ └─ item: integer #36 │ │ │ ├─ variant_4: struct #42 │ │ │ │ └─ [in]: list #38 @@ -715,165 +824,56 @@ root: struct #145 │ │ │ └─ variant_5: struct #43 │ │ │ └─ [notIn]: list #38 │ │ │ └─ item: integer #36 -│ │ ├─ [title]: optional '_79__string_filter_c?' #79 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 -│ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 -│ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [name]: optional '_81__string_filter_c?' #81 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [posts]: optional #90 -│ │ └─ item: union #89 -│ │ ├─ variant_0: struct #84 -│ │ │ └─ [every]: optional '_83_PostWhere?' #83 -│ │ │ └─ item: &PostWhere #82 -│ │ ├─ variant_1: struct #86 -│ │ │ └─ [some]: optional '_85_PostWhere?' #85 -│ │ │ └─ item: &PostWhere #82 -│ │ └─ variant_2: struct #88 -│ │ └─ [none]: optional '_87_PostWhere?' #87 -│ │ └─ item: &PostWhere #82 +│ │ └─ [title]: optional '_79__string_filter_c?' #79 +│ │ └─ item: optional '_string_filter_c' #33 +│ │ └─ item: union #32 +│ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_1: struct #31 +│ │ └─ [not]: union '_string_filter' #30 +│ │ ├─ variant_0: string #18 +│ │ ├─ variant_1: struct #21 +│ │ │ └─ [equals]: string #18 +│ │ ├─ variant_2: struct #22 +│ │ │ └─ [not]: string #18 +│ │ ├─ variant_3: struct #23 +│ │ │ └─ [in]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_4: struct #24 +│ │ │ └─ [notIn]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_5: struct #27 +│ │ │ ├─ [contains]: string #18 +│ │ │ └─ [mode]: optional #26 +│ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #28 +│ │ │ └─ [search]: string #18 +│ │ └─ variant_7: struct #29 +│ │ ├─ [endsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ [startsWith]: optional #19 +│ │ └─ item: string #18 │ ├─ variant_3: struct #110 │ │ └─ [update]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #109 │ │ ├─ [id]: optional #105 @@ -894,443 +894,552 @@ root: struct #145 │ │ └─ [set]: string #62 │ ├─ variant_4: struct #113 │ │ └─ [updateMany]: struct #112 -│ │ ├─ [where]: optional #111 -│ │ │ └─ item: union #95 -│ │ │ ├─ variant_0: struct 'PostWhere' #93 -│ │ │ │ ├─ [id]: optional '_78__integer_filter_c?' #78 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ │ └─ item: union #46 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_1: struct #45 -│ │ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [title]: optional '_79__string_filter_c?' #79 -│ │ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ │ └─ item: union #32 -│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ variant_1: struct #31 -│ │ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 -│ │ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 -│ │ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ │ └─ item: union #46 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_1: struct #45 -│ │ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 -│ │ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ │ └─ item: union #32 -│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ variant_1: struct #31 -│ │ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [posts]: optional #90 -│ │ │ │ └─ item: union #89 -│ │ │ │ ├─ variant_0: struct #84 -│ │ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 -│ │ │ │ │ └─ item: &PostWhere #82 -│ │ │ │ ├─ variant_1: struct #86 -│ │ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 -│ │ │ │ │ └─ item: &PostWhere #82 -│ │ │ │ └─ variant_2: struct #88 -│ │ │ │ └─ [none]: optional '_87_PostWhere?' #87 -│ │ │ │ └─ item: &PostWhere #82 -│ │ │ └─ variant_1: list '_94_PostWhere[]' #94 -│ │ │ └─ item: struct 'PostWhere' #93 -│ │ │ ├─ [id]: optional '_78__integer_filter_c?' #78 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_79__string_filter_c?' #79 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 -│ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 -│ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [posts]: optional #90 -│ │ │ └─ item: union #89 -│ │ │ ├─ variant_0: struct #84 -│ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 -│ │ │ │ └─ item: &PostWhere #82 -│ │ │ ├─ variant_1: struct #86 -│ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 -│ │ │ │ └─ item: &PostWhere #82 -│ │ │ └─ variant_2: struct #88 -│ │ │ └─ [none]: optional '_87_PostWhere?' #87 -│ │ │ └─ item: &PostWhere #82 -│ │ └─ [data]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #109 -│ │ ├─ [id]: optional #105 -│ │ │ └─ item: union #104 -│ │ │ ├─ variant_0: integer #61 -│ │ │ ├─ variant_1: struct #100 -│ │ │ │ └─ [set]: integer #61 -│ │ │ ├─ variant_2: struct #101 -│ │ │ │ └─ [multiply]: integer #61 -│ │ │ ├─ variant_3: struct #102 -│ │ │ │ └─ [decrement]: integer #61 -│ │ │ └─ variant_4: struct #103 -│ │ │ └─ [increment]: integer #61 -│ │ └─ [title]: optional #108 -│ │ └─ item: union #107 -│ │ ├─ variant_0: string #62 -│ │ └─ variant_1: struct #106 -│ │ └─ [set]: string #62 +│ │ ├─ [data]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #109 +│ │ │ ├─ [id]: optional #105 +│ │ │ │ └─ item: union #104 +│ │ │ │ ├─ variant_0: integer #61 +│ │ │ │ ├─ variant_1: struct #100 +│ │ │ │ │ └─ [set]: integer #61 +│ │ │ │ ├─ variant_2: struct #101 +│ │ │ │ │ └─ [multiply]: integer #61 +│ │ │ │ ├─ variant_3: struct #102 +│ │ │ │ │ └─ [decrement]: integer #61 +│ │ │ │ └─ variant_4: struct #103 +│ │ │ │ └─ [increment]: integer #61 +│ │ │ └─ [title]: optional #108 +│ │ │ └─ item: union #107 +│ │ │ ├─ variant_0: string #62 +│ │ │ └─ variant_1: struct #106 +│ │ │ └─ [set]: string #62 +│ │ └─ [where]: optional #111 +│ │ └─ item: union #95 +│ │ ├─ variant_0: struct 'PostWhere' #93 +│ │ │ ├─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 +│ │ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 +│ │ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 +│ │ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ │ └─ item: union #32 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ variant_1: struct #31 +│ │ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [posts]: optional #90 +│ │ │ │ └─ item: union #89 +│ │ │ │ ├─ variant_0: struct #84 +│ │ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 +│ │ │ │ │ └─ item: &PostWhere #82 +│ │ │ │ ├─ variant_1: struct #86 +│ │ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 +│ │ │ │ │ └─ item: &PostWhere #82 +│ │ │ │ └─ variant_2: struct #88 +│ │ │ │ └─ [none]: optional '_87_PostWhere?' #87 +│ │ │ │ └─ item: &PostWhere #82 +│ │ │ ├─ [id]: optional '_78__integer_filter_c?' #78 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ └─ [title]: optional '_79__string_filter_c?' #79 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_1: list '_94_PostWhere[]' #94 +│ │ └─ item: struct 'PostWhere' #93 +│ │ ├─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 +│ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 +│ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #90 +│ │ │ └─ item: union #89 +│ │ │ ├─ variant_0: struct #84 +│ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 +│ │ │ │ └─ item: &PostWhere #82 +│ │ │ ├─ variant_1: struct #86 +│ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 +│ │ │ │ └─ item: &PostWhere #82 +│ │ │ └─ variant_2: struct #88 +│ │ │ └─ [none]: optional '_87_PostWhere?' #87 +│ │ │ └─ item: &PostWhere #82 +│ │ ├─ [id]: optional '_78__integer_filter_c?' #78 +│ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ └─ item: union #46 +│ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ └─ variant_1: struct #45 +│ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ ├─ variant_0: integer #36 +│ │ │ ├─ variant_1: struct #39 +│ │ │ │ └─ [equals]: integer #36 +│ │ │ ├─ variant_2: struct #40 +│ │ │ │ └─ [not]: integer #36 +│ │ │ ├─ variant_3: struct #41 +│ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ [lte]: optional #37 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ variant_4: struct #42 +│ │ │ │ └─ [in]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ └─ variant_5: struct #43 +│ │ │ └─ [notIn]: list #38 +│ │ │ └─ item: integer #36 +│ │ └─ [title]: optional '_79__string_filter_c?' #79 +│ │ └─ item: optional '_string_filter_c' #33 +│ │ └─ item: union #32 +│ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_1: struct #31 +│ │ └─ [not]: union '_string_filter' #30 +│ │ ├─ variant_0: string #18 +│ │ ├─ variant_1: struct #21 +│ │ │ └─ [equals]: string #18 +│ │ ├─ variant_2: struct #22 +│ │ │ └─ [not]: string #18 +│ │ ├─ variant_3: struct #23 +│ │ │ └─ [in]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_4: struct #24 +│ │ │ └─ [notIn]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_5: struct #27 +│ │ │ ├─ [contains]: string #18 +│ │ │ └─ [mode]: optional #26 +│ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #28 +│ │ │ └─ [search]: string #18 +│ │ └─ variant_7: struct #29 +│ │ ├─ [endsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ [startsWith]: optional #19 +│ │ └─ item: string #18 │ ├─ variant_5: struct #116 │ │ └─ [deleteMany]: struct #115 │ │ └─ [where]: optional #114 │ │ └─ item: union #95 │ │ ├─ variant_0: struct 'PostWhere' #93 +│ │ │ ├─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 +│ │ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 +│ │ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ │ └─ item: union #46 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_1: struct #45 +│ │ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 +│ │ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ │ └─ item: union #32 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ variant_1: struct #31 +│ │ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [posts]: optional #90 +│ │ │ │ └─ item: union #89 +│ │ │ │ ├─ variant_0: struct #84 +│ │ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 +│ │ │ │ │ └─ item: &PostWhere #82 +│ │ │ │ ├─ variant_1: struct #86 +│ │ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 +│ │ │ │ │ └─ item: &PostWhere #82 +│ │ │ │ └─ variant_2: struct #88 +│ │ │ │ └─ [none]: optional '_87_PostWhere?' #87 +│ │ │ │ └─ item: &PostWhere #82 │ │ │ ├─ [id]: optional '_78__integer_filter_c?' #78 │ │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ │ └─ item: union #46 @@ -1341,13 +1450,13 @@ root: struct #145 │ │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ │ └─ [in]: list #38 @@ -1363,13 +1472,13 @@ root: struct #145 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -1377,167 +1486,167 @@ root: struct #145 │ │ │ │ └─ variant_5: struct #43 │ │ │ │ └─ [notIn]: list #38 │ │ │ │ └─ item: integer #36 -│ │ │ ├─ [title]: optional '_79__string_filter_c?' #79 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 -│ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 -│ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ │ └─ item: union #46 -│ │ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ variant_5: struct #43 -│ │ │ │ │ └─ [notIn]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_1: struct #45 -│ │ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 -│ │ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ │ └─ item: union #32 -│ │ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ │ ├─ variant_0: string #18 -│ │ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ │ └─ [not]: string #18 -│ │ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ │ └─ [search]: string #18 -│ │ │ │ │ └─ variant_7: struct #29 -│ │ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ │ └─ item: string #18 -│ │ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ variant_1: struct #31 -│ │ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [posts]: optional #90 -│ │ │ └─ item: union #89 -│ │ │ ├─ variant_0: struct #84 -│ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 -│ │ │ │ └─ item: &PostWhere #82 -│ │ │ ├─ variant_1: struct #86 -│ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 -│ │ │ │ └─ item: &PostWhere #82 -│ │ │ └─ variant_2: struct #88 -│ │ │ └─ [none]: optional '_87_PostWhere?' #87 -│ │ │ └─ item: &PostWhere #82 +│ │ │ └─ [title]: optional '_79__string_filter_c?' #79 +│ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ └─ item: union #32 +│ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ variant_1: struct #31 +│ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 │ │ └─ variant_1: list '_94_PostWhere[]' #94 │ │ └─ item: struct 'PostWhere' #93 +│ │ ├─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 +│ │ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 +│ │ │ ├─ [id]: optional '_80__integer_filter_c?' #80 +│ │ │ │ └─ item: optional '_integer_filter_c' #47 +│ │ │ │ └─ item: union #46 +│ │ │ │ ├─ variant_0: either '_integer_filter' #44 +│ │ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ variant_5: struct #43 +│ │ │ │ │ └─ [notIn]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_1: struct #45 +│ │ │ │ └─ [not]: either '_integer_filter' #44 +│ │ │ │ ├─ variant_0: integer #36 +│ │ │ │ ├─ variant_1: struct #39 +│ │ │ │ │ └─ [equals]: integer #36 +│ │ │ │ ├─ variant_2: struct #40 +│ │ │ │ │ └─ [not]: integer #36 +│ │ │ │ ├─ variant_3: struct #41 +│ │ │ │ │ ├─ [gt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ └─ [lte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ variant_4: struct #42 +│ │ │ │ │ └─ [in]: list #38 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ └─ variant_5: struct #43 +│ │ │ │ └─ [notIn]: list #38 +│ │ │ │ └─ item: integer #36 +│ │ │ ├─ [name]: optional '_81__string_filter_c?' #81 +│ │ │ │ └─ item: optional '_string_filter_c' #33 +│ │ │ │ └─ item: union #32 +│ │ │ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ │ │ ├─ variant_0: string #18 +│ │ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ │ └─ [not]: string #18 +│ │ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ │ └─ [search]: string #18 +│ │ │ │ │ └─ variant_7: struct #29 +│ │ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ │ └─ item: string #18 +│ │ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ variant_1: struct #31 +│ │ │ │ └─ [not]: union '_string_filter' #30 +│ │ │ │ ├─ variant_0: string #18 +│ │ │ │ ├─ variant_1: struct #21 +│ │ │ │ │ └─ [equals]: string #18 +│ │ │ │ ├─ variant_2: struct #22 +│ │ │ │ │ └─ [not]: string #18 +│ │ │ │ ├─ variant_3: struct #23 +│ │ │ │ │ └─ [in]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_4: struct #24 +│ │ │ │ │ └─ [notIn]: list #20 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ ├─ variant_5: struct #27 +│ │ │ │ │ ├─ [contains]: string #18 +│ │ │ │ │ └─ [mode]: optional #26 +│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #28 +│ │ │ │ │ └─ [search]: string #18 +│ │ │ │ └─ variant_7: struct #29 +│ │ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ │ └─ item: string #18 +│ │ │ │ └─ [startsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [posts]: optional #90 +│ │ │ └─ item: union #89 +│ │ │ ├─ variant_0: struct #84 +│ │ │ │ └─ [every]: optional '_83_PostWhere?' #83 +│ │ │ │ └─ item: &PostWhere #82 +│ │ │ ├─ variant_1: struct #86 +│ │ │ │ └─ [some]: optional '_85_PostWhere?' #85 +│ │ │ │ └─ item: &PostWhere #82 +│ │ │ └─ variant_2: struct #88 +│ │ │ └─ [none]: optional '_87_PostWhere?' #87 +│ │ │ └─ item: &PostWhere #82 │ │ ├─ [id]: optional '_78__integer_filter_c?' #78 │ │ │ └─ item: optional '_integer_filter_c' #47 │ │ │ └─ item: union #46 @@ -1548,13 +1657,13 @@ root: struct #145 │ │ │ │ ├─ variant_2: struct #40 │ │ │ │ │ └─ [not]: integer #36 │ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 │ │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ │ └─ item: integer #36 +│ │ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 +│ │ │ │ │ └─ [lte]: optional #37 │ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ variant_4: struct #42 │ │ │ │ │ └─ [in]: list #38 @@ -1570,13 +1679,13 @@ root: struct #145 │ │ │ ├─ variant_2: struct #40 │ │ │ │ └─ [not]: integer #36 │ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 │ │ │ │ ├─ [gt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 +│ │ │ │ ├─ [gte]: optional #37 +│ │ │ │ │ └─ item: integer #36 +│ │ │ │ ├─ [lt]: optional #37 │ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 +│ │ │ │ └─ [lte]: optional #37 │ │ │ │ └─ item: integer #36 │ │ │ ├─ variant_4: struct #42 │ │ │ │ └─ [in]: list #38 @@ -1584,165 +1693,56 @@ root: struct #145 │ │ │ └─ variant_5: struct #43 │ │ │ └─ [notIn]: list #38 │ │ │ └─ item: integer #36 -│ │ ├─ [title]: optional '_79__string_filter_c?' #79 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [author]: optional '_92_UserWhere__skip_64_PostWhere?' #92 -│ │ └─ item: struct 'UserWhere__skip_64_PostWhere' #91 -│ │ ├─ [id]: optional '_80__integer_filter_c?' #80 -│ │ │ └─ item: optional '_integer_filter_c' #47 -│ │ │ └─ item: union #46 -│ │ │ ├─ variant_0: either '_integer_filter' #44 -│ │ │ │ ├─ variant_0: integer #36 -│ │ │ │ ├─ variant_1: struct #39 -│ │ │ │ │ └─ [equals]: integer #36 -│ │ │ │ ├─ variant_2: struct #40 -│ │ │ │ │ └─ [not]: integer #36 -│ │ │ │ ├─ variant_3: struct #41 -│ │ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ │ └─ item: integer #36 -│ │ │ │ │ └─ [gte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ variant_4: struct #42 -│ │ │ │ │ └─ [in]: list #38 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ variant_5: struct #43 -│ │ │ │ └─ [notIn]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_1: struct #45 -│ │ │ └─ [not]: either '_integer_filter' #44 -│ │ │ ├─ variant_0: integer #36 -│ │ │ ├─ variant_1: struct #39 -│ │ │ │ └─ [equals]: integer #36 -│ │ │ ├─ variant_2: struct #40 -│ │ │ │ └─ [not]: integer #36 -│ │ │ ├─ variant_3: struct #41 -│ │ │ │ ├─ [lt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [gt]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ ├─ [lte]: optional #37 -│ │ │ │ │ └─ item: integer #36 -│ │ │ │ └─ [gte]: optional #37 -│ │ │ │ └─ item: integer #36 -│ │ │ ├─ variant_4: struct #42 -│ │ │ │ └─ [in]: list #38 -│ │ │ │ └─ item: integer #36 -│ │ │ └─ variant_5: struct #43 -│ │ │ └─ [notIn]: list #38 -│ │ │ └─ item: integer #36 -│ │ ├─ [name]: optional '_81__string_filter_c?' #81 -│ │ │ └─ item: optional '_string_filter_c' #33 -│ │ │ └─ item: union #32 -│ │ │ ├─ variant_0: union '_string_filter' #30 -│ │ │ │ ├─ variant_0: string #18 -│ │ │ │ ├─ variant_1: struct #21 -│ │ │ │ │ └─ [equals]: string #18 -│ │ │ │ ├─ variant_2: struct #22 -│ │ │ │ │ └─ [not]: string #18 -│ │ │ │ ├─ variant_3: struct #23 -│ │ │ │ │ └─ [in]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_4: struct #24 -│ │ │ │ │ └─ [notIn]: list #20 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ ├─ variant_5: struct #27 -│ │ │ │ │ ├─ [contains]: string #18 -│ │ │ │ │ └─ [mode]: optional #26 -│ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #28 -│ │ │ │ │ └─ [search]: string #18 -│ │ │ │ └─ variant_7: struct #29 -│ │ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ │ └─ item: string #18 -│ │ │ │ └─ [endsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ variant_1: struct #31 -│ │ │ └─ [not]: union '_string_filter' #30 -│ │ │ ├─ variant_0: string #18 -│ │ │ ├─ variant_1: struct #21 -│ │ │ │ └─ [equals]: string #18 -│ │ │ ├─ variant_2: struct #22 -│ │ │ │ └─ [not]: string #18 -│ │ │ ├─ variant_3: struct #23 -│ │ │ │ └─ [in]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_4: struct #24 -│ │ │ │ └─ [notIn]: list #20 -│ │ │ │ └─ item: string #18 -│ │ │ ├─ variant_5: struct #27 -│ │ │ │ ├─ [contains]: string #18 -│ │ │ │ └─ [mode]: optional #26 -│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #28 -│ │ │ │ └─ [search]: string #18 -│ │ │ └─ variant_7: struct #29 -│ │ │ ├─ [startsWith]: optional #19 -│ │ │ │ └─ item: string #18 -│ │ │ └─ [endsWith]: optional #19 -│ │ │ └─ item: string #18 -│ │ └─ [posts]: optional #90 -│ │ └─ item: union #89 -│ │ ├─ variant_0: struct #84 -│ │ │ └─ [every]: optional '_83_PostWhere?' #83 -│ │ │ └─ item: &PostWhere #82 -│ │ ├─ variant_1: struct #86 -│ │ │ └─ [some]: optional '_85_PostWhere?' #85 -│ │ │ └─ item: &PostWhere #82 -│ │ └─ variant_2: struct #88 -│ │ └─ [none]: optional '_87_PostWhere?' #87 -│ │ └─ item: &PostWhere #82 +│ │ └─ [title]: optional '_79__string_filter_c?' #79 +│ │ └─ item: optional '_string_filter_c' #33 +│ │ └─ item: union #32 +│ │ ├─ variant_0: union '_string_filter' #30 +│ │ │ ├─ variant_0: string #18 +│ │ │ ├─ variant_1: struct #21 +│ │ │ │ └─ [equals]: string #18 +│ │ │ ├─ variant_2: struct #22 +│ │ │ │ └─ [not]: string #18 +│ │ │ ├─ variant_3: struct #23 +│ │ │ │ └─ [in]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_4: struct #24 +│ │ │ │ └─ [notIn]: list #20 +│ │ │ │ └─ item: string #18 +│ │ │ ├─ variant_5: struct #27 +│ │ │ │ ├─ [contains]: string #18 +│ │ │ │ └─ [mode]: optional #26 +│ │ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #28 +│ │ │ │ └─ [search]: string #18 +│ │ │ └─ variant_7: struct #29 +│ │ │ ├─ [endsWith]: optional #19 +│ │ │ │ └─ item: string #18 +│ │ │ └─ [startsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ variant_1: struct #31 +│ │ └─ [not]: union '_string_filter' #30 +│ │ ├─ variant_0: string #18 +│ │ ├─ variant_1: struct #21 +│ │ │ └─ [equals]: string #18 +│ │ ├─ variant_2: struct #22 +│ │ │ └─ [not]: string #18 +│ │ ├─ variant_3: struct #23 +│ │ │ └─ [in]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_4: struct #24 +│ │ │ └─ [notIn]: list #20 +│ │ │ └─ item: string #18 +│ │ ├─ variant_5: struct #27 +│ │ │ ├─ [contains]: string #18 +│ │ │ └─ [mode]: optional #26 +│ │ │ └─ item: string #25 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #28 +│ │ │ └─ [search]: string #18 +│ │ └─ variant_7: struct #29 +│ │ ├─ [endsWith]: optional #19 +│ │ │ └─ item: string #18 +│ │ └─ [startsWith]: optional #19 +│ │ └─ item: string #18 │ └─ variant_6: struct #120 │ └─ [createMany]: optional #119 │ └─ item: struct #118 @@ -1758,6 +1758,14 @@ root: struct #145 │ │ └─ item: integer #61 │ └─ [title]: string #62 └─ [where]: struct 'QueryUserWhereUniqueInput' #144 + ├─ [AND]: optional '_142__141_QueryUserWhereUniqueInput[]?' #142 + │ └─ item: list '_141_QueryUserWhereUniqueInput[]' #141 + │ └─ item: &QueryUserWhereUniqueInput #140 + ├─ [NOT]: optional '_143_QueryUserWhereUniqueInput?' #143 + │ └─ item: &QueryUserWhereUniqueInput #140 + ├─ [OR]: optional '_142__141_QueryUserWhereUniqueInput[]?' #142 + │ └─ item: list '_141_QueryUserWhereUniqueInput[]' #141 + │ └─ item: &QueryUserWhereUniqueInput #140 ├─ [id]: optional '_124__integer_filter_c?' #124 │ └─ item: optional '_integer_filter_c' #47 │ └─ item: union #46 @@ -1768,13 +1776,13 @@ root: struct #145 │ │ ├─ variant_2: struct #40 │ │ │ └─ [not]: integer #36 │ │ ├─ variant_3: struct #41 - │ │ │ ├─ [lt]: optional #37 - │ │ │ │ └─ item: integer #36 │ │ │ ├─ [gt]: optional #37 │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [lte]: optional #37 + │ │ │ ├─ [gte]: optional #37 │ │ │ │ └─ item: integer #36 - │ │ │ └─ [gte]: optional #37 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 │ │ │ └─ item: integer #36 │ │ ├─ variant_4: struct #42 │ │ │ └─ [in]: list #38 @@ -1790,13 +1798,13 @@ root: struct #145 │ ├─ variant_2: struct #40 │ │ └─ [not]: integer #36 │ ├─ variant_3: struct #41 - │ │ ├─ [lt]: optional #37 - │ │ │ └─ item: integer #36 │ │ ├─ [gt]: optional #37 │ │ │ └─ item: integer #36 - │ │ ├─ [lte]: optional #37 + │ │ ├─ [gte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [lt]: optional #37 │ │ │ └─ item: integer #36 - │ │ └─ [gte]: optional #37 + │ │ └─ [lte]: optional #37 │ │ └─ item: integer #36 │ ├─ variant_4: struct #42 │ │ └─ [in]: list #38 @@ -1826,9 +1834,9 @@ root: struct #145 │ │ ├─ variant_6: struct #28 │ │ │ └─ [search]: string #18 │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 + │ │ ├─ [endsWith]: optional #19 │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 + │ │ └─ [startsWith]: optional #19 │ │ └─ item: string #18 │ └─ variant_1: struct #31 │ └─ [not]: union '_string_filter' #30 @@ -1850,321 +1858,313 @@ root: struct #145 │ ├─ variant_6: struct #28 │ │ └─ [search]: string #18 │ └─ variant_7: struct #29 - │ ├─ [startsWith]: optional #19 + │ ├─ [endsWith]: optional #19 │ │ └─ item: string #18 - │ └─ [endsWith]: optional #19 + │ └─ [startsWith]: optional #19 │ └─ item: string #18 - ├─ [posts]: optional #138 - │ └─ item: union #137 - │ ├─ variant_0: struct #132 - │ │ └─ [every]: optional '_131_PostWhere__skip_60_UserWhere?' #131 - │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 - │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 - │ │ │ └─ item: optional '_integer_filter_c' #47 - │ │ │ └─ item: union #46 - │ │ │ ├─ variant_0: either '_integer_filter' #44 - │ │ │ │ ├─ variant_0: integer #36 - │ │ │ │ ├─ variant_1: struct #39 - │ │ │ │ │ └─ [equals]: integer #36 - │ │ │ │ ├─ variant_2: struct #40 - │ │ │ │ │ └─ [not]: integer #36 - │ │ │ │ ├─ variant_3: struct #41 - │ │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ ├─ [gt]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ ├─ [lte]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ └─ [gte]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ variant_4: struct #42 - │ │ │ │ │ └─ [in]: list #38 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ variant_5: struct #43 - │ │ │ │ └─ [notIn]: list #38 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ variant_1: struct #45 - │ │ │ └─ [not]: either '_integer_filter' #44 - │ │ │ ├─ variant_0: integer #36 - │ │ │ ├─ variant_1: struct #39 - │ │ │ │ └─ [equals]: integer #36 - │ │ │ ├─ variant_2: struct #40 - │ │ │ │ └─ [not]: integer #36 - │ │ │ ├─ variant_3: struct #41 - │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [gt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [lte]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ [gte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ variant_4: struct #42 - │ │ │ │ └─ [in]: list #38 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ variant_5: struct #43 - │ │ │ └─ [notIn]: list #38 - │ │ │ └─ item: integer #36 - │ │ ├─ [title]: optional '_127__string_filter_c?' #127 - │ │ │ └─ item: optional '_string_filter_c' #33 - │ │ │ └─ item: union #32 - │ │ │ ├─ variant_0: union '_string_filter' #30 - │ │ │ │ ├─ variant_0: string #18 - │ │ │ │ ├─ variant_1: struct #21 - │ │ │ │ │ └─ [equals]: string #18 - │ │ │ │ ├─ variant_2: struct #22 - │ │ │ │ │ └─ [not]: string #18 - │ │ │ │ ├─ variant_3: struct #23 - │ │ │ │ │ └─ [in]: list #20 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ ├─ variant_4: struct #24 - │ │ │ │ │ └─ [notIn]: list #20 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ ├─ variant_5: struct #27 - │ │ │ │ │ ├─ [contains]: string #18 - │ │ │ │ │ └─ [mode]: optional #26 - │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #28 - │ │ │ │ │ └─ [search]: string #18 - │ │ │ │ └─ variant_7: struct #29 - │ │ │ │ ├─ [startsWith]: optional #19 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ └─ [endsWith]: optional #19 - │ │ │ │ └─ item: string #18 - │ │ │ └─ variant_1: struct #31 - │ │ │ └─ [not]: union '_string_filter' #30 - │ │ │ ├─ variant_0: string #18 - │ │ │ ├─ variant_1: struct #21 - │ │ │ │ └─ [equals]: string #18 - │ │ │ ├─ variant_2: struct #22 - │ │ │ │ └─ [not]: string #18 - │ │ │ ├─ variant_3: struct #23 - │ │ │ │ └─ [in]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_4: struct #24 - │ │ │ │ └─ [notIn]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_5: struct #27 - │ │ │ │ ├─ [contains]: string #18 - │ │ │ │ └─ [mode]: optional #26 - │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #28 - │ │ │ │ └─ [search]: string #18 - │ │ │ └─ variant_7: struct #29 - │ │ │ ├─ [startsWith]: optional #19 - │ │ │ │ └─ item: string #18 - │ │ │ └─ [endsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ [author]: optional '_129_UserWhere?' #129 - │ │ └─ item: &UserWhere #128 - │ ├─ variant_1: struct #134 - │ │ └─ [some]: optional '_133_PostWhere__skip_60_UserWhere?' #133 - │ │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 - │ │ ├─ [id]: optional '_126__integer_filter_c?' #126 - │ │ │ └─ item: optional '_integer_filter_c' #47 - │ │ │ └─ item: union #46 - │ │ │ ├─ variant_0: either '_integer_filter' #44 - │ │ │ │ ├─ variant_0: integer #36 - │ │ │ │ ├─ variant_1: struct #39 - │ │ │ │ │ └─ [equals]: integer #36 - │ │ │ │ ├─ variant_2: struct #40 - │ │ │ │ │ └─ [not]: integer #36 - │ │ │ │ ├─ variant_3: struct #41 - │ │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ ├─ [gt]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ ├─ [lte]: optional #37 - │ │ │ │ │ │ └─ item: integer #36 - │ │ │ │ │ └─ [gte]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ variant_4: struct #42 - │ │ │ │ │ └─ [in]: list #38 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ variant_5: struct #43 - │ │ │ │ └─ [notIn]: list #38 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ variant_1: struct #45 - │ │ │ └─ [not]: either '_integer_filter' #44 - │ │ │ ├─ variant_0: integer #36 - │ │ │ ├─ variant_1: struct #39 - │ │ │ │ └─ [equals]: integer #36 - │ │ │ ├─ variant_2: struct #40 - │ │ │ │ └─ [not]: integer #36 - │ │ │ ├─ variant_3: struct #41 - │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [gt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [lte]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ [gte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ variant_4: struct #42 - │ │ │ │ └─ [in]: list #38 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ variant_5: struct #43 - │ │ │ └─ [notIn]: list #38 - │ │ │ └─ item: integer #36 - │ │ ├─ [title]: optional '_127__string_filter_c?' #127 - │ │ │ └─ item: optional '_string_filter_c' #33 - │ │ │ └─ item: union #32 - │ │ │ ├─ variant_0: union '_string_filter' #30 - │ │ │ │ ├─ variant_0: string #18 - │ │ │ │ ├─ variant_1: struct #21 - │ │ │ │ │ └─ [equals]: string #18 - │ │ │ │ ├─ variant_2: struct #22 - │ │ │ │ │ └─ [not]: string #18 - │ │ │ │ ├─ variant_3: struct #23 - │ │ │ │ │ └─ [in]: list #20 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ ├─ variant_4: struct #24 - │ │ │ │ │ └─ [notIn]: list #20 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ ├─ variant_5: struct #27 - │ │ │ │ │ ├─ [contains]: string #18 - │ │ │ │ │ └─ [mode]: optional #26 - │ │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ │ │ ├─ variant_6: struct #28 - │ │ │ │ │ └─ [search]: string #18 - │ │ │ │ └─ variant_7: struct #29 - │ │ │ │ ├─ [startsWith]: optional #19 - │ │ │ │ │ └─ item: string #18 - │ │ │ │ └─ [endsWith]: optional #19 - │ │ │ │ └─ item: string #18 - │ │ │ └─ variant_1: struct #31 - │ │ │ └─ [not]: union '_string_filter' #30 - │ │ │ ├─ variant_0: string #18 - │ │ │ ├─ variant_1: struct #21 - │ │ │ │ └─ [equals]: string #18 - │ │ │ ├─ variant_2: struct #22 - │ │ │ │ └─ [not]: string #18 - │ │ │ ├─ variant_3: struct #23 - │ │ │ │ └─ [in]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_4: struct #24 - │ │ │ │ └─ [notIn]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_5: struct #27 - │ │ │ │ ├─ [contains]: string #18 - │ │ │ │ └─ [mode]: optional #26 - │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #28 - │ │ │ │ └─ [search]: string #18 - │ │ │ └─ variant_7: struct #29 - │ │ │ ├─ [startsWith]: optional #19 - │ │ │ │ └─ item: string #18 - │ │ │ └─ [endsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ [author]: optional '_129_UserWhere?' #129 - │ │ └─ item: &UserWhere #128 - │ └─ variant_2: struct #136 - │ └─ [none]: optional '_135_PostWhere__skip_60_UserWhere?' #135 - │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 - │ ├─ [id]: optional '_126__integer_filter_c?' #126 - │ │ └─ item: optional '_integer_filter_c' #47 - │ │ └─ item: union #46 - │ │ ├─ variant_0: either '_integer_filter' #44 - │ │ │ ├─ variant_0: integer #36 - │ │ │ ├─ variant_1: struct #39 - │ │ │ │ └─ [equals]: integer #36 - │ │ │ ├─ variant_2: struct #40 - │ │ │ │ └─ [not]: integer #36 - │ │ │ ├─ variant_3: struct #41 - │ │ │ │ ├─ [lt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [gt]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ ├─ [lte]: optional #37 - │ │ │ │ │ └─ item: integer #36 - │ │ │ │ └─ [gte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ variant_4: struct #42 - │ │ │ │ └─ [in]: list #38 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ variant_5: struct #43 - │ │ │ └─ [notIn]: list #38 - │ │ │ └─ item: integer #36 - │ │ └─ variant_1: struct #45 - │ │ └─ [not]: either '_integer_filter' #44 - │ │ ├─ variant_0: integer #36 - │ │ ├─ variant_1: struct #39 - │ │ │ └─ [equals]: integer #36 - │ │ ├─ variant_2: struct #40 - │ │ │ └─ [not]: integer #36 - │ │ ├─ variant_3: struct #41 - │ │ │ ├─ [lt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [gt]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ ├─ [lte]: optional #37 - │ │ │ │ └─ item: integer #36 - │ │ │ └─ [gte]: optional #37 - │ │ │ └─ item: integer #36 - │ │ ├─ variant_4: struct #42 - │ │ │ └─ [in]: list #38 - │ │ │ └─ item: integer #36 - │ │ └─ variant_5: struct #43 - │ │ └─ [notIn]: list #38 - │ │ └─ item: integer #36 - │ ├─ [title]: optional '_127__string_filter_c?' #127 - │ │ └─ item: optional '_string_filter_c' #33 - │ │ └─ item: union #32 - │ │ ├─ variant_0: union '_string_filter' #30 - │ │ │ ├─ variant_0: string #18 - │ │ │ ├─ variant_1: struct #21 - │ │ │ │ └─ [equals]: string #18 - │ │ │ ├─ variant_2: struct #22 - │ │ │ │ └─ [not]: string #18 - │ │ │ ├─ variant_3: struct #23 - │ │ │ │ └─ [in]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_4: struct #24 - │ │ │ │ └─ [notIn]: list #20 - │ │ │ │ └─ item: string #18 - │ │ │ ├─ variant_5: struct #27 - │ │ │ │ ├─ [contains]: string #18 - │ │ │ │ └─ [mode]: optional #26 - │ │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #28 - │ │ │ │ └─ [search]: string #18 - │ │ │ └─ variant_7: struct #29 - │ │ │ ├─ [startsWith]: optional #19 - │ │ │ │ └─ item: string #18 - │ │ │ └─ [endsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ variant_1: struct #31 - │ │ └─ [not]: union '_string_filter' #30 - │ │ ├─ variant_0: string #18 - │ │ ├─ variant_1: struct #21 - │ │ │ └─ [equals]: string #18 - │ │ ├─ variant_2: struct #22 - │ │ │ └─ [not]: string #18 - │ │ ├─ variant_3: struct #23 - │ │ │ └─ [in]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_4: struct #24 - │ │ │ └─ [notIn]: list #20 - │ │ │ └─ item: string #18 - │ │ ├─ variant_5: struct #27 - │ │ │ ├─ [contains]: string #18 - │ │ │ └─ [mode]: optional #26 - │ │ │ └─ item: string #25 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #28 - │ │ │ └─ [search]: string #18 - │ │ └─ variant_7: struct #29 - │ │ ├─ [startsWith]: optional #19 - │ │ │ └─ item: string #18 - │ │ └─ [endsWith]: optional #19 - │ │ └─ item: string #18 - │ └─ [author]: optional '_129_UserWhere?' #129 - │ └─ item: &UserWhere #128 - ├─ [AND]: optional '_142__141_QueryUserWhereUniqueInput[]?' #142 - │ └─ item: list '_141_QueryUserWhereUniqueInput[]' #141 - │ └─ item: &QueryUserWhereUniqueInput #140 - ├─ [OR]: optional '_142__141_QueryUserWhereUniqueInput[]?' #142 - │ └─ item: list '_141_QueryUserWhereUniqueInput[]' #141 - │ └─ item: &QueryUserWhereUniqueInput #140 - └─ [NOT]: optional '_143_QueryUserWhereUniqueInput?' #143 - └─ item: &QueryUserWhereUniqueInput #140 + └─ [posts]: optional #138 + └─ item: union #137 + ├─ variant_0: struct #132 + │ └─ [every]: optional '_131_PostWhere__skip_60_UserWhere?' #131 + │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 + │ ├─ [author]: optional '_129_UserWhere?' #129 + │ │ └─ item: &UserWhere #128 + │ ├─ [id]: optional '_126__integer_filter_c?' #126 + │ │ └─ item: optional '_integer_filter_c' #47 + │ │ └─ item: union #46 + │ │ ├─ variant_0: either '_integer_filter' #44 + │ │ │ ├─ variant_0: integer #36 + │ │ │ ├─ variant_1: struct #39 + │ │ │ │ └─ [equals]: integer #36 + │ │ │ ├─ variant_2: struct #40 + │ │ │ │ └─ [not]: integer #36 + │ │ │ ├─ variant_3: struct #41 + │ │ │ │ ├─ [gt]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ ├─ [gte]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ ├─ [lt]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ └─ [lte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ variant_4: struct #42 + │ │ │ │ └─ [in]: list #38 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ variant_5: struct #43 + │ │ │ └─ [notIn]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_1: struct #45 + │ │ └─ [not]: either '_integer_filter' #44 + │ │ ├─ variant_0: integer #36 + │ │ ├─ variant_1: struct #39 + │ │ │ └─ [equals]: integer #36 + │ │ ├─ variant_2: struct #40 + │ │ │ └─ [not]: integer #36 + │ │ ├─ variant_3: struct #41 + │ │ │ ├─ [gt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ variant_4: struct #42 + │ │ │ └─ [in]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_5: struct #43 + │ │ └─ [notIn]: list #38 + │ │ └─ item: integer #36 + │ └─ [title]: optional '_127__string_filter_c?' #127 + │ └─ item: optional '_string_filter_c' #33 + │ └─ item: union #32 + │ ├─ variant_0: union '_string_filter' #30 + │ │ ├─ variant_0: string #18 + │ │ ├─ variant_1: struct #21 + │ │ │ └─ [equals]: string #18 + │ │ ├─ variant_2: struct #22 + │ │ │ └─ [not]: string #18 + │ │ ├─ variant_3: struct #23 + │ │ │ └─ [in]: list #20 + │ │ │ └─ item: string #18 + │ │ ├─ variant_4: struct #24 + │ │ │ └─ [notIn]: list #20 + │ │ │ └─ item: string #18 + │ │ ├─ variant_5: struct #27 + │ │ │ ├─ [contains]: string #18 + │ │ │ └─ [mode]: optional #26 + │ │ │ └─ item: string #25 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #28 + │ │ │ └─ [search]: string #18 + │ │ └─ variant_7: struct #29 + │ │ ├─ [endsWith]: optional #19 + │ │ │ └─ item: string #18 + │ │ └─ [startsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ variant_1: struct #31 + │ └─ [not]: union '_string_filter' #30 + │ ├─ variant_0: string #18 + │ ├─ variant_1: struct #21 + │ │ └─ [equals]: string #18 + │ ├─ variant_2: struct #22 + │ │ └─ [not]: string #18 + │ ├─ variant_3: struct #23 + │ │ └─ [in]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_4: struct #24 + │ │ └─ [notIn]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_5: struct #27 + │ │ ├─ [contains]: string #18 + │ │ └─ [mode]: optional #26 + │ │ └─ item: string #25 enum{ '"insensitive"' } + │ ├─ variant_6: struct #28 + │ │ └─ [search]: string #18 + │ └─ variant_7: struct #29 + │ ├─ [endsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ [startsWith]: optional #19 + │ └─ item: string #18 + ├─ variant_1: struct #134 + │ └─ [some]: optional '_133_PostWhere__skip_60_UserWhere?' #133 + │ └─ item: struct 'PostWhere__skip_60_UserWhere' #130 + │ ├─ [author]: optional '_129_UserWhere?' #129 + │ │ └─ item: &UserWhere #128 + │ ├─ [id]: optional '_126__integer_filter_c?' #126 + │ │ └─ item: optional '_integer_filter_c' #47 + │ │ └─ item: union #46 + │ │ ├─ variant_0: either '_integer_filter' #44 + │ │ │ ├─ variant_0: integer #36 + │ │ │ ├─ variant_1: struct #39 + │ │ │ │ └─ [equals]: integer #36 + │ │ │ ├─ variant_2: struct #40 + │ │ │ │ └─ [not]: integer #36 + │ │ │ ├─ variant_3: struct #41 + │ │ │ │ ├─ [gt]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ ├─ [gte]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ ├─ [lt]: optional #37 + │ │ │ │ │ └─ item: integer #36 + │ │ │ │ └─ [lte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ variant_4: struct #42 + │ │ │ │ └─ [in]: list #38 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ variant_5: struct #43 + │ │ │ └─ [notIn]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_1: struct #45 + │ │ └─ [not]: either '_integer_filter' #44 + │ │ ├─ variant_0: integer #36 + │ │ ├─ variant_1: struct #39 + │ │ │ └─ [equals]: integer #36 + │ │ ├─ variant_2: struct #40 + │ │ │ └─ [not]: integer #36 + │ │ ├─ variant_3: struct #41 + │ │ │ ├─ [gt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ variant_4: struct #42 + │ │ │ └─ [in]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_5: struct #43 + │ │ └─ [notIn]: list #38 + │ │ └─ item: integer #36 + │ └─ [title]: optional '_127__string_filter_c?' #127 + │ └─ item: optional '_string_filter_c' #33 + │ └─ item: union #32 + │ ├─ variant_0: union '_string_filter' #30 + │ │ ├─ variant_0: string #18 + │ │ ├─ variant_1: struct #21 + │ │ │ └─ [equals]: string #18 + │ │ ├─ variant_2: struct #22 + │ │ │ └─ [not]: string #18 + │ │ ├─ variant_3: struct #23 + │ │ │ └─ [in]: list #20 + │ │ │ └─ item: string #18 + │ │ ├─ variant_4: struct #24 + │ │ │ └─ [notIn]: list #20 + │ │ │ └─ item: string #18 + │ │ ├─ variant_5: struct #27 + │ │ │ ├─ [contains]: string #18 + │ │ │ └─ [mode]: optional #26 + │ │ │ └─ item: string #25 enum{ '"insensitive"' } + │ │ ├─ variant_6: struct #28 + │ │ │ └─ [search]: string #18 + │ │ └─ variant_7: struct #29 + │ │ ├─ [endsWith]: optional #19 + │ │ │ └─ item: string #18 + │ │ └─ [startsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ variant_1: struct #31 + │ └─ [not]: union '_string_filter' #30 + │ ├─ variant_0: string #18 + │ ├─ variant_1: struct #21 + │ │ └─ [equals]: string #18 + │ ├─ variant_2: struct #22 + │ │ └─ [not]: string #18 + │ ├─ variant_3: struct #23 + │ │ └─ [in]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_4: struct #24 + │ │ └─ [notIn]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_5: struct #27 + │ │ ├─ [contains]: string #18 + │ │ └─ [mode]: optional #26 + │ │ └─ item: string #25 enum{ '"insensitive"' } + │ ├─ variant_6: struct #28 + │ │ └─ [search]: string #18 + │ └─ variant_7: struct #29 + │ ├─ [endsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ [startsWith]: optional #19 + │ └─ item: string #18 + └─ variant_2: struct #136 + └─ [none]: optional '_135_PostWhere__skip_60_UserWhere?' #135 + └─ item: struct 'PostWhere__skip_60_UserWhere' #130 + ├─ [author]: optional '_129_UserWhere?' #129 + │ └─ item: &UserWhere #128 + ├─ [id]: optional '_126__integer_filter_c?' #126 + │ └─ item: optional '_integer_filter_c' #47 + │ └─ item: union #46 + │ ├─ variant_0: either '_integer_filter' #44 + │ │ ├─ variant_0: integer #36 + │ │ ├─ variant_1: struct #39 + │ │ │ └─ [equals]: integer #36 + │ │ ├─ variant_2: struct #40 + │ │ │ └─ [not]: integer #36 + │ │ ├─ variant_3: struct #41 + │ │ │ ├─ [gt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [gte]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ ├─ [lt]: optional #37 + │ │ │ │ └─ item: integer #36 + │ │ │ └─ [lte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ variant_4: struct #42 + │ │ │ └─ [in]: list #38 + │ │ │ └─ item: integer #36 + │ │ └─ variant_5: struct #43 + │ │ └─ [notIn]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_1: struct #45 + │ └─ [not]: either '_integer_filter' #44 + │ ├─ variant_0: integer #36 + │ ├─ variant_1: struct #39 + │ │ └─ [equals]: integer #36 + │ ├─ variant_2: struct #40 + │ │ └─ [not]: integer #36 + │ ├─ variant_3: struct #41 + │ │ ├─ [gt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [gte]: optional #37 + │ │ │ └─ item: integer #36 + │ │ ├─ [lt]: optional #37 + │ │ │ └─ item: integer #36 + │ │ └─ [lte]: optional #37 + │ │ └─ item: integer #36 + │ ├─ variant_4: struct #42 + │ │ └─ [in]: list #38 + │ │ └─ item: integer #36 + │ └─ variant_5: struct #43 + │ └─ [notIn]: list #38 + │ └─ item: integer #36 + └─ [title]: optional '_127__string_filter_c?' #127 + └─ item: optional '_string_filter_c' #33 + └─ item: union #32 + ├─ variant_0: union '_string_filter' #30 + │ ├─ variant_0: string #18 + │ ├─ variant_1: struct #21 + │ │ └─ [equals]: string #18 + │ ├─ variant_2: struct #22 + │ │ └─ [not]: string #18 + │ ├─ variant_3: struct #23 + │ │ └─ [in]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_4: struct #24 + │ │ └─ [notIn]: list #20 + │ │ └─ item: string #18 + │ ├─ variant_5: struct #27 + │ │ ├─ [contains]: string #18 + │ │ └─ [mode]: optional #26 + │ │ └─ item: string #25 enum{ '"insensitive"' } + │ ├─ variant_6: struct #28 + │ │ └─ [search]: string #18 + │ └─ variant_7: struct #29 + │ ├─ [endsWith]: optional #19 + │ │ └─ item: string #18 + │ └─ [startsWith]: optional #19 + │ └─ item: string #18 + └─ variant_1: struct #31 + └─ [not]: union '_string_filter' #30 + ├─ variant_0: string #18 + ├─ variant_1: struct #21 + │ └─ [equals]: string #18 + ├─ variant_2: struct #22 + │ └─ [not]: string #18 + ├─ variant_3: struct #23 + │ └─ [in]: list #20 + │ └─ item: string #18 + ├─ variant_4: struct #24 + │ └─ [notIn]: list #20 + │ └─ item: string #18 + ├─ variant_5: struct #27 + │ ├─ [contains]: string #18 + │ └─ [mode]: optional #26 + │ └─ item: string #25 enum{ '"insensitive"' } + ├─ variant_6: struct #28 + │ └─ [search]: string #18 + └─ variant_7: struct #29 + ├─ [endsWith]: optional #19 + │ └─ item: string #18 + └─ [startsWith]: optional #19 + └─ item: string #18 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where Post.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where Post.snap index ed9359323..225a8c4c5 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where Post.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where Post.snap @@ -3,209 +3,209 @@ source: typegraph/core/src/runtimes/prisma/type_generation/where_.rs expression: "tree::print(context.generate(&Where::new(post))?)" --- root: struct 'PostWhere' #77 -├─ [id]: optional '_62__integer_filter_c?' #62 -│ └─ item: optional '_integer_filter_c' #34 -│ └─ item: union #33 -│ ├─ variant_0: either '_integer_filter' #31 -│ │ ├─ variant_0: integer #23 -│ │ ├─ variant_1: struct #26 -│ │ │ └─ [equals]: integer #23 -│ │ ├─ variant_2: struct #27 -│ │ │ └─ [not]: integer #23 -│ │ ├─ variant_3: struct #28 -│ │ │ ├─ [lt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [gt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [lte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ [gte]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ variant_4: struct #29 -│ │ │ └─ [in]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_5: struct #30 -│ │ └─ [notIn]: list #25 -│ │ └─ item: integer #23 -│ └─ variant_1: struct #32 -│ └─ [not]: either '_integer_filter' #31 -│ ├─ variant_0: integer #23 -│ ├─ variant_1: struct #26 -│ │ └─ [equals]: integer #23 -│ ├─ variant_2: struct #27 -│ │ └─ [not]: integer #23 -│ ├─ variant_3: struct #28 -│ │ ├─ [lt]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ [gt]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ [lte]: optional #24 -│ │ │ └─ item: integer #23 -│ │ └─ [gte]: optional #24 -│ │ └─ item: integer #23 -│ ├─ variant_4: struct #29 -│ │ └─ [in]: list #25 -│ │ └─ item: integer #23 -│ └─ variant_5: struct #30 -│ └─ [notIn]: list #25 -│ └─ item: integer #23 -├─ [title]: optional '_63__string_filter_c?' #63 -│ └─ item: optional '_string_filter_c' #20 -│ └─ item: union #19 -│ ├─ variant_0: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ └─ variant_1: struct #18 -│ └─ [not]: union '_string_filter' #17 -│ ├─ variant_0: string #5 -│ ├─ variant_1: struct #8 -│ │ └─ [equals]: string #5 -│ ├─ variant_2: struct #9 -│ │ └─ [not]: string #5 -│ ├─ variant_3: struct #10 -│ │ └─ [in]: list #7 -│ │ └─ item: string #5 -│ ├─ variant_4: struct #11 -│ │ └─ [notIn]: list #7 -│ │ └─ item: string #5 -│ ├─ variant_5: struct #14 -│ │ ├─ [contains]: string #5 -│ │ └─ [mode]: optional #13 -│ │ └─ item: string #12 enum{ '"insensitive"' } -│ ├─ variant_6: struct #15 -│ │ └─ [search]: string #5 -│ └─ variant_7: struct #16 -│ ├─ [startsWith]: optional #6 -│ │ └─ item: string #5 -│ └─ [endsWith]: optional #6 -│ └─ item: string #5 -└─ [author]: optional '_76_UserWhere__skip_45_PostWhere?' #76 - └─ item: struct 'UserWhere__skip_45_PostWhere' #75 - ├─ [id]: optional '_64__integer_filter_c?' #64 - │ └─ item: optional '_integer_filter_c' #34 - │ └─ item: union #33 - │ ├─ variant_0: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_1: struct #32 - │ └─ [not]: either '_integer_filter' #31 - │ ├─ variant_0: integer #23 - │ ├─ variant_1: struct #26 - │ │ └─ [equals]: integer #23 - │ ├─ variant_2: struct #27 - │ │ └─ [not]: integer #23 - │ ├─ variant_3: struct #28 - │ │ ├─ [lt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [gt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [lte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ └─ [gte]: optional #24 - │ │ └─ item: integer #23 - │ ├─ variant_4: struct #29 - │ │ └─ [in]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_5: struct #30 - │ └─ [notIn]: list #25 - │ └─ item: integer #23 - ├─ [name]: optional '_65__string_filter_c?' #65 - │ └─ item: optional '_string_filter_c' #20 - │ └─ item: union #19 - │ ├─ variant_0: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ variant_1: struct #18 - │ └─ [not]: union '_string_filter' #17 - │ ├─ variant_0: string #5 - │ ├─ variant_1: struct #8 - │ │ └─ [equals]: string #5 - │ ├─ variant_2: struct #9 - │ │ └─ [not]: string #5 - │ ├─ variant_3: struct #10 - │ │ └─ [in]: list #7 - │ │ └─ item: string #5 - │ ├─ variant_4: struct #11 - │ │ └─ [notIn]: list #7 - │ │ └─ item: string #5 - │ ├─ variant_5: struct #14 - │ │ ├─ [contains]: string #5 - │ │ └─ [mode]: optional #13 - │ │ └─ item: string #12 enum{ '"insensitive"' } - │ ├─ variant_6: struct #15 - │ │ └─ [search]: string #5 - │ └─ variant_7: struct #16 - │ ├─ [startsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [endsWith]: optional #6 - │ └─ item: string #5 - └─ [posts]: optional #74 - └─ item: union #73 - ├─ variant_0: struct #68 - │ └─ [every]: optional '_67_PostWhere?' #67 - │ └─ item: &PostWhere #66 - ├─ variant_1: struct #70 - │ └─ [some]: optional '_69_PostWhere?' #69 - │ └─ item: &PostWhere #66 - └─ variant_2: struct #72 - └─ [none]: optional '_71_PostWhere?' #71 - └─ item: &PostWhere #66 +├── [author]: optional '_76_UserWhere__skip_45_PostWhere?' #76 +│ └── item: struct 'UserWhere__skip_45_PostWhere' #75 +│ ├── [id]: optional '_64__integer_filter_c?' #64 +│ │ └── item: optional '_integer_filter_c' #34 +│ │ └── item: union #33 +│ │ ├── variant_0: either '_integer_filter' #31 +│ │ │ ├── variant_0: integer #23 +│ │ │ ├── variant_1: struct #26 +│ │ │ │ └── [equals]: integer #23 +│ │ │ ├── variant_2: struct #27 +│ │ │ │ └── [not]: integer #23 +│ │ │ ├── variant_3: struct #28 +│ │ │ │ ├── [gt]: optional #24 +│ │ │ │ │ └── item: integer #23 +│ │ │ │ ├── [gte]: optional #24 +│ │ │ │ │ └── item: integer #23 +│ │ │ │ ├── [lt]: optional #24 +│ │ │ │ │ └── item: integer #23 +│ │ │ │ └── [lte]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ ├── variant_4: struct #29 +│ │ │ │ └── [in]: list #25 +│ │ │ │ └── item: integer #23 +│ │ │ └── variant_5: struct #30 +│ │ │ └── [notIn]: list #25 +│ │ │ └── item: integer #23 +│ │ └── variant_1: struct #32 +│ │ └── [not]: either '_integer_filter' #31 +│ │ ├── variant_0: integer #23 +│ │ ├── variant_1: struct #26 +│ │ │ └── [equals]: integer #23 +│ │ ├── variant_2: struct #27 +│ │ │ └── [not]: integer #23 +│ │ ├── variant_3: struct #28 +│ │ │ ├── [gt]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ ├── [gte]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ ├── [lt]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ └── [lte]: optional #24 +│ │ │ └── item: integer #23 +│ │ ├── variant_4: struct #29 +│ │ │ └── [in]: list #25 +│ │ │ └── item: integer #23 +│ │ └── variant_5: struct #30 +│ │ └── [notIn]: list #25 +│ │ └── item: integer #23 +│ ├── [name]: optional '_65__string_filter_c?' #65 +│ │ └── item: optional '_string_filter_c' #20 +│ │ └── item: union #19 +│ │ ├── variant_0: union '_string_filter' #17 +│ │ │ ├── variant_0: string #5 +│ │ │ ├── variant_1: struct #8 +│ │ │ │ └── [equals]: string #5 +│ │ │ ├── variant_2: struct #9 +│ │ │ │ └── [not]: string #5 +│ │ │ ├── variant_3: struct #10 +│ │ │ │ └── [in]: list #7 +│ │ │ │ └── item: string #5 +│ │ │ ├── variant_4: struct #11 +│ │ │ │ └── [notIn]: list #7 +│ │ │ │ └── item: string #5 +│ │ │ ├── variant_5: struct #14 +│ │ │ │ ├── [contains]: string #5 +│ │ │ │ └── [mode]: optional #13 +│ │ │ │ └── item: string #12 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #15 +│ │ │ │ └── [search]: string #5 +│ │ │ └── variant_7: struct #16 +│ │ │ ├── [endsWith]: optional #6 +│ │ │ │ └── item: string #5 +│ │ │ └── [startsWith]: optional #6 +│ │ │ └── item: string #5 +│ │ └── variant_1: struct #18 +│ │ └── [not]: union '_string_filter' #17 +│ │ ├── variant_0: string #5 +│ │ ├── variant_1: struct #8 +│ │ │ └── [equals]: string #5 +│ │ ├── variant_2: struct #9 +│ │ │ └── [not]: string #5 +│ │ ├── variant_3: struct #10 +│ │ │ └── [in]: list #7 +│ │ │ └── item: string #5 +│ │ ├── variant_4: struct #11 +│ │ │ └── [notIn]: list #7 +│ │ │ └── item: string #5 +│ │ ├── variant_5: struct #14 +│ │ │ ├── [contains]: string #5 +│ │ │ └── [mode]: optional #13 +│ │ │ └── item: string #12 enum{ '"insensitive"' } +│ │ ├── variant_6: struct #15 +│ │ │ └── [search]: string #5 +│ │ └── variant_7: struct #16 +│ │ ├── [endsWith]: optional #6 +│ │ │ └── item: string #5 +│ │ └── [startsWith]: optional #6 +│ │ └── item: string #5 +│ └── [posts]: optional #74 +│ └── item: union #73 +│ ├── variant_0: struct #68 +│ │ └── [every]: optional '_67_PostWhere?' #67 +│ │ └── item: &PostWhere #66 +│ ├── variant_1: struct #70 +│ │ └── [some]: optional '_69_PostWhere?' #69 +│ │ └── item: &PostWhere #66 +│ └── variant_2: struct #72 +│ └── [none]: optional '_71_PostWhere?' #71 +│ └── item: &PostWhere #66 +├── [id]: optional '_62__integer_filter_c?' #62 +│ └── item: optional '_integer_filter_c' #34 +│ └── item: union #33 +│ ├── variant_0: either '_integer_filter' #31 +│ │ ├── variant_0: integer #23 +│ │ ├── variant_1: struct #26 +│ │ │ └── [equals]: integer #23 +│ │ ├── variant_2: struct #27 +│ │ │ └── [not]: integer #23 +│ │ ├── variant_3: struct #28 +│ │ │ ├── [gt]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ ├── [gte]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ ├── [lt]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ └── [lte]: optional #24 +│ │ │ └── item: integer #23 +│ │ ├── variant_4: struct #29 +│ │ │ └── [in]: list #25 +│ │ │ └── item: integer #23 +│ │ └── variant_5: struct #30 +│ │ └── [notIn]: list #25 +│ │ └── item: integer #23 +│ └── variant_1: struct #32 +│ └── [not]: either '_integer_filter' #31 +│ ├── variant_0: integer #23 +│ ├── variant_1: struct #26 +│ │ └── [equals]: integer #23 +│ ├── variant_2: struct #27 +│ │ └── [not]: integer #23 +│ ├── variant_3: struct #28 +│ │ ├── [gt]: optional #24 +│ │ │ └── item: integer #23 +│ │ ├── [gte]: optional #24 +│ │ │ └── item: integer #23 +│ │ ├── [lt]: optional #24 +│ │ │ └── item: integer #23 +│ │ └── [lte]: optional #24 +│ │ └── item: integer #23 +│ ├── variant_4: struct #29 +│ │ └── [in]: list #25 +│ │ └── item: integer #23 +│ └── variant_5: struct #30 +│ └── [notIn]: list #25 +│ └── item: integer #23 +└── [title]: optional '_63__string_filter_c?' #63 + └── item: optional '_string_filter_c' #20 + └── item: union #19 + ├── variant_0: union '_string_filter' #17 + │ ├── variant_0: string #5 + │ ├── variant_1: struct #8 + │ │ └── [equals]: string #5 + │ ├── variant_2: struct #9 + │ │ └── [not]: string #5 + │ ├── variant_3: struct #10 + │ │ └── [in]: list #7 + │ │ └── item: string #5 + │ ├── variant_4: struct #11 + │ │ └── [notIn]: list #7 + │ │ └── item: string #5 + │ ├── variant_5: struct #14 + │ │ ├── [contains]: string #5 + │ │ └── [mode]: optional #13 + │ │ └── item: string #12 enum{ '"insensitive"' } + │ ├── variant_6: struct #15 + │ │ └── [search]: string #5 + │ └── variant_7: struct #16 + │ ├── [endsWith]: optional #6 + │ │ └── item: string #5 + │ └── [startsWith]: optional #6 + │ └── item: string #5 + └── variant_1: struct #18 + └── [not]: union '_string_filter' #17 + ├── variant_0: string #5 + ├── variant_1: struct #8 + │ └── [equals]: string #5 + ├── variant_2: struct #9 + │ └── [not]: string #5 + ├── variant_3: struct #10 + │ └── [in]: list #7 + │ └── item: string #5 + ├── variant_4: struct #11 + │ └── [notIn]: list #7 + │ └── item: string #5 + ├── variant_5: struct #14 + │ ├── [contains]: string #5 + │ └── [mode]: optional #13 + │ └── item: string #12 enum{ '"insensitive"' } + ├── variant_6: struct #15 + │ └── [search]: string #5 + └── variant_7: struct #16 + ├── [endsWith]: optional #6 + │ └── item: string #5 + └── [startsWith]: optional #6 + └── item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where Record.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where Record.snap index 71191d8f1..63f9edaf6 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where Record.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where Record.snap @@ -3,150 +3,150 @@ source: typegraph/core/src/runtimes/prisma/type_generation/where_.rs expression: "tree::print(where_type)" --- root: struct 'RecordWhere' #36 -├─ [id]: optional '_21__string_filter_c?' #21 -│ └─ item: optional '_string_filter_c' #20 -│ └─ item: union #19 -│ ├─ variant_0: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ └─ variant_1: struct #18 -│ └─ [not]: union '_string_filter' #17 -│ ├─ variant_0: string #5 -│ ├─ variant_1: struct #8 -│ │ └─ [equals]: string #5 -│ ├─ variant_2: struct #9 -│ │ └─ [not]: string #5 -│ ├─ variant_3: struct #10 -│ │ └─ [in]: list #7 -│ │ └─ item: string #5 -│ ├─ variant_4: struct #11 -│ │ └─ [notIn]: list #7 -│ │ └─ item: string #5 -│ ├─ variant_5: struct #14 -│ │ ├─ [contains]: string #5 -│ │ └─ [mode]: optional #13 -│ │ └─ item: string #12 enum{ '"insensitive"' } -│ ├─ variant_6: struct #15 -│ │ └─ [search]: string #5 -│ └─ variant_7: struct #16 -│ ├─ [startsWith]: optional #6 -│ │ └─ item: string #5 -│ └─ [endsWith]: optional #6 -│ └─ item: string #5 -├─ [name]: optional '_22__string_filter_c?' #22 -│ └─ item: optional '_string_filter_c' #20 -│ └─ item: union #19 -│ ├─ variant_0: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ └─ variant_1: struct #18 -│ └─ [not]: union '_string_filter' #17 -│ ├─ variant_0: string #5 -│ ├─ variant_1: struct #8 -│ │ └─ [equals]: string #5 -│ ├─ variant_2: struct #9 -│ │ └─ [not]: string #5 -│ ├─ variant_3: struct #10 -│ │ └─ [in]: list #7 -│ │ └─ item: string #5 -│ ├─ variant_4: struct #11 -│ │ └─ [notIn]: list #7 -│ │ └─ item: string #5 -│ ├─ variant_5: struct #14 -│ │ ├─ [contains]: string #5 -│ │ └─ [mode]: optional #13 -│ │ └─ item: string #12 enum{ '"insensitive"' } -│ ├─ variant_6: struct #15 -│ │ └─ [search]: string #5 -│ └─ variant_7: struct #16 -│ ├─ [startsWith]: optional #6 -│ │ └─ item: string #5 -│ └─ [endsWith]: optional #6 -│ └─ item: string #5 -└─ [age]: optional '_35__integer_filter_c?' #35 - └─ item: optional '_integer_filter_c' #34 - └─ item: union #33 - ├─ variant_0: either '_integer_filter' #31 - │ ├─ variant_0: integer #23 - │ ├─ variant_1: struct #26 - │ │ └─ [equals]: integer #23 - │ ├─ variant_2: struct #27 - │ │ └─ [not]: integer #23 - │ ├─ variant_3: struct #28 - │ │ ├─ [lt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [gt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [lte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ └─ [gte]: optional #24 - │ │ └─ item: integer #23 - │ ├─ variant_4: struct #29 - │ │ └─ [in]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_5: struct #30 - │ └─ [notIn]: list #25 - │ └─ item: integer #23 - └─ variant_1: struct #32 - └─ [not]: either '_integer_filter' #31 - ├─ variant_0: integer #23 - ├─ variant_1: struct #26 - │ └─ [equals]: integer #23 - ├─ variant_2: struct #27 - │ └─ [not]: integer #23 - ├─ variant_3: struct #28 - │ ├─ [lt]: optional #24 - │ │ └─ item: integer #23 - │ ├─ [gt]: optional #24 - │ │ └─ item: integer #23 - │ ├─ [lte]: optional #24 - │ │ └─ item: integer #23 - │ └─ [gte]: optional #24 - │ └─ item: integer #23 - ├─ variant_4: struct #29 - │ └─ [in]: list #25 - │ └─ item: integer #23 - └─ variant_5: struct #30 - └─ [notIn]: list #25 - └─ item: integer #23 +├── [age]: optional '_35__integer_filter_c?' #35 +│ └── item: optional '_integer_filter_c' #34 +│ └── item: union #33 +│ ├── variant_0: either '_integer_filter' #31 +│ │ ├── variant_0: integer #23 +│ │ ├── variant_1: struct #26 +│ │ │ └── [equals]: integer #23 +│ │ ├── variant_2: struct #27 +│ │ │ └── [not]: integer #23 +│ │ ├── variant_3: struct #28 +│ │ │ ├── [gt]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ ├── [gte]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ ├── [lt]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ └── [lte]: optional #24 +│ │ │ └── item: integer #23 +│ │ ├── variant_4: struct #29 +│ │ │ └── [in]: list #25 +│ │ │ └── item: integer #23 +│ │ └── variant_5: struct #30 +│ │ └── [notIn]: list #25 +│ │ └── item: integer #23 +│ └── variant_1: struct #32 +│ └── [not]: either '_integer_filter' #31 +│ ├── variant_0: integer #23 +│ ├── variant_1: struct #26 +│ │ └── [equals]: integer #23 +│ ├── variant_2: struct #27 +│ │ └── [not]: integer #23 +│ ├── variant_3: struct #28 +│ │ ├── [gt]: optional #24 +│ │ │ └── item: integer #23 +│ │ ├── [gte]: optional #24 +│ │ │ └── item: integer #23 +│ │ ├── [lt]: optional #24 +│ │ │ └── item: integer #23 +│ │ └── [lte]: optional #24 +│ │ └── item: integer #23 +│ ├── variant_4: struct #29 +│ │ └── [in]: list #25 +│ │ └── item: integer #23 +│ └── variant_5: struct #30 +│ └── [notIn]: list #25 +│ └── item: integer #23 +├── [id]: optional '_21__string_filter_c?' #21 +│ └── item: optional '_string_filter_c' #20 +│ └── item: union #19 +│ ├── variant_0: union '_string_filter' #17 +│ │ ├── variant_0: string #5 +│ │ ├── variant_1: struct #8 +│ │ │ └── [equals]: string #5 +│ │ ├── variant_2: struct #9 +│ │ │ └── [not]: string #5 +│ │ ├── variant_3: struct #10 +│ │ │ └── [in]: list #7 +│ │ │ └── item: string #5 +│ │ ├── variant_4: struct #11 +│ │ │ └── [notIn]: list #7 +│ │ │ └── item: string #5 +│ │ ├── variant_5: struct #14 +│ │ │ ├── [contains]: string #5 +│ │ │ └── [mode]: optional #13 +│ │ │ └── item: string #12 enum{ '"insensitive"' } +│ │ ├── variant_6: struct #15 +│ │ │ └── [search]: string #5 +│ │ └── variant_7: struct #16 +│ │ ├── [endsWith]: optional #6 +│ │ │ └── item: string #5 +│ │ └── [startsWith]: optional #6 +│ │ └── item: string #5 +│ └── variant_1: struct #18 +│ └── [not]: union '_string_filter' #17 +│ ├── variant_0: string #5 +│ ├── variant_1: struct #8 +│ │ └── [equals]: string #5 +│ ├── variant_2: struct #9 +│ │ └── [not]: string #5 +│ ├── variant_3: struct #10 +│ │ └── [in]: list #7 +│ │ └── item: string #5 +│ ├── variant_4: struct #11 +│ │ └── [notIn]: list #7 +│ │ └── item: string #5 +│ ├── variant_5: struct #14 +│ │ ├── [contains]: string #5 +│ │ └── [mode]: optional #13 +│ │ └── item: string #12 enum{ '"insensitive"' } +│ ├── variant_6: struct #15 +│ │ └── [search]: string #5 +│ └── variant_7: struct #16 +│ ├── [endsWith]: optional #6 +│ │ └── item: string #5 +│ └── [startsWith]: optional #6 +│ └── item: string #5 +└── [name]: optional '_22__string_filter_c?' #22 + └── item: optional '_string_filter_c' #20 + └── item: union #19 + ├── variant_0: union '_string_filter' #17 + │ ├── variant_0: string #5 + │ ├── variant_1: struct #8 + │ │ └── [equals]: string #5 + │ ├── variant_2: struct #9 + │ │ └── [not]: string #5 + │ ├── variant_3: struct #10 + │ │ └── [in]: list #7 + │ │ └── item: string #5 + │ ├── variant_4: struct #11 + │ │ └── [notIn]: list #7 + │ │ └── item: string #5 + │ ├── variant_5: struct #14 + │ │ ├── [contains]: string #5 + │ │ └── [mode]: optional #13 + │ │ └── item: string #12 enum{ '"insensitive"' } + │ ├── variant_6: struct #15 + │ │ └── [search]: string #5 + │ └── variant_7: struct #16 + │ ├── [endsWith]: optional #6 + │ │ └── item: string #5 + │ └── [startsWith]: optional #6 + │ └── item: string #5 + └── variant_1: struct #18 + └── [not]: union '_string_filter' #17 + ├── variant_0: string #5 + ├── variant_1: struct #8 + │ └── [equals]: string #5 + ├── variant_2: struct #9 + │ └── [not]: string #5 + ├── variant_3: struct #10 + │ └── [in]: list #7 + │ └── item: string #5 + ├── variant_4: struct #11 + │ └── [notIn]: list #7 + │ └── item: string #5 + ├── variant_5: struct #14 + │ ├── [contains]: string #5 + │ └── [mode]: optional #13 + │ └── item: string #12 enum{ '"insensitive"' } + ├── variant_6: struct #15 + │ └── [search]: string #5 + └── variant_7: struct #16 + ├── [endsWith]: optional #6 + │ └── item: string #5 + └── [startsWith]: optional #6 + └── item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where User.snap b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where User.snap index d6db1243c..54c1e4184 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where User.snap +++ b/typegraph/core/src/runtimes/prisma/type_generation/snapshots/typegraph_core__runtimes__prisma__type_generation__where___test__where User.snap @@ -3,405 +3,405 @@ source: typegraph/core/src/runtimes/prisma/type_generation/where_.rs expression: "tree::print(context.generate(&Where::new(user))?)" --- root: struct 'UserWhere' #61 -├─ [id]: optional '_46__integer_filter_c?' #46 -│ └─ item: optional '_integer_filter_c' #34 -│ └─ item: union #33 -│ ├─ variant_0: either '_integer_filter' #31 -│ │ ├─ variant_0: integer #23 -│ │ ├─ variant_1: struct #26 -│ │ │ └─ [equals]: integer #23 -│ │ ├─ variant_2: struct #27 -│ │ │ └─ [not]: integer #23 -│ │ ├─ variant_3: struct #28 -│ │ │ ├─ [lt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [gt]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ ├─ [lte]: optional #24 -│ │ │ │ └─ item: integer #23 -│ │ │ └─ [gte]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ variant_4: struct #29 -│ │ │ └─ [in]: list #25 -│ │ │ └─ item: integer #23 -│ │ └─ variant_5: struct #30 -│ │ └─ [notIn]: list #25 -│ │ └─ item: integer #23 -│ └─ variant_1: struct #32 -│ └─ [not]: either '_integer_filter' #31 -│ ├─ variant_0: integer #23 -│ ├─ variant_1: struct #26 -│ │ └─ [equals]: integer #23 -│ ├─ variant_2: struct #27 -│ │ └─ [not]: integer #23 -│ ├─ variant_3: struct #28 -│ │ ├─ [lt]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ [gt]: optional #24 -│ │ │ └─ item: integer #23 -│ │ ├─ [lte]: optional #24 -│ │ │ └─ item: integer #23 -│ │ └─ [gte]: optional #24 -│ │ └─ item: integer #23 -│ ├─ variant_4: struct #29 -│ │ └─ [in]: list #25 -│ │ └─ item: integer #23 -│ └─ variant_5: struct #30 -│ └─ [notIn]: list #25 -│ └─ item: integer #23 -├─ [name]: optional '_47__string_filter_c?' #47 -│ └─ item: optional '_string_filter_c' #20 -│ └─ item: union #19 -│ ├─ variant_0: union '_string_filter' #17 -│ │ ├─ variant_0: string #5 -│ │ ├─ variant_1: struct #8 -│ │ │ └─ [equals]: string #5 -│ │ ├─ variant_2: struct #9 -│ │ │ └─ [not]: string #5 -│ │ ├─ variant_3: struct #10 -│ │ │ └─ [in]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_4: struct #11 -│ │ │ └─ [notIn]: list #7 -│ │ │ └─ item: string #5 -│ │ ├─ variant_5: struct #14 -│ │ │ ├─ [contains]: string #5 -│ │ │ └─ [mode]: optional #13 -│ │ │ └─ item: string #12 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #15 -│ │ │ └─ [search]: string #5 -│ │ └─ variant_7: struct #16 -│ │ ├─ [startsWith]: optional #6 -│ │ │ └─ item: string #5 -│ │ └─ [endsWith]: optional #6 -│ │ └─ item: string #5 -│ └─ variant_1: struct #18 -│ └─ [not]: union '_string_filter' #17 -│ ├─ variant_0: string #5 -│ ├─ variant_1: struct #8 -│ │ └─ [equals]: string #5 -│ ├─ variant_2: struct #9 -│ │ └─ [not]: string #5 -│ ├─ variant_3: struct #10 -│ │ └─ [in]: list #7 -│ │ └─ item: string #5 -│ ├─ variant_4: struct #11 -│ │ └─ [notIn]: list #7 -│ │ └─ item: string #5 -│ ├─ variant_5: struct #14 -│ │ ├─ [contains]: string #5 -│ │ └─ [mode]: optional #13 -│ │ └─ item: string #12 enum{ '"insensitive"' } -│ ├─ variant_6: struct #15 -│ │ └─ [search]: string #5 -│ └─ variant_7: struct #16 -│ ├─ [startsWith]: optional #6 -│ │ └─ item: string #5 -│ └─ [endsWith]: optional #6 -│ └─ item: string #5 -└─ [posts]: optional #60 - └─ item: union #59 - ├─ variant_0: struct #54 - │ └─ [every]: optional '_53_PostWhere__skip_41_UserWhere?' #53 - │ └─ item: struct 'PostWhere__skip_41_UserWhere' #52 - │ ├─ [id]: optional '_48__integer_filter_c?' #48 - │ │ └─ item: optional '_integer_filter_c' #34 - │ │ └─ item: union #33 - │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_1: struct #32 - │ │ └─ [not]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ ├─ [title]: optional '_49__string_filter_c?' #49 - │ │ └─ item: optional '_string_filter_c' #20 - │ │ └─ item: union #19 - │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ variant_1: struct #18 - │ │ └─ [not]: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [author]: optional '_51_UserWhere?' #51 - │ └─ item: &UserWhere #50 - ├─ variant_1: struct #56 - │ └─ [some]: optional '_55_PostWhere__skip_41_UserWhere?' #55 - │ └─ item: struct 'PostWhere__skip_41_UserWhere' #52 - │ ├─ [id]: optional '_48__integer_filter_c?' #48 - │ │ └─ item: optional '_integer_filter_c' #34 - │ │ └─ item: union #33 - │ │ ├─ variant_0: either '_integer_filter' #31 - │ │ │ ├─ variant_0: integer #23 - │ │ │ ├─ variant_1: struct #26 - │ │ │ │ └─ [equals]: integer #23 - │ │ │ ├─ variant_2: struct #27 - │ │ │ │ └─ [not]: integer #23 - │ │ │ ├─ variant_3: struct #28 - │ │ │ │ ├─ [lt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [gt]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ ├─ [lte]: optional #24 - │ │ │ │ │ └─ item: integer #23 - │ │ │ │ └─ [gte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ variant_4: struct #29 - │ │ │ │ └─ [in]: list #25 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ variant_5: struct #30 - │ │ │ └─ [notIn]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_1: struct #32 - │ │ └─ [not]: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ ├─ [title]: optional '_49__string_filter_c?' #49 - │ │ └─ item: optional '_string_filter_c' #20 - │ │ └─ item: union #19 - │ │ ├─ variant_0: union '_string_filter' #17 - │ │ │ ├─ variant_0: string #5 - │ │ │ ├─ variant_1: struct #8 - │ │ │ │ └─ [equals]: string #5 - │ │ │ ├─ variant_2: struct #9 - │ │ │ │ └─ [not]: string #5 - │ │ │ ├─ variant_3: struct #10 - │ │ │ │ └─ [in]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_4: struct #11 - │ │ │ │ └─ [notIn]: list #7 - │ │ │ │ └─ item: string #5 - │ │ │ ├─ variant_5: struct #14 - │ │ │ │ ├─ [contains]: string #5 - │ │ │ │ └─ [mode]: optional #13 - │ │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ │ ├─ variant_6: struct #15 - │ │ │ │ └─ [search]: string #5 - │ │ │ └─ variant_7: struct #16 - │ │ │ ├─ [startsWith]: optional #6 - │ │ │ │ └─ item: string #5 - │ │ │ └─ [endsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ variant_1: struct #18 - │ │ └─ [not]: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [author]: optional '_51_UserWhere?' #51 - │ └─ item: &UserWhere #50 - └─ variant_2: struct #58 - └─ [none]: optional '_57_PostWhere__skip_41_UserWhere?' #57 - └─ item: struct 'PostWhere__skip_41_UserWhere' #52 - ├─ [id]: optional '_48__integer_filter_c?' #48 - │ └─ item: optional '_integer_filter_c' #34 - │ └─ item: union #33 - │ ├─ variant_0: either '_integer_filter' #31 - │ │ ├─ variant_0: integer #23 - │ │ ├─ variant_1: struct #26 - │ │ │ └─ [equals]: integer #23 - │ │ ├─ variant_2: struct #27 - │ │ │ └─ [not]: integer #23 - │ │ ├─ variant_3: struct #28 - │ │ │ ├─ [lt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [gt]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ ├─ [lte]: optional #24 - │ │ │ │ └─ item: integer #23 - │ │ │ └─ [gte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ variant_4: struct #29 - │ │ │ └─ [in]: list #25 - │ │ │ └─ item: integer #23 - │ │ └─ variant_5: struct #30 - │ │ └─ [notIn]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_1: struct #32 - │ └─ [not]: either '_integer_filter' #31 - │ ├─ variant_0: integer #23 - │ ├─ variant_1: struct #26 - │ │ └─ [equals]: integer #23 - │ ├─ variant_2: struct #27 - │ │ └─ [not]: integer #23 - │ ├─ variant_3: struct #28 - │ │ ├─ [lt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [gt]: optional #24 - │ │ │ └─ item: integer #23 - │ │ ├─ [lte]: optional #24 - │ │ │ └─ item: integer #23 - │ │ └─ [gte]: optional #24 - │ │ └─ item: integer #23 - │ ├─ variant_4: struct #29 - │ │ └─ [in]: list #25 - │ │ └─ item: integer #23 - │ └─ variant_5: struct #30 - │ └─ [notIn]: list #25 - │ └─ item: integer #23 - ├─ [title]: optional '_49__string_filter_c?' #49 - │ └─ item: optional '_string_filter_c' #20 - │ └─ item: union #19 - │ ├─ variant_0: union '_string_filter' #17 - │ │ ├─ variant_0: string #5 - │ │ ├─ variant_1: struct #8 - │ │ │ └─ [equals]: string #5 - │ │ ├─ variant_2: struct #9 - │ │ │ └─ [not]: string #5 - │ │ ├─ variant_3: struct #10 - │ │ │ └─ [in]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_4: struct #11 - │ │ │ └─ [notIn]: list #7 - │ │ │ └─ item: string #5 - │ │ ├─ variant_5: struct #14 - │ │ │ ├─ [contains]: string #5 - │ │ │ └─ [mode]: optional #13 - │ │ │ └─ item: string #12 enum{ '"insensitive"' } - │ │ ├─ variant_6: struct #15 - │ │ │ └─ [search]: string #5 - │ │ └─ variant_7: struct #16 - │ │ ├─ [startsWith]: optional #6 - │ │ │ └─ item: string #5 - │ │ └─ [endsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ variant_1: struct #18 - │ └─ [not]: union '_string_filter' #17 - │ ├─ variant_0: string #5 - │ ├─ variant_1: struct #8 - │ │ └─ [equals]: string #5 - │ ├─ variant_2: struct #9 - │ │ └─ [not]: string #5 - │ ├─ variant_3: struct #10 - │ │ └─ [in]: list #7 - │ │ └─ item: string #5 - │ ├─ variant_4: struct #11 - │ │ └─ [notIn]: list #7 - │ │ └─ item: string #5 - │ ├─ variant_5: struct #14 - │ │ ├─ [contains]: string #5 - │ │ └─ [mode]: optional #13 - │ │ └─ item: string #12 enum{ '"insensitive"' } - │ ├─ variant_6: struct #15 - │ │ └─ [search]: string #5 - │ └─ variant_7: struct #16 - │ ├─ [startsWith]: optional #6 - │ │ └─ item: string #5 - │ └─ [endsWith]: optional #6 - │ └─ item: string #5 - └─ [author]: optional '_51_UserWhere?' #51 - └─ item: &UserWhere #50 +├── [id]: optional '_46__integer_filter_c?' #46 +│ └── item: optional '_integer_filter_c' #34 +│ └── item: union #33 +│ ├── variant_0: either '_integer_filter' #31 +│ │ ├── variant_0: integer #23 +│ │ ├── variant_1: struct #26 +│ │ │ └── [equals]: integer #23 +│ │ ├── variant_2: struct #27 +│ │ │ └── [not]: integer #23 +│ │ ├── variant_3: struct #28 +│ │ │ ├── [gt]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ ├── [gte]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ ├── [lt]: optional #24 +│ │ │ │ └── item: integer #23 +│ │ │ └── [lte]: optional #24 +│ │ │ └── item: integer #23 +│ │ ├── variant_4: struct #29 +│ │ │ └── [in]: list #25 +│ │ │ └── item: integer #23 +│ │ └── variant_5: struct #30 +│ │ └── [notIn]: list #25 +│ │ └── item: integer #23 +│ └── variant_1: struct #32 +│ └── [not]: either '_integer_filter' #31 +│ ├── variant_0: integer #23 +│ ├── variant_1: struct #26 +│ │ └── [equals]: integer #23 +│ ├── variant_2: struct #27 +│ │ └── [not]: integer #23 +│ ├── variant_3: struct #28 +│ │ ├── [gt]: optional #24 +│ │ │ └── item: integer #23 +│ │ ├── [gte]: optional #24 +│ │ │ └── item: integer #23 +│ │ ├── [lt]: optional #24 +│ │ │ └── item: integer #23 +│ │ └── [lte]: optional #24 +│ │ └── item: integer #23 +│ ├── variant_4: struct #29 +│ │ └── [in]: list #25 +│ │ └── item: integer #23 +│ └── variant_5: struct #30 +│ └── [notIn]: list #25 +│ └── item: integer #23 +├── [name]: optional '_47__string_filter_c?' #47 +│ └── item: optional '_string_filter_c' #20 +│ └── item: union #19 +│ ├── variant_0: union '_string_filter' #17 +│ │ ├── variant_0: string #5 +│ │ ├── variant_1: struct #8 +│ │ │ └── [equals]: string #5 +│ │ ├── variant_2: struct #9 +│ │ │ └── [not]: string #5 +│ │ ├── variant_3: struct #10 +│ │ │ └── [in]: list #7 +│ │ │ └── item: string #5 +│ │ ├── variant_4: struct #11 +│ │ │ └── [notIn]: list #7 +│ │ │ └── item: string #5 +│ │ ├── variant_5: struct #14 +│ │ │ ├── [contains]: string #5 +│ │ │ └── [mode]: optional #13 +│ │ │ └── item: string #12 enum{ '"insensitive"' } +│ │ ├── variant_6: struct #15 +│ │ │ └── [search]: string #5 +│ │ └── variant_7: struct #16 +│ │ ├── [endsWith]: optional #6 +│ │ │ └── item: string #5 +│ │ └── [startsWith]: optional #6 +│ │ └── item: string #5 +│ └── variant_1: struct #18 +│ └── [not]: union '_string_filter' #17 +│ ├── variant_0: string #5 +│ ├── variant_1: struct #8 +│ │ └── [equals]: string #5 +│ ├── variant_2: struct #9 +│ │ └── [not]: string #5 +│ ├── variant_3: struct #10 +│ │ └── [in]: list #7 +│ │ └── item: string #5 +│ ├── variant_4: struct #11 +│ │ └── [notIn]: list #7 +│ │ └── item: string #5 +│ ├── variant_5: struct #14 +│ │ ├── [contains]: string #5 +│ │ └── [mode]: optional #13 +│ │ └── item: string #12 enum{ '"insensitive"' } +│ ├── variant_6: struct #15 +│ │ └── [search]: string #5 +│ └── variant_7: struct #16 +│ ├── [endsWith]: optional #6 +│ │ └── item: string #5 +│ └── [startsWith]: optional #6 +│ └── item: string #5 +└── [posts]: optional #60 + └── item: union #59 + ├── variant_0: struct #54 + │ └── [every]: optional '_53_PostWhere__skip_41_UserWhere?' #53 + │ └── item: struct 'PostWhere__skip_41_UserWhere' #52 + │ ├── [author]: optional '_51_UserWhere?' #51 + │ │ └── item: &UserWhere #50 + │ ├── [id]: optional '_48__integer_filter_c?' #48 + │ │ └── item: optional '_integer_filter_c' #34 + │ │ └── item: union #33 + │ │ ├── variant_0: either '_integer_filter' #31 + │ │ │ ├── variant_0: integer #23 + │ │ │ ├── variant_1: struct #26 + │ │ │ │ └── [equals]: integer #23 + │ │ │ ├── variant_2: struct #27 + │ │ │ │ └── [not]: integer #23 + │ │ │ ├── variant_3: struct #28 + │ │ │ │ ├── [gt]: optional #24 + │ │ │ │ │ └── item: integer #23 + │ │ │ │ ├── [gte]: optional #24 + │ │ │ │ │ └── item: integer #23 + │ │ │ │ ├── [lt]: optional #24 + │ │ │ │ │ └── item: integer #23 + │ │ │ │ └── [lte]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ ├── variant_4: struct #29 + │ │ │ │ └── [in]: list #25 + │ │ │ │ └── item: integer #23 + │ │ │ └── variant_5: struct #30 + │ │ │ └── [notIn]: list #25 + │ │ │ └── item: integer #23 + │ │ └── variant_1: struct #32 + │ │ └── [not]: either '_integer_filter' #31 + │ │ ├── variant_0: integer #23 + │ │ ├── variant_1: struct #26 + │ │ │ └── [equals]: integer #23 + │ │ ├── variant_2: struct #27 + │ │ │ └── [not]: integer #23 + │ │ ├── variant_3: struct #28 + │ │ │ ├── [gt]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ ├── [gte]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ ├── [lt]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ └── [lte]: optional #24 + │ │ │ └── item: integer #23 + │ │ ├── variant_4: struct #29 + │ │ │ └── [in]: list #25 + │ │ │ └── item: integer #23 + │ │ └── variant_5: struct #30 + │ │ └── [notIn]: list #25 + │ │ └── item: integer #23 + │ └── [title]: optional '_49__string_filter_c?' #49 + │ └── item: optional '_string_filter_c' #20 + │ └── item: union #19 + │ ├── variant_0: union '_string_filter' #17 + │ │ ├── variant_0: string #5 + │ │ ├── variant_1: struct #8 + │ │ │ └── [equals]: string #5 + │ │ ├── variant_2: struct #9 + │ │ │ └── [not]: string #5 + │ │ ├── variant_3: struct #10 + │ │ │ └── [in]: list #7 + │ │ │ └── item: string #5 + │ │ ├── variant_4: struct #11 + │ │ │ └── [notIn]: list #7 + │ │ │ └── item: string #5 + │ │ ├── variant_5: struct #14 + │ │ │ ├── [contains]: string #5 + │ │ │ └── [mode]: optional #13 + │ │ │ └── item: string #12 enum{ '"insensitive"' } + │ │ ├── variant_6: struct #15 + │ │ │ └── [search]: string #5 + │ │ └── variant_7: struct #16 + │ │ ├── [endsWith]: optional #6 + │ │ │ └── item: string #5 + │ │ └── [startsWith]: optional #6 + │ │ └── item: string #5 + │ └── variant_1: struct #18 + │ └── [not]: union '_string_filter' #17 + │ ├── variant_0: string #5 + │ ├── variant_1: struct #8 + │ │ └── [equals]: string #5 + │ ├── variant_2: struct #9 + │ │ └── [not]: string #5 + │ ├── variant_3: struct #10 + │ │ └── [in]: list #7 + │ │ └── item: string #5 + │ ├── variant_4: struct #11 + │ │ └── [notIn]: list #7 + │ │ └── item: string #5 + │ ├── variant_5: struct #14 + │ │ ├── [contains]: string #5 + │ │ └── [mode]: optional #13 + │ │ └── item: string #12 enum{ '"insensitive"' } + │ ├── variant_6: struct #15 + │ │ └── [search]: string #5 + │ └── variant_7: struct #16 + │ ├── [endsWith]: optional #6 + │ │ └── item: string #5 + │ └── [startsWith]: optional #6 + │ └── item: string #5 + ├── variant_1: struct #56 + │ └── [some]: optional '_55_PostWhere__skip_41_UserWhere?' #55 + │ └── item: struct 'PostWhere__skip_41_UserWhere' #52 + │ ├── [author]: optional '_51_UserWhere?' #51 + │ │ └── item: &UserWhere #50 + │ ├── [id]: optional '_48__integer_filter_c?' #48 + │ │ └── item: optional '_integer_filter_c' #34 + │ │ └── item: union #33 + │ │ ├── variant_0: either '_integer_filter' #31 + │ │ │ ├── variant_0: integer #23 + │ │ │ ├── variant_1: struct #26 + │ │ │ │ └── [equals]: integer #23 + │ │ │ ├── variant_2: struct #27 + │ │ │ │ └── [not]: integer #23 + │ │ │ ├── variant_3: struct #28 + │ │ │ │ ├── [gt]: optional #24 + │ │ │ │ │ └── item: integer #23 + │ │ │ │ ├── [gte]: optional #24 + │ │ │ │ │ └── item: integer #23 + │ │ │ │ ├── [lt]: optional #24 + │ │ │ │ │ └── item: integer #23 + │ │ │ │ └── [lte]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ ├── variant_4: struct #29 + │ │ │ │ └── [in]: list #25 + │ │ │ │ └── item: integer #23 + │ │ │ └── variant_5: struct #30 + │ │ │ └── [notIn]: list #25 + │ │ │ └── item: integer #23 + │ │ └── variant_1: struct #32 + │ │ └── [not]: either '_integer_filter' #31 + │ │ ├── variant_0: integer #23 + │ │ ├── variant_1: struct #26 + │ │ │ └── [equals]: integer #23 + │ │ ├── variant_2: struct #27 + │ │ │ └── [not]: integer #23 + │ │ ├── variant_3: struct #28 + │ │ │ ├── [gt]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ ├── [gte]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ ├── [lt]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ └── [lte]: optional #24 + │ │ │ └── item: integer #23 + │ │ ├── variant_4: struct #29 + │ │ │ └── [in]: list #25 + │ │ │ └── item: integer #23 + │ │ └── variant_5: struct #30 + │ │ └── [notIn]: list #25 + │ │ └── item: integer #23 + │ └── [title]: optional '_49__string_filter_c?' #49 + │ └── item: optional '_string_filter_c' #20 + │ └── item: union #19 + │ ├── variant_0: union '_string_filter' #17 + │ │ ├── variant_0: string #5 + │ │ ├── variant_1: struct #8 + │ │ │ └── [equals]: string #5 + │ │ ├── variant_2: struct #9 + │ │ │ └── [not]: string #5 + │ │ ├── variant_3: struct #10 + │ │ │ └── [in]: list #7 + │ │ │ └── item: string #5 + │ │ ├── variant_4: struct #11 + │ │ │ └── [notIn]: list #7 + │ │ │ └── item: string #5 + │ │ ├── variant_5: struct #14 + │ │ │ ├── [contains]: string #5 + │ │ │ └── [mode]: optional #13 + │ │ │ └── item: string #12 enum{ '"insensitive"' } + │ │ ├── variant_6: struct #15 + │ │ │ └── [search]: string #5 + │ │ └── variant_7: struct #16 + │ │ ├── [endsWith]: optional #6 + │ │ │ └── item: string #5 + │ │ └── [startsWith]: optional #6 + │ │ └── item: string #5 + │ └── variant_1: struct #18 + │ └── [not]: union '_string_filter' #17 + │ ├── variant_0: string #5 + │ ├── variant_1: struct #8 + │ │ └── [equals]: string #5 + │ ├── variant_2: struct #9 + │ │ └── [not]: string #5 + │ ├── variant_3: struct #10 + │ │ └── [in]: list #7 + │ │ └── item: string #5 + │ ├── variant_4: struct #11 + │ │ └── [notIn]: list #7 + │ │ └── item: string #5 + │ ├── variant_5: struct #14 + │ │ ├── [contains]: string #5 + │ │ └── [mode]: optional #13 + │ │ └── item: string #12 enum{ '"insensitive"' } + │ ├── variant_6: struct #15 + │ │ └── [search]: string #5 + │ └── variant_7: struct #16 + │ ├── [endsWith]: optional #6 + │ │ └── item: string #5 + │ └── [startsWith]: optional #6 + │ └── item: string #5 + └── variant_2: struct #58 + └── [none]: optional '_57_PostWhere__skip_41_UserWhere?' #57 + └── item: struct 'PostWhere__skip_41_UserWhere' #52 + ├── [author]: optional '_51_UserWhere?' #51 + │ └── item: &UserWhere #50 + ├── [id]: optional '_48__integer_filter_c?' #48 + │ └── item: optional '_integer_filter_c' #34 + │ └── item: union #33 + │ ├── variant_0: either '_integer_filter' #31 + │ │ ├── variant_0: integer #23 + │ │ ├── variant_1: struct #26 + │ │ │ └── [equals]: integer #23 + │ │ ├── variant_2: struct #27 + │ │ │ └── [not]: integer #23 + │ │ ├── variant_3: struct #28 + │ │ │ ├── [gt]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ ├── [gte]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ ├── [lt]: optional #24 + │ │ │ │ └── item: integer #23 + │ │ │ └── [lte]: optional #24 + │ │ │ └── item: integer #23 + │ │ ├── variant_4: struct #29 + │ │ │ └── [in]: list #25 + │ │ │ └── item: integer #23 + │ │ └── variant_5: struct #30 + │ │ └── [notIn]: list #25 + │ │ └── item: integer #23 + │ └── variant_1: struct #32 + │ └── [not]: either '_integer_filter' #31 + │ ├── variant_0: integer #23 + │ ├── variant_1: struct #26 + │ │ └── [equals]: integer #23 + │ ├── variant_2: struct #27 + │ │ └── [not]: integer #23 + │ ├── variant_3: struct #28 + │ │ ├── [gt]: optional #24 + │ │ │ └── item: integer #23 + │ │ ├── [gte]: optional #24 + │ │ │ └── item: integer #23 + │ │ ├── [lt]: optional #24 + │ │ │ └── item: integer #23 + │ │ └── [lte]: optional #24 + │ │ └── item: integer #23 + │ ├── variant_4: struct #29 + │ │ └── [in]: list #25 + │ │ └── item: integer #23 + │ └── variant_5: struct #30 + │ └── [notIn]: list #25 + │ └── item: integer #23 + └── [title]: optional '_49__string_filter_c?' #49 + └── item: optional '_string_filter_c' #20 + └── item: union #19 + ├── variant_0: union '_string_filter' #17 + │ ├── variant_0: string #5 + │ ├── variant_1: struct #8 + │ │ └── [equals]: string #5 + │ ├── variant_2: struct #9 + │ │ └── [not]: string #5 + │ ├── variant_3: struct #10 + │ │ └── [in]: list #7 + │ │ └── item: string #5 + │ ├── variant_4: struct #11 + │ │ └── [notIn]: list #7 + │ │ └── item: string #5 + │ ├── variant_5: struct #14 + │ │ ├── [contains]: string #5 + │ │ └── [mode]: optional #13 + │ │ └── item: string #12 enum{ '"insensitive"' } + │ ├── variant_6: struct #15 + │ │ └── [search]: string #5 + │ └── variant_7: struct #16 + │ ├── [endsWith]: optional #6 + │ │ └── item: string #5 + │ └── [startsWith]: optional #6 + │ └── item: string #5 + └── variant_1: struct #18 + └── [not]: union '_string_filter' #17 + ├── variant_0: string #5 + ├── variant_1: struct #8 + │ └── [equals]: string #5 + ├── variant_2: struct #9 + │ └── [not]: string #5 + ├── variant_3: struct #10 + │ └── [in]: list #7 + │ └── item: string #5 + ├── variant_4: struct #11 + │ └── [notIn]: list #7 + │ └── item: string #5 + ├── variant_5: struct #14 + │ ├── [contains]: string #5 + │ └── [mode]: optional #13 + │ └── item: string #12 enum{ '"insensitive"' } + ├── variant_6: struct #15 + │ └── [search]: string #5 + └── variant_7: struct #16 + ├── [endsWith]: optional #6 + │ └── item: string #5 + └── [startsWith]: optional #6 + └── item: string #5 diff --git a/typegraph/core/src/runtimes/prisma/type_generation/with_nested_count.rs b/typegraph/core/src/runtimes/prisma/type_generation/with_nested_count.rs index 871375086..f14a2ec5a 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/with_nested_count.rs +++ b/typegraph/core/src/runtimes/prisma/type_generation/with_nested_count.rs @@ -8,6 +8,7 @@ use crate::runtimes::prisma::relationship::Cardinality; use crate::runtimes::prisma::type_generation::count::Count; use crate::t::{self, ConcreteTypeBuilder, TypeBuilder}; use crate::types::{TypeDefExt, TypeId}; +use crate::utils::remove_injection; use super::TypeGen; @@ -71,7 +72,7 @@ impl TypeGen for WithNestedCount { Property::Scalar(prop) => { let type_id = prop.wrapper_type_id.resolve_ref()?.1.id(); - builder.prop(key, type_id); + builder.prop(key, remove_injection(type_id)?); } Property::Unmanaged(type_id) => { diff --git a/typegraph/core/src/t.rs b/typegraph/core/src/t.rs index 8b8638abb..687b2f028 100644 --- a/typegraph/core/src/t.rs +++ b/typegraph/core/src/t.rs @@ -455,6 +455,7 @@ impl Default for TypeFunc { Self { inp: u32::max_value(), out: u32::max_value(), + parameter_transform: None, mat: u32::max_value(), rate_calls: false, rate_weight: None, diff --git a/typegraph/core/src/test_utils.rs b/typegraph/core/src/test_utils.rs index 02b899138..219f15f70 100644 --- a/typegraph/core/src/test_utils.rs +++ b/typegraph/core/src/test_utils.rs @@ -76,10 +76,63 @@ pub fn setup(name: Option<&str>) -> crate::errors::Result<()> { pub mod tree { use std::{borrow::Cow, io::Write, rc::Rc}; - use ptree::{Style, TreeItem}; + use ptree::{print_config::StyleWhen, IndentChars, PrintConfig, Style, TreeItem}; use crate::types::{Type, TypeDef, TypeDefExt, TypeId}; + pub struct PrintOptions { + no_indent_lines: bool, + indent_size: u16, + } + + impl PrintOptions { + pub fn new() -> Self { + Self { + no_indent_lines: false, + indent_size: 4, + } + } + + pub fn no_indent_lines(mut self) -> Self { + self.no_indent_lines = true; + self + } + + #[allow(dead_code)] + pub fn indent_size(mut self, size: u16) -> Self { + self.indent_size = size; + self + } + + pub fn print(&self, type_id: TypeId) -> String { + let mut config = PrintConfig { + indent: self.indent_size as usize, + styled: StyleWhen::Never, + ..Default::default() + }; + if self.no_indent_lines { + config.characters = IndentChars { + down_and_right: " ".to_string(), + down: " ".to_string(), + turn_right: " ".to_string(), + right: " ".to_string(), + empty: " ".to_string(), + }; + } + + let root = Node { + label: "root".into(), + type_id, + parents: Rc::new(vec![]), + }; + + let mut buf: Vec = vec![]; + ptree::write_tree_with(&root, &mut buf, &config).expect("could not write tree"); + + String::from_utf8(buf).unwrap() + } + } + #[derive(Clone)] struct Node { label: String, @@ -88,16 +141,7 @@ pub mod tree { } pub fn print(type_id: TypeId) -> String { - let root = Node { - label: "root".into(), - type_id, - parents: Rc::new(vec![]), - }; - - let mut buf: Vec = vec![]; - ptree::write_tree(&root, &mut buf).expect("could not write tree"); - - String::from_utf8(buf).unwrap() + PrintOptions::new().print(type_id) } impl TreeItem for Node { @@ -175,17 +219,21 @@ pub mod tree { | TypeDef::String(_) | TypeDef::File(_) | TypeDef::Boolean(_) => Cow::Owned(vec![]), - TypeDef::Struct(ty) => Cow::Owned( - ty.data + TypeDef::Struct(ty) => { + let mut children = ty + .data .props .iter() .map(|(k, id)| Node { label: format!("[{k}]"), - type_id: (*id).into(), + type_id: id.into(), parents: Rc::clone(&parents), }) - .collect(), - ), + .collect::>(); + children.sort_unstable_by_key(|n| n.label.clone()); + + Cow::Owned(children) + } TypeDef::Func(ty) => Cow::Owned(vec![ Node { label: "input".to_string(), diff --git a/typegraph/core/src/typedef/func.rs b/typegraph/core/src/typedef/func.rs index b18fbeabf..675b4ccce 100644 --- a/typegraph/core/src/typedef/func.rs +++ b/typegraph/core/src/typedef/func.rs @@ -1,17 +1,18 @@ // Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. // SPDX-License-Identifier: MPL-2.0 -use common::typegraph::{FunctionTypeData, TypeNode}; -use errors::Result; - -use crate::{ - conversion::types::{BaseBuilderInit, TypeConversion}, - errors, - typegraph::TypegraphContext, - types::{Func, TypeDef, TypeDefData, TypeId}, - wit::core::TypeFunc, +use common::typegraph::{ + parameter_transform::FunctionParameterTransform, FunctionTypeData, TypeNode, }; +use crate::conversion::parameter_transform::convert_tree; +use crate::conversion::types::{BaseBuilderInit, TypeConversion}; +use crate::errors::{self, Result, TgError}; +use crate::params::apply::ParameterTransformNode; +use crate::typegraph::TypegraphContext; +use crate::types::{Func, TypeDef, TypeDefData, TypeId}; +use crate::wit::core::TypeFunc; + impl TypeConversion for Func { fn convert(&self, ctx: &mut TypegraphContext, _runtime_id: Option) -> Result { let (mat_id, runtime_id) = ctx.register_materializer(self.data.mat)?; @@ -28,6 +29,30 @@ impl TypeConversion for Func { let out_type = TypeId(self.data.out).resolve_ref()?.1; let output = ctx.register_type(out_type, Some(runtime_id))?.into(); + let parameter_transform = self + .data + .parameter_transform + .as_ref() + .map(|transform| -> Result<_> { + let resolver_input = TypeId(transform.resolver_input); + let transform_root: ParameterTransformNode = + serde_json::from_str(&transform.transform_tree).map_err(|e| { + TgError::from(format!("Failed to parse transform_root: {}", e)) + })?; + + let transform_root = convert_tree(ctx, &transform_root, runtime_id)?; + Ok(FunctionParameterTransform { + resolver_input: match resolver_input.resolve_ref()?.1 { + TypeDef::Struct(_) => { + ctx.register_type(resolver_input.try_into()?, Some(runtime_id))? + } + _ => return Err(errors::invalid_input_type(&resolver_input.repr()?)), + } + .into(), + transform_root, + }) + }) + .transpose()?; Ok(TypeNode::Function { base: BaseBuilderInit { ctx, @@ -42,6 +67,7 @@ impl TypeConversion for Func { .build()?, data: FunctionTypeData { input, + parameter_transform, output, materializer: mat_id, rate_calls: self.data.rate_calls, diff --git a/typegraph/core/src/types/mod.rs b/typegraph/core/src/types/mod.rs index 79622363a..0c837855a 100644 --- a/typegraph/core/src/types/mod.rs +++ b/typegraph/core/src/types/mod.rs @@ -1,6 +1,7 @@ // Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. // SPDX-License-Identifier: MPL-2.0 +pub mod subgraph; pub mod type_def; pub mod type_id; pub mod type_ref; diff --git a/typegraph/core/src/types/subgraph/map.rs b/typegraph/core/src/types/subgraph/map.rs new file mode 100644 index 000000000..2889aa027 --- /dev/null +++ b/typegraph/core/src/types/subgraph/map.rs @@ -0,0 +1,142 @@ +// Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. +// SPDX-License-Identifier: MPL-2.0 + +use std::collections::HashMap; + +use crate::errors::Result; +use crate::global_store::Store; +use crate::t::{self, TypeBuilder}; +use crate::types::{TypeDef, TypeId}; +use crate::wit::core::{TypeEither, TypeList, TypeOptional, TypeStruct, TypeUnion}; + +#[derive(Debug, Clone)] +struct Context { + result_aliases: HashMap, +} + +struct SubgraphMap +where + M: Fn(TypeId) -> Result, +{ + mapper: M, +} + +pub fn map(root: TypeId, mapper: M) -> Result +where + M: Fn(TypeId) -> Result, +{ + let mut ctx = Context { + result_aliases: HashMap::new(), + }; + SubgraphMap { mapper }.map(root, &mut ctx) +} + +impl SubgraphMap +where + M: Fn(TypeId) -> Result, +{ + pub fn map(&self, type_id: TypeId, ctx: &mut Context) -> Result { + if let Some(alias) = ctx.result_aliases.get(&type_id) { + return t::ref_(alias).build(); + } + let alias = Store::generate_alias(); + ctx.result_aliases.insert(type_id, alias.clone()); + + let new_type_id = (self.mapper)(type_id)?; + + let res = self.map_children(new_type_id, ctx)?; + Store::register_alias(alias, res)?; + ctx.result_aliases.remove(&type_id); + + Ok(res) + } + + fn map_children(&self, type_id: TypeId, ctx: &mut Context) -> Result { + let (_, type_def) = type_id.resolve_ref()?; + + match type_def { + TypeDef::Struct(ty) => { + let props = ty + .data + .props + .iter() + .map(|(name, prop)| -> Result<_> { + let prop_type = self.map(prop.into(), ctx)?; + Ok((name.clone(), prop_type.0)) + }) + .collect::>>()?; + + if props == ty.data.props { + Ok(type_id) + } else { + ty.type_with_data(TypeStruct { + props, + ..ty.data.clone() + }) + } + } + + TypeDef::List(ty) => { + let item_type = self.map(ty.data.of.into(), ctx)?.0; + if item_type == ty.data.of { + Ok(type_id) + } else { + ty.type_with_data(TypeList { + of: item_type, + ..ty.data + }) + } + } + + TypeDef::Optional(ty) => { + let item_type = self.map(ty.data.of.into(), ctx)?.0; + if item_type == ty.data.of { + Ok(type_id) + } else { + ty.type_with_data(TypeOptional { + of: item_type, + ..ty.data.clone() + }) + } + } + + TypeDef::Union(ty) => { + let variants = ty + .data + .variants + .iter() + .map(|type_id| self.map(type_id.into(), ctx).map(|x| x.0)) + .collect::>>()?; + + if variants == ty.data.variants { + Ok(type_id) + } else { + ty.type_with_data(TypeUnion { variants }) + } + } + + TypeDef::Either(ty) => { + let variants = ty + .data + .variants + .iter() + .map(|type_id| self.map(type_id.into(), ctx).map(|x| x.0)) + .collect::>>()?; + + if variants == ty.data.variants { + Ok(type_id) + } else { + ty.type_with_data(TypeEither { variants }) + } + } + + TypeDef::Boolean(_) + | TypeDef::Integer(_) + | TypeDef::Float(_) + | TypeDef::String(_) + | TypeDef::File(_) => Ok(type_id), + + TypeDef::Func(_) => Err("not supported".into()), + } + } +} diff --git a/typegraph/core/src/types/subgraph/mod.rs b/typegraph/core/src/types/subgraph/mod.rs new file mode 100644 index 000000000..11609b26f --- /dev/null +++ b/typegraph/core/src/types/subgraph/mod.rs @@ -0,0 +1,24 @@ +// Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. +// SPDX-License-Identifier: MPL-2.0 + +use crate::errors::Result; + +use super::TypeId; +mod map; + +pub struct Subgraph { + root: TypeId, +} + +impl Subgraph { + pub fn new(root: TypeId) -> Self { + Self { root } + } + + pub fn map(self, mapper: M) -> Result + where + M: Fn(TypeId) -> Result, + { + map::map(self.root, mapper) + } +} diff --git a/typegraph/core/src/types/type_def.rs b/typegraph/core/src/types/type_def.rs index bc9d82756..9fbf5eb21 100644 --- a/typegraph/core/src/types/type_def.rs +++ b/typegraph/core/src/types/type_def.rs @@ -5,6 +5,7 @@ use std::rc::Rc; use crate::conversion::types::TypeConversion; use crate::errors::Result; +use crate::global_store::{NameRegistration, Store}; use crate::typegraph::TypegraphContext; use crate::wit::core::{ PolicySpec, TypeBase, TypeEither, TypeFile, TypeFloat, TypeFunc, TypeInteger, TypeList, @@ -41,6 +42,30 @@ pub struct NonRefType { pub data: T, } +impl NonRefType +where + Rc>: Into, +{ + pub fn type_with_data(&self, data: T) -> Result { + let base = TypeBase { + name: None, // different name -- since it is now a different type + ..self.base.clone() + }; + Store::register_type_def( + |type_id| { + Rc::new(Self { + id: type_id, + base, + extended_base: self.extended_base.clone(), + data, + }) + .into() + }, + NameRegistration(false), + ) + } +} + #[allow(clippy::derivable_impls)] impl Default for TypeBase { fn default() -> Self { diff --git a/typegraph/core/src/utils/mod.rs b/typegraph/core/src/utils/mod.rs index 3cf219450..07f92038e 100644 --- a/typegraph/core/src/utils/mod.rs +++ b/typegraph/core/src/utils/mod.rs @@ -8,8 +8,9 @@ use indexmap::IndexMap; use serde_json::json; use crate::errors::Result; -use crate::global_store::Store; -use crate::types::TypeId; +use crate::global_store::{NameRegistration, Store}; +use crate::types::subgraph::Subgraph; +use crate::types::{TypeDefExt, TypeId}; use crate::wit::core::{Guest, TypeBase, TypeId as CoreTypeId, TypeStruct}; use crate::wit::utils::{Auth as WitAuth, QueryDeployParams}; use crate::Lib; @@ -255,4 +256,34 @@ impl crate::wit::utils::Guest for crate::Lib { fn unpack_tarb64(tar_b64: String, dest: String) -> Result<()> { fs_host::unpack_base64(&tar_b64, dest).map_err(|e| e.into()) } + + fn remove_injections(id: CoreTypeId) -> Result { + Subgraph::new(id.into()) + .map(remove_injection) + .map(|id| id.into()) + } +} + +pub fn remove_injection(type_id: TypeId) -> Result { + let (_, type_def) = type_id.resolve_ref()?; + + let x_base = type_def.x_base(); + if x_base.injection.is_none() { + return Ok(type_id); + } + + let mut x_base = x_base.clone(); + x_base.injection = None; + + Store::register_type_def( + move |id| type_def.with_x_base(id, x_base), + NameRegistration(false), + ) +} + +pub fn clear_name(base: &TypeBase) -> TypeBase { + TypeBase { + name: None, + ..base.clone() + } } diff --git a/typegraph/core/wit/typegraph.wit b/typegraph/core/wit/typegraph.wit index 4cab2d005..1ffc09901 100644 --- a/typegraph/core/wit/typegraph.wit +++ b/typegraph/core/wit/typegraph.wit @@ -1,7 +1,6 @@ package metatype:typegraph interface core { - record error { stack: list, } @@ -145,18 +144,41 @@ interface core { enumeration: option>, } structb: func(data: type-struct, base: type-base) -> result + extend-struct: func(tpe: type-id, props: list>) -> result get-type-repr: func(id: type-id) -> result + variant value-source { + raw(string), // json + context(string), // key + secret(string), // key + parent(string), // name + param(string), // name + } + + record parameter-transform { + resolver-input: type-id, + transform-tree: string, + } + record type-func { inp: type-id, + parameter-transform: option, out: type-id, mat: materializer-id, rate-calls: bool, rate-weight: option, } + funcb: func(data: type-func) -> result + record transform-data { + query-input: type-id, + parameter-transform: parameter-transform, + } + + get-transform-data: func(resolver-input: type-id, transform-tree: string) -> result + type policy-id = u32 record policy { @@ -524,10 +546,13 @@ interface utils { gql-remove-query: func(tg-name: list) -> result unpack-tarb64: func(tar-b64: string, dest: string) -> result<_, error> + + remove-injections: func(type-id: type-id) -> result } interface host { print: func(s: string) + eprint: func(s: string) expand-glob: func(root: string, exclude: list) -> result, string> file-exists: func(path: string) -> result read-file: func(path: string) -> result, string> diff --git a/typegraph/node/sdk/src/host/host.ts b/typegraph/node/sdk/src/host/host.ts index 839bc4e53..fe76ac6ce 100644 --- a/typegraph/node/sdk/src/host/host.ts +++ b/typegraph/node/sdk/src/host/host.ts @@ -44,6 +44,10 @@ export function print(msg: string) { console.log(msg); } +export function eprint(msg: string) { + console.error(msg); +} + export function getCwd(): string { try { return process.cwd(); diff --git a/typegraph/node/sdk/src/runtimes/deno.ts b/typegraph/node/sdk/src/runtimes/deno.ts index 660e45e36..5a784fdc6 100644 --- a/typegraph/node/sdk/src/runtimes/deno.ts +++ b/typegraph/node/sdk/src/runtimes/deno.ts @@ -2,7 +2,7 @@ // SPDX-License-Identifier: MPL-2.0 import * as t from "../types.js"; -import { runtimes } from "../wit.js"; +import { runtimes, wit_utils } from "../wit.js"; import { Effect } from "../gen/interfaces/metatype-typegraph-runtimes.js"; import Policy from "../policy.js"; import { Materializer, Runtime } from "./mod.js"; @@ -44,14 +44,13 @@ export class DenoRuntime extends Runtime { } func< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( inp: I, out: O, { code, secrets = [], effect = fx.read() }: DenoFunc, - ): t.Func { + ): t.Func { const matId = runtimes.registerDenoFunc({ code, secrets }, effect); const mat: FunMat = { _id: matId, @@ -63,14 +62,13 @@ export class DenoRuntime extends Runtime { } import< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( inp: I, out: O, { name, module, effect = fx.read(), secrets = [] }: DenoImport, - ): t.Func { + ): t.Func { const matId = runtimes.importDenoFunction({ funcName: name, module, @@ -87,16 +85,16 @@ export class DenoRuntime extends Runtime { } identity< - P extends Record = Record, - I extends t.Struct

= t.Struct

, - >(inp: I): t.Func { + I extends t.Typedef = t.Typedef, + >(inp: I): t.Func { const mat: PredefinedFuncMat = { _id: runtimes.getPredefinedDenoFunc({ name: "identity" }), name: "identity", }; + const out = wit_utils.removeInjections(inp._id); return t.func( inp, - inp, + new t.Typedef(out, {}), mat, ); } diff --git a/typegraph/node/sdk/src/runtimes/graphql.ts b/typegraph/node/sdk/src/runtimes/graphql.ts index 219e00c42..0c66eb433 100644 --- a/typegraph/node/sdk/src/runtimes/graphql.ts +++ b/typegraph/node/sdk/src/runtimes/graphql.ts @@ -15,10 +15,9 @@ export class GraphQLRuntime extends Runtime { } query< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, - >(inp: I, out: O, path?: string[]): t.Func { + >(inp: I, out: O, path?: string[]): t.Func { const matId = runtimes.graphqlQuery({ runtime: this._id, effect: fx.read(), @@ -33,15 +32,14 @@ export class GraphQLRuntime extends Runtime { } mutation< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( inp: I, out: O, effect: Effect, path?: string[], - ): t.Func { + ): t.Func { const matId = runtimes.graphqlMutation({ runtime: this._id, effect, diff --git a/typegraph/node/sdk/src/runtimes/http.ts b/typegraph/node/sdk/src/runtimes/http.ts index 6ffe82b10..bb43cadea 100644 --- a/typegraph/node/sdk/src/runtimes/http.ts +++ b/typegraph/node/sdk/src/runtimes/http.ts @@ -33,8 +33,7 @@ export class HttpRuntime extends Runtime { #request< M extends HttpMethod, - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( method: M, @@ -42,7 +41,7 @@ export class HttpRuntime extends Runtime { out: O, options: Omit, effect: Effect, - ): t.Func { + ): t.Func { const matId = runtimes.httpRequest({ runtime: this._id, effect, @@ -57,66 +56,61 @@ export class HttpRuntime extends Runtime { } get< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( inp: I, out: O, options: Omit, - ): t.Func { + ): t.Func { return this.#request("get", inp, out, options, fx.read()); } post< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( inp: I, out: O, options: Omit, effect?: Effect, - ): t.Func { + ): t.Func { return this.#request("get", inp, out, options, effect ?? fx.create()); } put< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( inp: I, out: O, options: Omit, effect?: Effect, - ): t.Func { + ): t.Func { return this.#request("get", inp, out, options, effect ?? fx.update()); } patch< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( inp: I, out: O, options: Omit, effect?: Effect, - ): t.Func { + ): t.Func { return this.#request("patch", inp, out, options, effect ?? fx.update()); } delete_< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( inp: I, out: O, options: Omit, effect?: Effect, - ): t.Func { + ): t.Func { return this.#request("get", inp, out, options, effect ?? fx.delete_()); } } diff --git a/typegraph/node/sdk/src/runtimes/python.ts b/typegraph/node/sdk/src/runtimes/python.ts index 63cfe00c4..51f840c40 100644 --- a/typegraph/node/sdk/src/runtimes/python.ts +++ b/typegraph/node/sdk/src/runtimes/python.ts @@ -85,14 +85,13 @@ export class PythonRuntime extends Runtime { } import< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( inp: I, out: O, { name, module, effect = fx.read(), secrets = [] }: PythonImport, - ): t.Func { + ): t.Func { const base = { runtime: this._id, effect, diff --git a/typegraph/node/sdk/src/runtimes/wasmedge.ts b/typegraph/node/sdk/src/runtimes/wasmedge.ts index 7355b25de..76a636607 100644 --- a/typegraph/node/sdk/src/runtimes/wasmedge.ts +++ b/typegraph/node/sdk/src/runtimes/wasmedge.ts @@ -19,8 +19,7 @@ export class WasmEdgeRuntime extends Runtime { } wasi< - P extends Record = Record, - I extends t.Struct

= t.Struct

, + I extends t.Typedef = t.Typedef, O extends t.Typedef = t.Typedef, >( inp: I, @@ -30,7 +29,7 @@ export class WasmEdgeRuntime extends Runtime { wasm: string; effect?: Effect; }, - ): t.Func { + ): t.Func { const matId = runtimes.fromWasiModule( { runtime: this._id, diff --git a/typegraph/node/sdk/src/typegraph.ts b/typegraph/node/sdk/src/typegraph.ts index 4e0eb2b4d..e188821be 100644 --- a/typegraph/node/sdk/src/typegraph.ts +++ b/typegraph/node/sdk/src/typegraph.ts @@ -30,7 +30,37 @@ interface TypegraphArgs { disableAutoSerialization?: boolean; } -export interface TypegraphBuilderArgs { +export class ApplyFromArg { + constructor(public name: string | null) { } +} + +export class ApplyFromStatic { + constructor(public value: any) { } +} + +export class ApplyFromSecret { + constructor(public key: string) { } +} + +export class ApplyFromContext { + constructor(public key: string) { } +} + +export class ApplyFromParent { + constructor(public typeName: string) { } +} + +const InjectionSource = { + asArg: (name?: string) => new ApplyFromArg(name ?? null), + set: (value: any) => new ApplyFromStatic(value), + fromSecret: (key: string) => new ApplyFromSecret(key), + fromContext: (key: string) => new ApplyFromContext(key), + fromParent: (typeName: string) => new ApplyFromParent(typeName), +} as const; + +type InjectionSourceType = typeof InjectionSource; + +export interface TypegraphBuilderArgs extends InjectionSourceType { expose: (exports: Exports, defaultPolicy?: Policy) => void; inherit: () => InheritDef; rest: (graphql: string) => number; @@ -69,7 +99,7 @@ export class InheritDef { export type TypegraphBuilder = (g: TypegraphBuilderArgs) => void; export class RawAuth { - constructor(readonly jsonStr: string) {} + constructor(readonly jsonStr: string) { } } export interface TypegraphOutput { @@ -165,6 +195,7 @@ export function typegraph( ref: (name: string) => { return genRef(name); }, + ...InjectionSource, }; builder(g); diff --git a/typegraph/node/sdk/src/types.ts b/typegraph/node/sdk/src/types.ts index 430ac1661..6517fe77f 100644 --- a/typegraph/node/sdk/src/types.ts +++ b/typegraph/node/sdk/src/types.ts @@ -14,6 +14,7 @@ import { TypeOptional, TypeString, TypeUnion, + ParameterTransform, } from "./gen/interfaces/metatype-typegraph-core.js"; import { Reduce } from "./gen/interfaces/metatype-typegraph-utils.js"; import { FuncParams } from "./gen/interfaces/metatype-typegraph-runtimes.js"; @@ -27,7 +28,7 @@ import { serializeStaticInjection, } from "./utils/injection_utils.js"; import { InjectionValue } from "./utils/type_utils.js"; -import { InheritDef } from "./typegraph.js"; +import { ApplyFromArg, ApplyFromContext, ApplyFromParent, ApplyFromSecret, ApplyFromStatic, InheritDef } from "./typegraph.js"; export type PolicySpec = Policy | PolicyPerEffectObject | { none: Policy; @@ -510,21 +511,72 @@ export function struct

( ); } +// `Record` does work... +type ApplyParamObjectNode = { + [key: string]: ApplyParamNode; +}; +type ApplyParamArrayNode = Array; +type ApplyParamLeafNode = ApplyFromArg | ApplyFromStatic | ApplyFromContext | ApplyFromSecret | ApplyFromParent; +type ApplyParamNode = ApplyParamObjectNode | ApplyParamArrayNode | ApplyParamLeafNode; + +function serializeApplyParamNode(node: ApplyParamNode): Record { + if (node instanceof ApplyFromArg) { + return { source: "arg", name: node.name }; + } else if (node instanceof ApplyFromStatic) { + return { source: "static", value: JSON.stringify(node.value) }; + } else if (node instanceof ApplyFromContext) { + return { source: "context", key: node.key }; + } else if (node instanceof ApplyFromSecret) { + return { source: "secret", key: node.key }; + } else if (node instanceof ApplyFromParent) { + return { source: "parent", typeName: node.typeName }; + } else if (Array.isArray(node)) { + return { + type: "array", + items: node.map(serializeApplyParamNode), + }; + } else if (typeof node === "object" && node !== null) { + return { + type: "object", + fields: mapValues(node, serializeApplyParamNode), + }; + } + throw new Error(`Unexpected node type: ${node}`); +} + export class Func< - P extends { [key: string]: Typedef } = Record, - I extends Struct

= Struct

, + I extends Typedef = Typedef, O extends Typedef = Typedef, M extends Materializer = Materializer, > extends Typedef { inp: I; out: O; mat: M; + parameterTransform: ParameterTransform | null; + config: FuncConfig | null; - constructor(_id: number, inp: I, out: O, mat: M) { + constructor(_id: number, inp: I, out: O, mat: M, parameterTransform: ParameterTransform | null = null, config: FuncConfig | null = null) { super(_id, {}); this.inp = inp; this.out = out; this.mat = mat; + this.parameterTransform = parameterTransform; + this.config = config; + } + + extend(fields: Record): Func { + const output = core.extendStruct( + this.out._id, + Object.entries(fields).map(([name, typ]) => [name, typ._id] as [string, number]) + ); + + return func( + this.inp, + new Typedef(output, {}), + this.mat, + this.parameterTransform, + this.config, + ); } reduce(value: Record) { @@ -538,19 +590,37 @@ export class Func< ); return func( - new Typedef(reducedId, {}) as Struct

, + new Typedef(reducedId, {}), this.out, this.mat, ); } + apply(value: ApplyParamObjectNode): Func { + const serialized = serializeApplyParamNode(value); + if (typeof serialized !== "object" || serialized == null || serialized.type !== "object") { + throw new Error("Invalid apply value: root must be an object"); + } + const transformTree = JSON.stringify(serialized.fields); + const transformData = core.getTransformData(this.inp._id, transformTree); + + return func( + new Typedef(transformData.queryInput, {}), + this.out, + this.mat, + transformData.parameterTransform, + this.config, + ) + } + rate( inp: { calls: boolean; weight?: number }, - ): Func { + ): Func { return func( this.inp, this.out, this.mat, + this.parameterTransform, { rateCalls: inp.calls ?? false, rateWeight: inp.weight }, ); } @@ -570,26 +640,31 @@ type FuncConfig = { }; export function func< - P extends { [key: string]: Typedef }, - I extends Struct

= Struct

, + I extends Typedef = Typedef, O extends Typedef = Typedef, M extends Materializer = Materializer, >( inp: I, out: O, mat: M, - { rateCalls = false, rateWeight = undefined }: FuncConfig = {}, + transformData: ParameterTransform | null = null, + config: FuncConfig | null = null, ) { - return new Func( + const rateCalls = config?.rateCalls ?? false; + const rateWeight = config?.rateWeight ?? undefined; + return new Func( core.funcb({ inp: inp._id, out: out._id, mat: mat._id, + parameterTransform: transformData ?? undefined, rateCalls, rateWeight, }) as number, inp, out, mat, + transformData, + config, ); } diff --git a/typegraph/python/typegraph/graph/typegraph.py b/typegraph/python/typegraph/graph/typegraph.py index dddbb75b8..d82594e79 100644 --- a/typegraph/python/typegraph/graph/typegraph.py +++ b/typegraph/python/typegraph/graph/typegraph.py @@ -4,7 +4,7 @@ import inspect from dataclasses import dataclass from pathlib import Path -from typing import TYPE_CHECKING, Callable, List, Optional, Union +from typing import TYPE_CHECKING, Callable, List, Optional, Union, Any from typegraph.gen.exports.core import ( ArtifactResolutionConfig, @@ -89,6 +89,31 @@ def expose( raise Exception(res.value) +@dataclass +class ApplyFromArg: + name: Optional[str] + + +@dataclass +class ApplyFromStatic: + value: Any + + +@dataclass +class ApplyFromSecret: + key: str + + +@dataclass +class ApplyFromContext: + key: str + + +@dataclass +class ApplyFromParent: + type_name: str + + @dataclass class Graph: typegraph: Typegraph @@ -124,6 +149,21 @@ def auth(self, value: Union[Auth, RawAuth]): def ref(self, name: str) -> "t.typedef": return gen_ref(name) + def as_arg(self, name: Optional[str] = None): + return ApplyFromArg(name) + + def set(self, value: Any): + return ApplyFromStatic(value) + + def from_secret(self, key: str): + return ApplyFromSecret(key) + + def from_context(self, key: str): + return ApplyFromContext(key) + + def from_parent(self, type_name: str): + return ApplyFromParent(type_name) + @dataclass class TypegraphOutput: diff --git a/typegraph/python/typegraph/host/host.py b/typegraph/python/typegraph/host/host.py index 05820bcca..13eb72acc 100644 --- a/typegraph/python/typegraph/host/host.py +++ b/typegraph/python/typegraph/host/host.py @@ -6,6 +6,7 @@ from typegraph.gen.types import Err, Ok, Result import os import re +import sys def has_match(text: str, items: List[str]) -> bool: @@ -20,6 +21,9 @@ class HostImpl(imports.HostHost): def print(self, msg: str): print(msg) + def eprint(self, msg: str): + print(msg, file=sys.stderr) + def expand_glob(self, root: str, exclude: List[str]) -> Result[List[str], str]: try: result = [] diff --git a/typegraph/python/typegraph/runtimes/deno.py b/typegraph/python/typegraph/runtimes/deno.py index dfbb0ab67..f4771347f 100644 --- a/typegraph/python/typegraph/runtimes/deno.py +++ b/typegraph/python/typegraph/runtimes/deno.py @@ -17,7 +17,7 @@ from typegraph.gen.types import Err from typegraph.policy import Policy from typegraph.runtimes.base import Materializer, Runtime -from typegraph.wit import runtimes, store +from typegraph.wit import runtimes, wit_utils, store if TYPE_CHECKING: from typegraph import t @@ -117,9 +117,14 @@ def identity(self, inp: "t.struct") -> "t.func": if isinstance(res, Err): raise Exception(res.value) + out_res = wit_utils.remove_injections(store, inp.id) + if isinstance(res, Err): + raise Exception(res.value) + out = t.typedef(out_res.value) + return t.func( inp, - inp, + out, PredefinedFunMat(id=res.value, name="identity", effect=EffectRead()), ) diff --git a/typegraph/python/typegraph/t.py b/typegraph/python/typegraph/t.py index 96bd4bfd0..c8ed9e29a 100644 --- a/typegraph/python/typegraph/t.py +++ b/typegraph/python/typegraph/t.py @@ -10,6 +10,7 @@ from typegraph.effects import EffectType from typegraph.gen.exports.core import ( FuncParams, + ParameterTransform, TypeList, TypeBase, TypeEither, @@ -26,7 +27,15 @@ from typegraph.gen.exports.runtimes import EffectRead from typegraph.gen.exports.utils import Reduce from typegraph.gen.types import Err -from typegraph.graph.typegraph import core, store +from typegraph.graph.typegraph import ( + core, + store, + ApplyFromArg, + ApplyFromContext, + ApplyFromParent, + ApplyFromSecret, + ApplyFromStatic, +) from typegraph.injection import ( serialize_generic_injection, serialize_parent_injection, @@ -599,24 +608,59 @@ def extend(self, props: Dict[str, typedef]): return struct(props={**self.props, **props}) +ApplyParamObjectNode = Dict[str, "ApplyParamNode"] +ApplyParamArrayNode = List["ApplyParamNode"] +ApplyParamLeafNode = Union[ + ApplyFromArg, ApplyFromStatic, ApplyFromContext, ApplyFromSecret, ApplyFromParent +] + +ApplyParamNode = Union[ApplyParamObjectNode, ApplyParamArrayNode, ApplyParamLeafNode] + + +def serialize_apply_param_node(node: ApplyParamNode) -> Any: + if isinstance(node, ApplyFromArg): + return {"source": "arg", "name": node.name} + if isinstance(node, ApplyFromStatic): + return {"source": "static", "value": JsonLib.dumps(node.value)} + if isinstance(node, ApplyFromContext): + return {"source": "context", "key": node.key} + if isinstance(node, ApplyFromSecret): + return {"source": "secret", "key": node.key} + if isinstance(node, ApplyFromParent): + return {"source": "parent", "type_name": node.type_name} + if isinstance(node, dict): + return { + "type": "object", + "fields": {k: serialize_apply_param_node(v) for k, v in node.items()}, + } + if isinstance(node, (og_list, tuple)): + return {"type": "array", "items": [serialize_apply_param_node(v) for v in node]} + + raise Exception(f"unexpected node type: node={node}") + + class func(typedef): - inp: struct + inp: Union[struct, typedef] out: typedef mat: Materializer rate_calls: bool rate_weight: Optional[int] + parameter_transform: Optional[ParameterTransform] def __init__( self, - inp: struct, + inp: Union[struct, typedef], out: typedef, mat: Materializer, + /, rate_calls: bool = False, rate_weight: Optional[int] = None, + parameter_transform: Optional[ParameterTransform] = None, ): data = TypeFunc( inp=inp.id, out=out.id, + parameter_transform=parameter_transform, mat=mat.id, rate_calls=rate_calls, rate_weight=rate_weight, @@ -631,26 +675,76 @@ def __init__( self.mat = mat self.rate_calls = rate_calls self.rate_weight = rate_weight + self.parameter_transform = parameter_transform def rate(self, calls: bool = False, weight: Optional[int] = None) -> "func": - return func(self.inp, self.out, self.mat, calls, weight) + return func( + self.inp, + self.out, + self.mat, + parameter_transform=self.parameter_transform, + rate_calls=calls, + rate_weight=weight, + ) def extend(self, props: Dict[str, typedef]): - if not isinstance(self.out, struct): - raise Exception("Cannot extend non-struct function output") + res = core.extend_struct( + store, self.out.id, og_list((k, v.id) for k, v in props.items()) + ) + if isinstance(res, Err): + raise Exception(res.value) - out = self.out.extend(props) - return func(self.inp, out, self.mat) + out = typedef(res.value) - def reduce(self, value: Dict[str, any]) -> "func": + return func( + self.inp, + out, + self.mat, + parameter_transform=self.parameter_transform, + rate_calls=self.rate_calls, + rate_weight=self.rate_weight, + ) + + def reduce(self, value: Dict[str, Any]) -> "func": data = Reduce(paths=build_reduce_data(value, [], [])) reduced_id = wit_utils.gen_reduceb(store, self.inp.id, data=data) if isinstance(reduced_id, Err): raise Exception(reduced_id.value) - return func(typedef(id=reduced_id.value), self.out, self.mat) + # TODO typedef(...).as_struct() + return func( + typedef(id=reduced_id.value), + self.out, + self.mat, + parameter_transform=self.parameter_transform, + rate_calls=self.rate_calls, + rate_weight=self.rate_weight, + ) + + def apply(self, value: ApplyParamObjectNode) -> "func": + serialized = serialize_apply_param_node(value) + assert isinstance(serialized, dict) + assert serialized["type"] == "object" + transform_tree = JsonLib.dumps(serialized["fields"]) + + transform_data = core.get_transform_data(store, self.inp.id, transform_tree) + if isinstance(transform_data, Err): + import sys + + print(transform_tree, file=sys.stderr) + raise Exception(transform_data.value) + + return func( + typedef(transform_data.value.query_input), + self.out, + self.mat, + parameter_transform=transform_data.value.parameter_transform, + rate_calls=self.rate_calls, + rate_weight=self.rate_weight, + ) + @staticmethod def from_type_func( data: FuncParams, rate_calls: bool = False, rate_weight: Optional[int] = None ) -> "func": @@ -663,6 +757,7 @@ def from_type_func( mat, rate_calls=rate_calls, rate_weight=rate_weight, + parameter_transform=None, ) diff --git a/typegraph/python/typegraph/utils.py b/typegraph/python/typegraph/utils.py index f3b249eaf..05acb4843 100644 --- a/typegraph/python/typegraph/utils.py +++ b/typegraph/python/typegraph/utils.py @@ -33,7 +33,7 @@ def serialize_config(config: Optional[ConfigSpec]) -> Optional[List[Tuple[str, s return [(k, json.dumps(v)) for k, v in config.items()] -def build_reduce_data(node: any, paths: List[ReducePath], curr_path: List[str]): +def build_reduce_data(node: Any, paths: List[ReducePath], curr_path: List[str]): if node is None: raise Exception(f"unsupported value {str(node)} at {'.'.join(curr_path)},") diff --git a/website/docs/reference/types/index.mdx b/website/docs/reference/types/index.mdx index 7f48843e4..e65f97488 100644 --- a/website/docs/reference/types/index.mdx +++ b/website/docs/reference/types/index.mdx @@ -366,6 +366,14 @@ created with the [runtime](./runtimes) instance. |output type|any type|The type of the output data.| |materializer|[`Materializer`](./runtimes)|The materializer to use to perform the operation/computation.| +#### Methods +|Method|Purpose|Reference page| +|---|---|---| +|`rate`|Rate limiting|[Rate limiting](/docs/reference/typegate/rate-limiting)| +|`reduce`|Parameter transformation|[`reduce`](/docs/reference/types/parameter-transformations#funcreducetree)| +|`apply`|Parameter transformation|[`apply`](/docs/reference/types/parameter-transformations#funcapplytree)| + + #### Examples ```python diff --git a/website/docs/reference/types/parameter-transformations.mdx b/website/docs/reference/types/parameter-transformations.mdx new file mode 100644 index 000000000..46cfd32ba --- /dev/null +++ b/website/docs/reference/types/parameter-transformations.mdx @@ -0,0 +1,281 @@ +import SDKTabs from "@site/src/components/SDKTabs"; +import TabItem from "@theme/TabItem"; + + +# Parameter Transformations + + +:::info Use cases +You might consider using parameter transformations if: +- you want a simple interface for your function but you cannot change the input type; +- if you want to re-use your function with a different set of parameters. +::: + +Parameter transformations are a way to refine the input type of your function to adapt to your need. +They enable you to use injection to predefined input type +without manually rewriting the type to add injections. +It is most usefull for input types generated by runtimes, especially the `PrismaRuntime` which generates complex input types. + +**Related concept:** [Injection](./injections) +:::note +In the following sections a _plain object_ means: +- **in JavaScript/TypeScript**: an object (literal) +- **in Python**: a dictionary +::: + + +## `func::reduce(tree)` + +The reduce method allows you to only enable some paths +in the graph of the input type of the function. + +The only required parameter to `func::reduce` is the reduce tree. + +### Reduce tree + +A reduce tree (reduce sub-tree) is plain object +whose property values are either a reduce sub-tree or a `g.inherit()` expression. + +Each plain object represents a `t.struct()` in the input type subgraph. + +All the nodes that are missing from the reduce tree will set the argument to +its default value. Therefore they must be optional. + +Consider the following typegraph: + + + +```ts +const post = t.struct({ + id: t.uuid(), + title: t.string(), + content: t.string(), +}); + +const user = t.struct({ + id: t.uuid(), + email: t.email(), + posts: t.list(post), +}); + +const filter = t.struct({ + id: t.uuid().optional(), + email: t.email().optional(), + posts: t.struct({ + count: t.struct({ + gt: t.integer({ min: 1 }).optional(), + lt: t.integer({ min: 1 }).optional(), + }), + tag: t.list(t.string()), + }), +}); + +const deno = DenoRuntime(); +const findUsers = deno.func(filter, t.list(user), { code: "..." }); + +g.expose({ + findUserById: findUsers.reduce({ + id: g.inherit(), + }), + findUsersByPostCount: findUsers.reduce({ + posts: { + count: g.inherit(), + } + }), + currentUser: findUsers.reduce({ + id: g.inherit().fromContext("profile.userId"), + }), +}); +``` + + + +```python +post = t.struct({ + "id": t.uuid(), + "email": t.email(), + "posts": t.list(post), +}) + +user = t.struct({ + "id": t.uuid(), + "email": t.email(), + "posts": t.list(post), +}) + +filter = t.struct({ + "id": t.uuid().optional(), + "email": t.email().optional(), + "posts": t.struct({ + "count": t.struct({ + "gt": t.integer(min=1).optional(), + "lt": t.integer(min=1).optional(), + }), + "tag": t.list(t.string()), + }), +}) + +deno = DenoRuntime() +findUsers = deno.func(filter, t.list(user), code="...") + +g.expose( + findUserById=findUsers.reduce({ + "id": g.inherit(), + }), + findUsersByPostCount=findUsers.reduce({ + "posts": { + "count": g.inherit(), + } + }), + currentUser=findUsers.reduce({ + "id": g.inherit().from_context("profile.userId") + }), +) +``` + + + +The following queries are valid: +```graphql +query FindUsersById($id: String!) { + findUserById(id: $id) { + id + email + } +} + +query FindUsersByPostCount($min: Int!) { + findUsersByPostCount(posts: { count: { gt: $min } }) { + id + email + } +} +``` + +However the following query is invalid: +```graphql +query Q { + findUserById(email: "user@example.com") { + id email + } +} +``` + +The `currentUser` function will not accept any parameter. + +**Notes**: +- The only fully supported non-leaf node is `t.struct()`. +- Support for `t.either()` and `t.union()` is experimental. +- `t.list()` is not supported. +- Each non-leaf node may be optional or not. + + + +## `func::apply(tree)` + +The apply method allows you to rewrite the input type of the function, +enabling flat input type whatever is the level of nesting in the original input type. + +The only required parameter to `func::apply` is the apply tree. + +### Apply tree + +Lexicon | Definition +---|---| +Apply node | Object node, list node or leaf-node | +Apply tree | Object node | +Object node | A plain object whose property values are nodes. It represents a `t.struct()`. | +List node | An array or list whose items are nodes. It represents a `t.list()`. | +Leaf node | An apply expression. See [below](#apply-expressions). | + +From the code blocks in previouse section, let's make the following changes. + + + +```typescript +g.expose( + findUsersByPostCount: findUsers.apply({ + posts: { + count: { + lt: g.as_arg(), + gt: g.as_arg(), + } + } + }), + findTechWriters: findUsers.apply({ + posts: { + tags: [g.set("tech")] + } + }), +) +``` + + + +```python +g.expose( + findUserByPostCount=findUsers.apply({ + "posts": { + "count": { + "lt": g.as_arg(), + "gt": g.as_arg(), + } + } + }), + findTechWriters=findUsers.apply({ + "posts": { + "tags": [g.set("tech")] + } + }), +) +``` + + + +In this case, the matching queries are the following: +```graphql +query FindUsersByPostCount($lt: Int, $gt: Int) { + findUsersByPostCount(lt: $lt, gt: $gt) { + id + email + } +} + +query FindTechWriters { + findTechWriters { + id + email + } +} +``` + +Those queries will be translated to the following: +```graphql +query FindUsersByPostCount($lt: Int, $gt: Int) { + findUsers({ posts: { count: { lt: $lt, gt: $gt } } }) { + id + email + } +} + +query FindTechWriters { + findUsers({ posts: { tags: ["tech"] } }) { + id + email + } +} +``` + +### Apply expressions + +An apply expression indicates the source of the value for a specific leaf node +in the apply tree. + +Apply expression | Source +---|--- +`g.as_arg([name])` | The value will be provided as a parameter, under the name `name`. It is optional for object properties where the default is the property key. +`g.from_parent(type_name)` | The node will have the same value as the field of the parent `t.struct` (of the `t.func`) that has the type name `type_name`. +`g.from_context(path)` | The node will have the value of the context field accessible by the path `path`. +`g.from_secret(key)` | The node will have the value of the secret named `key` on the current typegraph. +`g.set(literal_value)` | The passed `literal_value` will be used. + diff --git a/website/docs/tutorials/metatype-basics/index.mdx b/website/docs/tutorials/metatype-basics/index.mdx index 6652d159d..36a164608 100644 --- a/website/docs/tutorials/metatype-basics/index.mdx +++ b/website/docs/tutorials/metatype-basics/index.mdx @@ -732,6 +732,8 @@ If you're using the GraphiQl interface from earlier, there should be a panel in ### `reduce` +**Reference**: [Parameter transformations](/docs/reference/types/parameter-transformations) + We can use the `reduce` method to modify the input types of functions. This comes especially handy when dealing with generated functions like those from the CRUD helpers from the Prisma runtime. By default, Prisma generates types that supports the whole suite of usecases one might have on a CRUD operation such as allowing creation of objects of related types in a single operation. diff --git a/website/static/specs/0.0.3.json b/website/static/specs/0.0.3.json index 6f23e6b01..845a327ca 100644 --- a/website/static/specs/0.0.3.json +++ b/website/static/specs/0.0.3.json @@ -842,6 +842,16 @@ "format": "uint32", "minimum": 0.0 }, + "parameterTransform": { + "anyOf": [ + { + "$ref": "#/definitions/FunctionParameterTransform" + }, + { + "type": "null" + } + ] + }, "output": { "type": "integer", "format": "uint32", @@ -1300,6 +1310,192 @@ "phone" ] }, + "FunctionParameterTransform": { + "type": "object", + "required": [ + "resolver_input", + "transform_root" + ], + "properties": { + "resolver_input": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "transform_root": { + "$ref": "#/definitions/ParameterTransformNode" + } + } + }, + "ParameterTransformNode": { + "type": "object", + "required": [ + "data", + "typeIdx" + ], + "properties": { + "typeIdx": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "data": { + "$ref": "#/definitions/ParameterTransformNodeData" + } + } + }, + "ParameterTransformNodeData": { + "anyOf": [ + { + "$ref": "#/definitions/ParameterTransformLeafNode" + }, + { + "$ref": "#/definitions/ParameterTransformParentNode" + } + ] + }, + "ParameterTransformLeafNode": { + "oneOf": [ + { + "type": "object", + "required": [ + "name", + "source" + ], + "properties": { + "source": { + "type": "string", + "enum": [ + "arg" + ] + }, + "name": { + "type": "string" + } + } + }, + { + "type": "object", + "required": [ + "source", + "valueJson" + ], + "properties": { + "source": { + "type": "string", + "enum": [ + "static" + ] + }, + "valueJson": { + "type": "string" + } + } + }, + { + "type": "object", + "required": [ + "key", + "source" + ], + "properties": { + "source": { + "type": "string", + "enum": [ + "secret" + ] + }, + "key": { + "type": "string" + } + } + }, + { + "type": "object", + "required": [ + "key", + "source" + ], + "properties": { + "source": { + "type": "string", + "enum": [ + "context" + ] + }, + "key": { + "type": "string" + } + } + }, + { + "type": "object", + "required": [ + "parentIdx", + "source" + ], + "properties": { + "source": { + "type": "string", + "enum": [ + "parent" + ] + }, + "parentIdx": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + } + } + } + ] + }, + "ParameterTransformParentNode": { + "oneOf": [ + { + "type": "object", + "required": [ + "fields", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "object" + ] + }, + "fields": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/ParameterTransformNode" + } + } + } + }, + { + "type": "object", + "required": [ + "items", + "type" + ], + "properties": { + "type": { + "type": "string", + "enum": [ + "array" + ] + }, + "items": { + "type": "array", + "items": { + "$ref": "#/definitions/ParameterTransformNode" + } + } + } + } + ] + }, "Materializer": { "type": "object", "required": [ diff --git a/whiz.yaml b/whiz.yaml index 8e6e87446..1a57917cc 100644 --- a/whiz.yaml +++ b/whiz.yaml @@ -57,6 +57,7 @@ typegraph: jco transpile $WASM_FILE -o typegraph/node/sdk/src/gen --map metatype:typegraph/host=../host/host.js cd typegraph/node + pnpm install pnpm run sdk-build cp ./sdk/{package.json,package-lock.json,LICENSE.md} ./sdk/dist cd ../..