From 237453096701ab4ced0f2fd6d128939e7c58a063 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Tue, 6 Feb 2024 20:51:48 +0300 Subject: [PATCH 01/32] update wit --- typegraph/core/src/t.rs | 1 + typegraph/core/wit/typegraph.wit | 27 ++++++++++++++++++++++++++- whiz.yaml | 1 + 3 files changed, 28 insertions(+), 1 deletion(-) 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/wit/typegraph.wit b/typegraph/core/wit/typegraph.wit index b763e70c1..397ec7085 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, } @@ -132,8 +131,34 @@ interface core { 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-leaf { + path: list, + source: value-source, + } + + type parameter-transform-tree = list + + record parameter-transform { + resolver-input: type-id, + tree: parameter-transform-tree, + } + + record query-parameter { + path: list, + type-id: type-id, + } + record type-func { inp: type-id, + parameter-transform: option, out: type-id, mat: materializer-id, rate-calls: bool, 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 ../.. From bf75c3a18031002dfd85e93a60db5c270cba827a Mon Sep 17 00:00:00 2001 From: Natoandro Date: Wed, 7 Feb 2024 21:05:25 +0300 Subject: [PATCH 02/32] parameter transform tree --- typegraph/core/Cargo.toml | 3 +- typegraph/core/src/global_store.rs | 44 +- typegraph/core/src/lib.rs | 2 + typegraph/core/src/params/apply.rs | 465 ++++++++++++++++++ typegraph/core/src/params/mod.rs | 4 + typegraph/core/src/test_utils.rs | 80 ++- typegraph/core/src/utils/mod.rs | 9 + typegraph/core/wit/typegraph.wit | 16 +- typegraph/python/typegraph/graph/typegraph.py | 42 +- typegraph/python/typegraph/t.py | 91 +++- typegraph/python/typegraph/utils.py | 2 +- 11 files changed, 713 insertions(+), 45 deletions(-) create mode 100644 typegraph/core/src/params/apply.rs create mode 100644 typegraph/core/src/params/mod.rs diff --git a/typegraph/core/Cargo.toml b/typegraph/core/Cargo.toml index f1cc4f786..45f5db303 100644 --- a/typegraph/core/Cargo.toml +++ b/typegraph/core/Cargo.toml @@ -19,9 +19,10 @@ typescript = { path = "../../libs/typescript" } 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/global_store.rs b/typegraph/core/src/global_store.rs index b269c99db..9b9a3006b 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; @@ -463,6 +463,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| { @@ -473,13 +498,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(_)))) @@ -493,4 +513,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..9dd290ef8 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; @@ -320,6 +321,7 @@ impl wit::core::Guest for Lib { 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| { diff --git a/typegraph/core/src/params/apply.rs b/typegraph/core/src/params/apply.rs new file mode 100644 index 000000000..974f9dcdd --- /dev/null +++ b/typegraph/core/src/params/apply.rs @@ -0,0 +1,465 @@ +// 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 serde::Deserialize; +use std::collections::HashMap; + +#[derive(Debug, Clone, Deserialize)] +pub struct ApplyFromArg { + name: Option, +} + +#[allow(dead_code)] +#[derive(Debug, Clone, Deserialize)] +pub struct ApplyFromStatic { + value: String, +} + +// TODO add to secret list?? +#[allow(dead_code)] +#[derive(Debug, Clone, Deserialize)] +pub struct ApplyFromSecret { + key: String, +} + +#[allow(dead_code)] +#[derive(Debug, Clone, Deserialize)] +pub struct ApplyFromContext { + key: String, +} + +#[allow(dead_code)] +#[derive(Debug, Clone, Deserialize)] +pub struct ApplyFromParent { + name: String, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(tag = "source")] +pub enum ParameterTransformLeafNode { + Arg(ApplyFromArg), + Static(ApplyFromStatic), + Secret(ApplyFromSecret), + Context(ApplyFromContext), + Parent(ApplyFromParent), +} + +#[derive(Debug, Clone, Deserialize)] +pub struct ParameterTransformObjectNode { + fields: HashMap, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct ParameterTransformArrayNode { + items: Vec, +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(tag = "type")] +pub enum ParameterTransformParentNode { + Object(ParameterTransformObjectNode), + Array(ParameterTransformArrayNode), +} + +#[derive(Debug, Clone, Deserialize)] +pub enum ParameterTransformNode { + Leaf(ParameterTransformLeafNode), + Parent(ParameterTransformParentNode), +} + +struct QueryParam { + path: Vec, + type_id: TypeId, +} + +pub struct ParameterTransformValidator { + query_params: HashMap, +} + +enum PathSeg { + Field(String), + Index(usize), +} + +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)) + } + } +} + +impl ParameterTransformValidator { + pub fn new() -> Self { + Self { + query_params: HashMap::new(), + } + } + + fn get_param_name(provided: Option<&str>, path: &[String]) -> Result { + if let Some(provided) = provided { + Ok(provided.to_string()) + } else { + let name = path + .last() + .ok_or_else(|| TgError::from("Cannot get param name from empty path"))?; + let seg = PathSeg::try_from(name.clone()).with_context(|| { + format!( + "Could not get path segment from {name:?} at {}", + path.join(".") + ) + })?; + match seg { + PathSeg::Field(name) => Ok(name), + PathSeg::Index(_) => Err(format!( + "Cannot get param name from array item at {}. Please provide an explicit name", + path.join(".") + ) + .into()), + } + } + } + + // get query input type + pub fn query_input( + mut self, + resolver_input: TypeId, + root: ParameterTransformObjectNode, + ) -> Result { + self.check_object_node(resolver_input, &root, vec![])?; + + let mut query_input_type = t::struct_(); + for (name, param) in self.query_params.into_iter() { + query_input_type.prop(name, param.type_id); + } + + query_input_type.build() + } + + fn check_leaf_node( + &mut self, + type_id: TypeId, + leaf: &ParameterTransformLeafNode, + path: Vec, + ) -> Result<()> { + match leaf { + ParameterTransformLeafNode::Arg(arg) => { + let param_name = Self::get_param_name(arg.name.as_deref(), &path)?; + let old_param = self.query_params.insert( + param_name.clone(), + QueryParam { + path: path.clone(), + type_id, + }, + ); + if let Some(param) = old_param { + let path1 = path.join("."); + let path2 = param.path.join("."); + Err( + format!("Duplicate parameter {param_name:?} at {path1:?} and {path2:?}") + .into(), + ) + } else { + Ok(()) + } + } + ParameterTransformLeafNode::Static(_) => Ok(()), // TODO validate agains type + ParameterTransformLeafNode::Secret(_) => Ok(()), + ParameterTransformLeafNode::Context(_) => Ok(()), + ParameterTransformLeafNode::Parent(_) => Ok(()), + } + } + + fn check_object_node( + &mut self, + type_id: TypeId, + node: &ParameterTransformObjectNode, + path: Vec, + ) -> Result<()> { + 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 = path.join(".") + ) + })?; + let mut available_fields = ty + .data + .props + .iter() + .map(|(k, v)| (k.as_str(), *v)) + .collect::>(); + for (field, node) in &node.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 = path.join("."), + ) + })?; + + let mut path = path.clone(); + path.push(field.clone()); + self.check_node(prop_type_id.into(), node, path)?; + } + + 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 = path.join(".") + ) + }) + .transpose() + }) + .collect::>>()?; + + if !non_optional_fields.is_empty() { + Err(format!( + "Missing non-optional fields {non_optional_fields:?} at {path:?}", + path = path.join(".") + ) + .into()) + } else { + Ok(()) + } + } + + fn check_array_node( + &mut self, + type_id: TypeId, + node: &ParameterTransformArrayNode, + path: Vec, + ) -> Result<()> { + 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 = path.join(".") + ) + })?; + + let item_type_id = TypeId(ty.data.of); + + for (index, node) in node.items.iter().enumerate() { + let mut path = path.clone(); + path.push(format!("[{index}]")); + self.check_node(item_type_id, node, path)?; + } + Ok(()) + } + + fn check_node( + &mut self, + type_id: TypeId, + node: &ParameterTransformNode, + path: Vec, + ) -> Result<()> { + match node { + ParameterTransformNode::Leaf(leaf) => self.check_leaf_node(type_id, leaf, path), + ParameterTransformNode::Parent(parent) => match parent { + ParameterTransformParentNode::Object(obj) => { + self.check_object_node(type_id, obj, path) + } + ParameterTransformParentNode::Array(arr) => { + self.check_array_node(type_id, arr, path) + } + }, + } + } +} + +#[cfg(test)] +mod test { + use super::*; + use crate::test_utils::tree; + + #[test] + fn identity() -> Result<()> { + let validator = ParameterTransformValidator::new(); + let input = t::struct_() + .propx("a", t::string())? + .propx("b", t::string())? + .build()?; + let root = ParameterTransformObjectNode { + fields: vec![ + ( + "a".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { + name: None, + })), + ), + ( + "b".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { + name: None, + })), + ), + ] + .into_iter() + .collect(), + }; + let query_input = validator.query_input(input, root)?; + + let print_options = tree::PrintOptions::new().no_indent_lines(); + assert_eq!( + print_options.print(query_input), + indoc::indoc! {" + root: struct #3 + [a]: string #0 + [b]: string #1 + "} + ); + Ok(()) + } + + #[test] + fn identity_named() -> Result<()> { + let validator = ParameterTransformValidator::new(); + let input = t::struct_() + .propx("a", t::string())? + .propx("b", t::string())? + .build()?; + let root = ParameterTransformObjectNode { + fields: vec![ + ( + "a".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { + name: Some("first".to_string()), + })), + ), + ( + "b".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { + name: Some("second".to_string()), + })), + ), + ] + .into_iter() + .collect(), + }; + + let query_input = validator.query_input(input, root)?; + + let print_options = tree::PrintOptions::new().no_indent_lines(); + assert_eq!( + print_options.print(query_input), + indoc::indoc! {" + root: struct #3 + [first]: string #0 + [second]: string #1 + "} + ); + Ok(()) + } + + #[test] + fn array_items() -> Result<()> { + let validator = ParameterTransformValidator::new(); + let input = t::struct_() + .propx("a", t::string())? + .propx("b", t::listx(t::string())?)? + .build()?; + let root = ParameterTransformObjectNode { + fields: vec![ + ( + "a".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { + name: None, + })), + ), + ( + "b".to_string(), + ParameterTransformNode::Parent(ParameterTransformParentNode::Array( + ParameterTransformArrayNode { + items: vec![ + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg( + ApplyFromArg { name: None }, + )), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg( + ApplyFromArg { name: None }, + )), + ], + }, + )), + ), + ] + .into_iter() + .collect(), + }; + + let query_input = validator.query_input(input, root); + assert!(query_input.is_err()); + let err = query_input.unwrap_err().to_string(); + // eprintln!("{}", err); + assert!(err.contains("Cannot get param name from array item at b.[0]")); + + let root = ParameterTransformObjectNode { + fields: vec![ + ( + "a".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { + name: None, + })), + ), + ( + "b".to_string(), + ParameterTransformNode::Parent(ParameterTransformParentNode::Array( + ParameterTransformArrayNode { + items: vec![ + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg( + ApplyFromArg { + name: Some("first".to_string()), + }, + )), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg( + ApplyFromArg { + name: Some("second".to_string()), + }, + )), + ], + }, + )), + ), + ] + .into_iter() + .collect(), + }; + let query_input = ParameterTransformValidator::new().query_input(input, root)?; + + let print_options = tree::PrintOptions::new().no_indent_lines(); + assert_eq!( + print_options.print(query_input), + 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/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/utils/mod.rs b/typegraph/core/src/utils/mod.rs index 4e9861329..db5c2a6b5 100644 --- a/typegraph/core/src/utils/mod.rs +++ b/typegraph/core/src/utils/mod.rs @@ -9,6 +9,7 @@ use serde_json::json; use crate::errors::Result; use crate::global_store::Store; +use crate::params::apply::ParameterTransformValidator; use crate::types::TypeId; use crate::wit::core::{Guest, TypeBase, TypeId as CoreTypeId, TypeStruct}; use crate::wit::utils::{Auth as WitAuth, QueryBodyParams}; @@ -162,6 +163,14 @@ impl crate::wit::utils::Guest for crate::Lib { Ok(*root_id) } + fn check_parameter_transform(resolver_input: CoreTypeId, tree: String) -> Result { + let tree = serde_json::from_str(&tree) + .map_err(|e| format!("Error while parsing parameter transform tree: {e:?}"))?; + ParameterTransformValidator::new() + .query_input(resolver_input.into(), tree) + .map(Into::into) + } + fn add_graphql_endpoint(graphql: String) -> Result { Store::add_graphql_endpoint(graphql) } diff --git a/typegraph/core/wit/typegraph.wit b/typegraph/core/wit/typegraph.wit index 397ec7085..40103af9a 100644 --- a/typegraph/core/wit/typegraph.wit +++ b/typegraph/core/wit/typegraph.wit @@ -139,21 +139,9 @@ interface core { param(string), // name } - record parameter-transform-leaf { - path: list, - source: value-source, - } - - type parameter-transform-tree = list - record parameter-transform { resolver-input: type-id, - tree: parameter-transform-tree, - } - - record query-parameter { - path: list, - type-id: type-id, + transform-tree: string, } record type-func { @@ -501,6 +489,8 @@ interface utils { gen-reduceb: func(supertype-id: type-id, data: reduce) -> result + check-parameter-transform: func(resolver-inp: type-id, transform: string) -> result + add-graphql-endpoint: func(graphql: string) -> result variant auth-protocol { diff --git a/typegraph/python/typegraph/graph/typegraph.py b/typegraph/python/typegraph/graph/typegraph.py index 2b0634037..e8e82283f 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 ( Rate, @@ -84,6 +84,31 @@ def expose( ) +@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 @@ -119,6 +144,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/t.py b/typegraph/python/typegraph/t.py index 96bd4bfd0..668b8379b 100644 --- a/typegraph/python/typegraph/t.py +++ b/typegraph/python/typegraph/t.py @@ -26,7 +26,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 +607,62 @@ 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, list): + return {"type": "array", "items": [serialize_apply_param_node(v) for v in node]} + raise Exception(f"unexpected node type: {node}") + + class func(typedef): inp: struct out: typedef mat: Materializer rate_calls: bool rate_weight: Optional[int] + parameter_transform: Optional[ApplyParamObjectNode] def __init__( self, inp: struct, out: typedef, mat: Materializer, + /, rate_calls: bool = False, rate_weight: Optional[int] = None, + parameter_transform: Optional[ApplyParamObjectNode] = None, ): data = TypeFunc( inp=inp.id, out=out.id, + parameter_transform=JsonLib.dumps( + serialize_apply_param_node(parameter_transform) + ) + if parameter_transform + else None, mat=mat.id, rate_calls=rate_calls, rate_weight=rate_weight, @@ -631,26 +677,60 @@ 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") out = self.out.extend(props) - return func(self.inp, out, self.mat) + 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": + 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": + return func( + self.inp, + self.out, + self.mat, + parameter_transform=value, + 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 +743,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 123201235..f29db6969 100644 --- a/typegraph/python/typegraph/utils.py +++ b/typegraph/python/typegraph/utils.py @@ -32,7 +32,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)},") From 494be636e9f4db84be5b5d0d36a881d972365bbb Mon Sep 17 00:00:00 2001 From: Natoandro Date: Fri, 9 Feb 2024 10:36:28 +0300 Subject: [PATCH 03/32] feat: conversion --- libs/common/src/typegraph/mod.rs | 1 + .../src/typegraph/parameter_transform.rs | 85 ++++++++ libs/common/src/typegraph/types.rs | 4 +- typegate/src/typegraph/types.ts | 38 ++++ typegate/tests/params/apply_test.ts | 2 + typegraph/core/src/conversion/mod.rs | 1 + .../src/conversion/parameter_transform.rs | 98 +++++++++ typegraph/core/src/lib.rs | 25 ++- typegraph/core/src/params/apply.rs | 14 +- typegraph/core/src/typedef/func.rs | 26 ++- typegraph/core/wit/typegraph.wit | 7 + website/static/specs/0.0.3.json | 191 ++++++++++++++++++ 12 files changed, 479 insertions(+), 13 deletions(-) create mode 100644 libs/common/src/typegraph/parameter_transform.rs create mode 100644 typegate/tests/params/apply_test.ts create mode 100644 typegraph/core/src/conversion/parameter_transform.rs 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..06a9ee2f4 --- /dev/null +++ b/libs/common/src/typegraph/parameter_transform.rs @@ -0,0 +1,85 @@ +// 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)] +pub struct ApplyFromArg { + pub name: String, +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct ApplyFromStatic { + #[serde(rename = "valueJson")] + pub value_json: String, +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct ApplyFromSecret { + pub key: String, +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct ApplyFromContext { + pub key: String, +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct ApplyFromParent { + pub name: String, +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +#[serde(tag = "source")] +pub enum ParameterTransformLeafNode { + Arg(ApplyFromArg), + Static(ApplyFromStatic), + Secret(ApplyFromSecret), + Context(ApplyFromContext), + Parent(ApplyFromParent), +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct ParameterTransformObjectNode { + pub fields: HashMap, +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct ParameterTransformArrayNode { + pub items: Vec, +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +#[serde(tag = "type")] +pub enum ParameterTransformParentNode { + Object(ParameterTransformObjectNode), + Array(ParameterTransformArrayNode), +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +#[serde(untagged)] +pub enum ParameterTransformNode { + Leaf(ParameterTransformLeafNode), + Parent(ParameterTransformParentNode), +} + +#[cfg_attr(feature = "codegen", derive(JsonSchema))] +#[derive(Serialize, Deserialize, Clone, Debug)] +pub struct FunctionParameterTransform { + pub resolver_input: u32, + pub transform_root: ParameterTransformObjectNode, +} diff --git a/libs/common/src/typegraph/types.rs b/libs/common/src/typegraph/types.rs index 7965df4a1..5adafe315 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)] @@ -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/typegate/src/typegraph/types.ts b/typegate/src/typegraph/types.ts index 04ae4732c..57df3887c 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 ParameterTransformNode = + | ParameterTransformLeafNode + | ParameterTransformParentNode; +export type ParameterTransformLeafNode = { + source: "Arg"; + name: string; +} | { + source: "Static"; + valueJson: string; +} | { + source: "Secret"; + key: string; +} | { + source: "Context"; + key: string; +} | { + source: "Parent"; + name: string; +}; +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,15 @@ export interface SingleValueFor_String { export interface SingleValueForUint32 { value: number; } +export interface FunctionParameterTransform { + resolver_input: number; + transform_root: ParameterTransformObjectNode; +} +export interface ParameterTransformObjectNode { + fields: { + [k: string]: ParameterTransformNode; + }; +} export interface Materializer { name: string; runtime: number; diff --git a/typegate/tests/params/apply_test.ts b/typegate/tests/params/apply_test.ts new file mode 100644 index 000000000..1ceedcfaf --- /dev/null +++ b/typegate/tests/params/apply_test.ts @@ -0,0 +1,2 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 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..544fa365f --- /dev/null +++ b/typegraph/core/src/conversion/parameter_transform.rs @@ -0,0 +1,98 @@ +// Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. +// SPDX-License-Identifier: MPL-2.0 + +use common::typegraph::parameter_transform as cm; + +use crate::params::apply::*; + +impl From for cm::ApplyFromArg { + fn from(a: ApplyFromArg) -> Self { + cm::ApplyFromArg { + name: a.name.unwrap(), + } + } +} + +impl From for cm::ApplyFromStatic { + fn from(a: ApplyFromStatic) -> Self { + cm::ApplyFromStatic { + value_json: a.value_json, + } + } +} + +impl From for cm::ApplyFromSecret { + fn from(a: ApplyFromSecret) -> Self { + cm::ApplyFromSecret { key: a.key } + } +} + +impl From for cm::ApplyFromContext { + fn from(a: ApplyFromContext) -> Self { + cm::ApplyFromContext { key: a.key } + } +} + +impl From for cm::ApplyFromParent { + fn from(a: ApplyFromParent) -> Self { + cm::ApplyFromParent { name: a.name } + } +} + +impl From for cm::ParameterTransformLeafNode { + fn from(a: ParameterTransformLeafNode) -> Self { + match a { + ParameterTransformLeafNode::Arg(a) => cm::ParameterTransformLeafNode::Arg(a.into()), + ParameterTransformLeafNode::Static(a) => { + cm::ParameterTransformLeafNode::Static(a.into()) + } + ParameterTransformLeafNode::Secret(a) => { + cm::ParameterTransformLeafNode::Secret(a.into()) + } + ParameterTransformLeafNode::Context(a) => { + cm::ParameterTransformLeafNode::Context(a.into()) + } + ParameterTransformLeafNode::Parent(a) => { + cm::ParameterTransformLeafNode::Parent(a.into()) + } + } + } +} + +impl From for cm::ParameterTransformObjectNode { + fn from(a: ParameterTransformObjectNode) -> Self { + cm::ParameterTransformObjectNode { + fields: a.fields.into_iter().map(|(k, v)| (k, v.into())).collect(), + } + } +} + +impl From for cm::ParameterTransformArrayNode { + fn from(a: ParameterTransformArrayNode) -> Self { + cm::ParameterTransformArrayNode { + items: a.items.into_iter().map(|v| v.into()).collect(), + } + } +} + +impl From for cm::ParameterTransformParentNode { + fn from(a: ParameterTransformParentNode) -> Self { + match a { + ParameterTransformParentNode::Object(a) => { + cm::ParameterTransformParentNode::Object(a.into()) + } + ParameterTransformParentNode::Array(a) => { + cm::ParameterTransformParentNode::Array(a.into()) + } + } + } +} + +impl From for cm::ParameterTransformNode { + fn from(a: ParameterTransformNode) -> Self { + match a { + ParameterTransformNode::Leaf(a) => cm::ParameterTransformNode::Leaf(a.into()), + ParameterTransformNode::Parent(a) => cm::ParameterTransformNode::Parent(a.into()), + } + } +} diff --git a/typegraph/core/src/lib.rs b/typegraph/core/src/lib.rs index 9dd290ef8..920e880ee 100644 --- a/typegraph/core/src/lib.rs +++ b/typegraph/core/src/lib.rs @@ -18,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::{ @@ -29,9 +30,9 @@ use types::{ }; use wit::core::{ - ContextCheck, Policy, PolicyId, PolicySpec, TypeBase, TypeEither, TypeFile, TypeFloat, - TypeFunc, TypeId as CoreTypeId, TypeInteger, TypeList, TypeOptional, TypeString, TypeStruct, - TypeUnion, TypegraphFinalizeMode, TypegraphInitParams, + ApplyParams, ContextCheck, ParameterTransform, Policy, PolicyId, PolicySpec, TypeBase, + TypeEither, TypeFile, TypeFloat, TypeFunc, TypeId as CoreTypeId, TypeInteger, TypeList, + TypeOptional, TypeString, TypeStruct, TypeUnion, TypegraphFinalizeMode, TypegraphInitParams, }; use wit::runtimes::{Guest, MaterializerDenoFunc}; @@ -340,6 +341,22 @@ impl wit::core::Guest for Lib { .into()) } + fn gen_apply(resolver_input: CoreTypeId, transform_tree: String) -> Result { + let query_input = apply::ParameterTransformValidator::new().query_input( + resolver_input.into(), + serde_json::from_str(&transform_tree).map_err(|e| -> TgError { + format!("Error while parsing transform tree: {e:?}").into() + })?, + )?; + Ok(ApplyParams { + query_input: resolver_input, + parameter_transform: ParameterTransform { + resolver_input: query_input.0, + transform_tree, + }, + }) + } + 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 index 974f9dcdd..d0f17af93 100644 --- a/typegraph/core/src/params/apply.rs +++ b/typegraph/core/src/params/apply.rs @@ -9,32 +9,32 @@ use std::collections::HashMap; #[derive(Debug, Clone, Deserialize)] pub struct ApplyFromArg { - name: Option, + pub name: Option, } #[allow(dead_code)] #[derive(Debug, Clone, Deserialize)] pub struct ApplyFromStatic { - value: String, + pub value_json: String, } // TODO add to secret list?? #[allow(dead_code)] #[derive(Debug, Clone, Deserialize)] pub struct ApplyFromSecret { - key: String, + pub key: String, } #[allow(dead_code)] #[derive(Debug, Clone, Deserialize)] pub struct ApplyFromContext { - key: String, + pub key: String, } #[allow(dead_code)] #[derive(Debug, Clone, Deserialize)] pub struct ApplyFromParent { - name: String, + pub name: String, } #[derive(Debug, Clone, Deserialize)] @@ -49,12 +49,12 @@ pub enum ParameterTransformLeafNode { #[derive(Debug, Clone, Deserialize)] pub struct ParameterTransformObjectNode { - fields: HashMap, + pub fields: HashMap, } #[derive(Debug, Clone, Deserialize)] pub struct ParameterTransformArrayNode { - items: Vec, + pub items: Vec, } #[derive(Debug, Clone, Deserialize)] diff --git a/typegraph/core/src/typedef/func.rs b/typegraph/core/src/typedef/func.rs index b18fbeabf..4c2497cae 100644 --- a/typegraph/core/src/typedef/func.rs +++ b/typegraph/core/src/typedef/func.rs @@ -6,7 +6,7 @@ use errors::Result; use crate::{ conversion::types::{BaseBuilderInit, TypeConversion}, - errors, + errors::{self, TgError}, typegraph::TypegraphContext, types::{Func, TypeDef, TypeDefData, TypeId}, wit::core::TypeFunc, @@ -28,6 +28,29 @@ 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<_> { + Ok( + common::typegraph::parameter_transform::FunctionParameterTransform { + resolver_input: { + let inp_id = TypeId(transform.resolver_input); + match TypeId(transform.resolver_input).resolve_ref()?.1 { + TypeDef::Struct(_) => ctx + .register_type(inp_id.try_into()?, Some(runtime_id))? + .into(), + _ => return Err(errors::invalid_input_type(&inp_id.repr()?)), + } + }, + transform_root: serde_json::from_str(&transform.transform_tree).map_err( + |e| -> TgError { format!("invalid parameter transform: {e:?}").into() }, + )?, + }, + ) + }) + .transpose()?; Ok(TypeNode::Function { base: BaseBuilderInit { ctx, @@ -42,6 +65,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/wit/typegraph.wit b/typegraph/core/wit/typegraph.wit index 40103af9a..f5a2a65e4 100644 --- a/typegraph/core/wit/typegraph.wit +++ b/typegraph/core/wit/typegraph.wit @@ -152,8 +152,15 @@ interface core { rate-calls: bool, rate-weight: option, } + funcb: func(data: type-func) -> result + record apply-params { + query-input: type-id, + parameter-transform: parameter-transform, + } + gen-apply: func(resolver-input: type-id, transform-tree: string) -> result + type policy-id = u32 record policy { diff --git a/website/static/specs/0.0.3.json b/website/static/specs/0.0.3.json index 6f23e6b01..563377a22 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,187 @@ "phone" ] }, + "FunctionParameterTransform": { + "type": "object", + "required": [ + "resolver_input", + "transform_root" + ], + "properties": { + "resolver_input": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 + }, + "transform_root": { + "$ref": "#/definitions/ParameterTransformObjectNode" + } + } + }, + "ParameterTransformObjectNode": { + "type": "object", + "required": [ + "fields" + ], + "properties": { + "fields": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/ParameterTransformNode" + } + } + } + }, + "ParameterTransformNode": { + "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": [ + "name", + "source" + ], + "properties": { + "source": { + "type": "string", + "enum": [ + "Parent" + ] + }, + "name": { + "type": "string" + } + } + } + ] + }, + "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": [ From 7839418a5c8e45303f99343b3c1676ed0d944a2e Mon Sep 17 00:00:00 2001 From: Natoandro Date: Fri, 9 Feb 2024 22:36:23 +0300 Subject: [PATCH 04/32] update conversion - add failing test --- .../src/typegraph/parameter_transform.rs | 67 ++------ typegate/tests/params/apply.py | 18 ++ typegate/tests/params/apply_test.ts | 20 +++ .../src/conversion/parameter_transform.rs | 160 ++++++++++-------- typegraph/core/src/lib.rs | 2 +- typegraph/core/src/params/apply.rs | 127 +++++--------- typegraph/core/src/typedef/func.rs | 52 +++--- typegraph/core/src/utils/mod.rs | 4 +- typegraph/python/typegraph/t.py | 30 ++-- 9 files changed, 233 insertions(+), 247 deletions(-) create mode 100644 typegate/tests/params/apply.py diff --git a/libs/common/src/typegraph/parameter_transform.rs b/libs/common/src/typegraph/parameter_transform.rs index 06a9ee2f4..9f7598163 100644 --- a/libs/common/src/typegraph/parameter_transform.rs +++ b/libs/common/src/typegraph/parameter_transform.rs @@ -9,64 +9,25 @@ use serde::{Deserialize, Serialize}; #[cfg_attr(feature = "codegen", derive(JsonSchema))] #[derive(Serialize, Deserialize, Clone, Debug)] -pub struct ApplyFromArg { - pub name: String, -} - -#[cfg_attr(feature = "codegen", derive(JsonSchema))] -#[derive(Serialize, Deserialize, Clone, Debug)] -pub struct ApplyFromStatic { - #[serde(rename = "valueJson")] - pub value_json: String, -} - -#[cfg_attr(feature = "codegen", derive(JsonSchema))] -#[derive(Serialize, Deserialize, Clone, Debug)] -pub struct ApplyFromSecret { - pub key: String, -} - -#[cfg_attr(feature = "codegen", derive(JsonSchema))] -#[derive(Serialize, Deserialize, Clone, Debug)] -pub struct ApplyFromContext { - pub key: String, -} - -#[cfg_attr(feature = "codegen", derive(JsonSchema))] -#[derive(Serialize, Deserialize, Clone, Debug)] -pub struct ApplyFromParent { - pub name: String, -} - -#[cfg_attr(feature = "codegen", derive(JsonSchema))] -#[derive(Serialize, Deserialize, Clone, Debug)] -#[serde(tag = "source")] +#[serde(tag = "source", rename_all = "lowercase")] pub enum ParameterTransformLeafNode { - Arg(ApplyFromArg), - Static(ApplyFromStatic), - Secret(ApplyFromSecret), - Context(ApplyFromContext), - Parent(ApplyFromParent), -} - -#[cfg_attr(feature = "codegen", derive(JsonSchema))] -#[derive(Serialize, Deserialize, Clone, Debug)] -pub struct ParameterTransformObjectNode { - pub fields: HashMap, -} - -#[cfg_attr(feature = "codegen", derive(JsonSchema))] -#[derive(Serialize, Deserialize, Clone, Debug)] -pub struct ParameterTransformArrayNode { - pub items: Vec, + Arg { name: String }, + Static { value_json: String }, + Secret { key: String }, + Context { key: String }, + Parent { type_idx: u32 }, } #[cfg_attr(feature = "codegen", derive(JsonSchema))] #[derive(Serialize, Deserialize, Clone, Debug)] -#[serde(tag = "type")] +#[serde(tag = "type", rename_all = "lowercase")] pub enum ParameterTransformParentNode { - Object(ParameterTransformObjectNode), - Array(ParameterTransformArrayNode), + Object { + fields: HashMap, + }, + Array { + items: Vec, + }, } #[cfg_attr(feature = "codegen", derive(JsonSchema))] @@ -81,5 +42,5 @@ pub enum ParameterTransformNode { #[derive(Serialize, Deserialize, Clone, Debug)] pub struct FunctionParameterTransform { pub resolver_input: u32, - pub transform_root: ParameterTransformObjectNode, + pub transform_root: HashMap, } diff --git a/typegate/tests/params/apply.py b/typegate/tests/params/apply.py new file mode 100644 index 000000000..fd1fdf7e1 --- /dev/null +++ b/typegate/tests/params/apply.py @@ -0,0 +1,18 @@ +from typegraph import Graph, Policy, t, typegraph +from typegraph.runtimes.deno import DenoRuntime + + +@typegraph() +def renamed_params(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"), + } + ), + ) diff --git a/typegate/tests/params/apply_test.ts b/typegate/tests/params/apply_test.ts index 1ceedcfaf..34e56f2d8 100644 --- a/typegate/tests/params/apply_test.ts +++ b/typegate/tests/params/apply_test.ts @@ -1,2 +1,22 @@ // 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"); + + 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); + }); +}); diff --git a/typegraph/core/src/conversion/parameter_transform.rs b/typegraph/core/src/conversion/parameter_transform.rs index 544fa365f..a0f604f82 100644 --- a/typegraph/core/src/conversion/parameter_transform.rs +++ b/typegraph/core/src/conversion/parameter_transform.rs @@ -1,98 +1,110 @@ // Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. // SPDX-License-Identifier: MPL-2.0 -use common::typegraph::parameter_transform as cm; +use std::collections::HashMap; -use crate::params::apply::*; +use crate::errors::Result; +use crate::errors::TgError; +use crate::t; +use crate::t::TypeBuilder; +use crate::{params::apply::*, typegraph::TypegraphContext}; +use common::typegraph::parameter_transform as cm; -impl From for cm::ApplyFromArg { - fn from(a: ApplyFromArg) -> Self { - cm::ApplyFromArg { - name: a.name.unwrap(), - } +pub fn convert_tree( + ctx: &mut TypegraphContext, + root_fields: &HashMap, + runtime_id: u32, +) -> Result> { + let object_node = convert_object_node(ctx, root_fields, runtime_id)?; + match object_node { + cm::ParameterTransformParentNode::Object { fields } => Ok(fields), + _ => unreachable!(), } } -impl From for cm::ApplyFromStatic { - fn from(a: ApplyFromStatic) -> Self { - cm::ApplyFromStatic { - value_json: a.value_json, +fn convert_node( + ctx: &mut TypegraphContext, + node: &ParameterTransformNode, + runtime_id: u32, +) -> Result { + match node { + ParameterTransformNode::Leaf(leaf_node) => { + convert_leaf_node(ctx, leaf_node, runtime_id).map(cm::ParameterTransformNode::Leaf) } - } -} - -impl From for cm::ApplyFromSecret { - fn from(a: ApplyFromSecret) -> Self { - cm::ApplyFromSecret { key: a.key } - } -} - -impl From for cm::ApplyFromContext { - fn from(a: ApplyFromContext) -> Self { - cm::ApplyFromContext { key: a.key } - } -} - -impl From for cm::ApplyFromParent { - fn from(a: ApplyFromParent) -> Self { - cm::ApplyFromParent { name: a.name } - } -} - -impl From for cm::ParameterTransformLeafNode { - fn from(a: ParameterTransformLeafNode) -> Self { - match a { - ParameterTransformLeafNode::Arg(a) => cm::ParameterTransformLeafNode::Arg(a.into()), - ParameterTransformLeafNode::Static(a) => { - cm::ParameterTransformLeafNode::Static(a.into()) - } - ParameterTransformLeafNode::Secret(a) => { - cm::ParameterTransformLeafNode::Secret(a.into()) - } - ParameterTransformLeafNode::Context(a) => { - cm::ParameterTransformLeafNode::Context(a.into()) - } - ParameterTransformLeafNode::Parent(a) => { - cm::ParameterTransformLeafNode::Parent(a.into()) - } + ParameterTransformNode::Parent(a) => { + convert_parent_node(ctx, a, runtime_id).map(cm::ParameterTransformNode::Parent) } } } -impl From for cm::ParameterTransformObjectNode { - fn from(a: ParameterTransformObjectNode) -> Self { - cm::ParameterTransformObjectNode { - fields: a.fields.into_iter().map(|(k, v)| (k, v.into())).collect(), +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().ok_or_else(|| { + Into::::into("argument must have a know name".to_string()) + })?, + }), + 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 { name } => { + let type_ref = t::ref_(name).build()?; + let (_, type_def) = type_ref.resolve_ref()?; + let type_idx = ctx.register_type(type_def, Some(runtime_id))?.0; + Ok(cm::ParameterTransformLeafNode::Parent { type_idx }) } } } -impl From for cm::ParameterTransformArrayNode { - fn from(a: ParameterTransformArrayNode) -> Self { - cm::ParameterTransformArrayNode { - items: a.items.into_iter().map(|v| v.into()).collect(), +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), } } -impl From for cm::ParameterTransformParentNode { - fn from(a: ParameterTransformParentNode) -> Self { - match a { - ParameterTransformParentNode::Object(a) => { - cm::ParameterTransformParentNode::Object(a.into()) - } - ParameterTransformParentNode::Array(a) => { - cm::ParameterTransformParentNode::Array(a.into()) - } - } - } +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) + })?, + }) } -impl From for cm::ParameterTransformNode { - fn from(a: ParameterTransformNode) -> Self { - match a { - ParameterTransformNode::Leaf(a) => cm::ParameterTransformNode::Leaf(a.into()), - ParameterTransformNode::Parent(a) => cm::ParameterTransformNode::Parent(a.into()), - } - } +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/lib.rs b/typegraph/core/src/lib.rs index 920e880ee..f3737d9b4 100644 --- a/typegraph/core/src/lib.rs +++ b/typegraph/core/src/lib.rs @@ -344,7 +344,7 @@ impl wit::core::Guest for Lib { fn gen_apply(resolver_input: CoreTypeId, transform_tree: String) -> Result { let query_input = apply::ParameterTransformValidator::new().query_input( resolver_input.into(), - serde_json::from_str(&transform_tree).map_err(|e| -> TgError { + &serde_json::from_str(&transform_tree).map_err(|e| -> TgError { format!("Error while parsing transform tree: {e:?}").into() })?, )?; diff --git a/typegraph/core/src/params/apply.rs b/typegraph/core/src/params/apply.rs index d0f17af93..7790b0030 100644 --- a/typegraph/core/src/params/apply.rs +++ b/typegraph/core/src/params/apply.rs @@ -8,63 +8,28 @@ use serde::Deserialize; use std::collections::HashMap; #[derive(Debug, Clone, Deserialize)] -pub struct ApplyFromArg { - pub name: Option, -} - -#[allow(dead_code)] -#[derive(Debug, Clone, Deserialize)] -pub struct ApplyFromStatic { - pub value_json: String, -} - -// TODO add to secret list?? -#[allow(dead_code)] -#[derive(Debug, Clone, Deserialize)] -pub struct ApplyFromSecret { - pub key: String, -} - -#[allow(dead_code)] -#[derive(Debug, Clone, Deserialize)] -pub struct ApplyFromContext { - pub key: String, -} - -#[allow(dead_code)] -#[derive(Debug, Clone, Deserialize)] -pub struct ApplyFromParent { - pub name: String, -} - -#[derive(Debug, Clone, Deserialize)] -#[serde(tag = "source")] +#[serde(tag = "source", rename_all = "lowercase")] pub enum ParameterTransformLeafNode { - Arg(ApplyFromArg), - Static(ApplyFromStatic), - Secret(ApplyFromSecret), - Context(ApplyFromContext), - Parent(ApplyFromParent), -} - -#[derive(Debug, Clone, Deserialize)] -pub struct ParameterTransformObjectNode { - pub fields: HashMap, -} - -#[derive(Debug, Clone, Deserialize)] -pub struct ParameterTransformArrayNode { - pub items: Vec, + Arg { name: Option }, + Static { value_json: String }, + Secret { key: String }, + Context { key: String }, + Parent { name: String }, } #[derive(Debug, Clone, Deserialize)] -#[serde(tag = "type")] +#[serde(tag = "type", rename_all = "lowercase")] pub enum ParameterTransformParentNode { - Object(ParameterTransformObjectNode), - Array(ParameterTransformArrayNode), + Object { + fields: HashMap, + }, + Array { + items: Vec, + }, } #[derive(Debug, Clone, Deserialize)] +#[serde(untagged, rename_all = "lowercase")] pub enum ParameterTransformNode { Leaf(ParameterTransformLeafNode), Parent(ParameterTransformParentNode), @@ -135,9 +100,9 @@ impl ParameterTransformValidator { pub fn query_input( mut self, resolver_input: TypeId, - root: ParameterTransformObjectNode, + root_fields: &HashMap, ) -> Result { - self.check_object_node(resolver_input, &root, vec![])?; + self.check_object_node(resolver_input, root_fields, vec![])?; let mut query_input_type = t::struct_(); for (name, param) in self.query_params.into_iter() { @@ -154,8 +119,8 @@ impl ParameterTransformValidator { path: Vec, ) -> Result<()> { match leaf { - ParameterTransformLeafNode::Arg(arg) => { - let param_name = Self::get_param_name(arg.name.as_deref(), &path)?; + ParameterTransformLeafNode::Arg { name } => { + let param_name = Self::get_param_name(name.as_deref(), &path)?; let old_param = self.query_params.insert( param_name.clone(), QueryParam { @@ -174,17 +139,17 @@ impl ParameterTransformValidator { Ok(()) } } - ParameterTransformLeafNode::Static(_) => Ok(()), // TODO validate agains type - ParameterTransformLeafNode::Secret(_) => Ok(()), - ParameterTransformLeafNode::Context(_) => Ok(()), - ParameterTransformLeafNode::Parent(_) => Ok(()), + ParameterTransformLeafNode::Static { .. } => Ok(()), // TODO validate agains type + ParameterTransformLeafNode::Secret { .. } => Ok(()), + ParameterTransformLeafNode::Context { .. } => Ok(()), + ParameterTransformLeafNode::Parent { .. } => Ok(()), } } fn check_object_node( &mut self, type_id: TypeId, - node: &ParameterTransformObjectNode, + fields: &HashMap, path: Vec, ) -> Result<()> { let type_id = type_id.resolve_optional()?; @@ -200,7 +165,7 @@ impl ParameterTransformValidator { .iter() .map(|(k, v)| (k.as_str(), *v)) .collect::>(); - for (field, node) in &node.fields { + 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:?}", @@ -251,7 +216,7 @@ impl ParameterTransformValidator { fn check_array_node( &mut self, type_id: TypeId, - node: &ParameterTransformArrayNode, + items: &[ParameterTransformNode], path: Vec, ) -> Result<()> { let type_id = type_id.resolve_optional()?; @@ -264,7 +229,7 @@ impl ParameterTransformValidator { let item_type_id = TypeId(ty.data.of); - for (index, node) in node.items.iter().enumerate() { + for (index, node) in items.iter().enumerate() { let mut path = path.clone(); path.push(format!("[{index}]")); self.check_node(item_type_id, node, path)?; @@ -281,11 +246,11 @@ impl ParameterTransformValidator { match node { ParameterTransformNode::Leaf(leaf) => self.check_leaf_node(type_id, leaf, path), ParameterTransformNode::Parent(parent) => match parent { - ParameterTransformParentNode::Object(obj) => { - self.check_object_node(type_id, obj, path) + ParameterTransformParentNode::Object { fields } => { + self.check_object_node(type_id, fields, path) } - ParameterTransformParentNode::Array(arr) => { - self.check_array_node(type_id, arr, path) + ParameterTransformParentNode::Array { items } => { + self.check_array_node(type_id, items, path) } }, } @@ -304,23 +269,21 @@ mod test { .propx("a", t::string())? .propx("b", t::string())? .build()?; - let root = ParameterTransformObjectNode { - fields: vec![ - ( - "a".to_string(), - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { - name: None, - })), - ), - ( - "b".to_string(), - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { - name: None, - })), - ), - ] - .into_iter() - .collect(), + let root_fields = { + let mut map = HashMap::new(); + map.insert( + "a".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { + name: None, + })), + ); + map.insert( + "b".to_string(), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { + name: None, + })), + ); + map }; let query_input = validator.query_input(input, root)?; diff --git a/typegraph/core/src/typedef/func.rs b/typegraph/core/src/typedef/func.rs index 4c2497cae..7f5f7e655 100644 --- a/typegraph/core/src/typedef/func.rs +++ b/typegraph/core/src/typedef/func.rs @@ -1,17 +1,20 @@ // 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 std::collections::HashMap; -use crate::{ - conversion::types::{BaseBuilderInit, TypeConversion}, - errors::{self, TgError}, - 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)?; @@ -33,22 +36,23 @@ impl TypeConversion for Func { .parameter_transform .as_ref() .map(|transform| -> Result<_> { - Ok( - common::typegraph::parameter_transform::FunctionParameterTransform { - resolver_input: { - let inp_id = TypeId(transform.resolver_input); - match TypeId(transform.resolver_input).resolve_ref()?.1 { - TypeDef::Struct(_) => ctx - .register_type(inp_id.try_into()?, Some(runtime_id))? - .into(), - _ => return Err(errors::invalid_input_type(&inp_id.repr()?)), - } - }, - transform_root: serde_json::from_str(&transform.transform_tree).map_err( - |e| -> TgError { format!("invalid parameter transform: {e:?}").into() }, - )?, - }, - ) + let resolver_input = TypeId(transform.resolver_input); + let transform_root: HashMap = + 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 { diff --git a/typegraph/core/src/utils/mod.rs b/typegraph/core/src/utils/mod.rs index db5c2a6b5..c822b6356 100644 --- a/typegraph/core/src/utils/mod.rs +++ b/typegraph/core/src/utils/mod.rs @@ -164,10 +164,10 @@ impl crate::wit::utils::Guest for crate::Lib { } fn check_parameter_transform(resolver_input: CoreTypeId, tree: String) -> Result { - let tree = serde_json::from_str(&tree) + let root_fields = serde_json::from_str(&tree) .map_err(|e| format!("Error while parsing parameter transform tree: {e:?}"))?; ParameterTransformValidator::new() - .query_input(resolver_input.into(), tree) + .query_input(resolver_input.into(), &root_fields) .map(Into::into) } diff --git a/typegraph/python/typegraph/t.py b/typegraph/python/typegraph/t.py index 668b8379b..ba03eab99 100644 --- a/typegraph/python/typegraph/t.py +++ b/typegraph/python/typegraph/t.py @@ -4,12 +4,14 @@ import json as JsonLib from typing import Any, Dict, List, Optional, Tuple, Union import copy +import sys from typing_extensions import Self from typegraph.effects import EffectType from typegraph.gen.exports.core import ( FuncParams, + ParameterTransform, TypeList, TypeBase, TypeEither, @@ -638,31 +640,27 @@ def serialize_apply_param_node(node: ApplyParamNode) -> Any: class func(typedef): - inp: struct + inp: Union[struct, typedef] out: typedef mat: Materializer rate_calls: bool rate_weight: Optional[int] - parameter_transform: Optional[ApplyParamObjectNode] + 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[ApplyParamObjectNode] = None, + parameter_transform: Optional[ParameterTransform] = None, ): data = TypeFunc( inp=inp.id, out=out.id, - parameter_transform=JsonLib.dumps( - serialize_apply_param_node(parameter_transform) - ) - if parameter_transform - else None, + parameter_transform=parameter_transform, mat=mat.id, rate_calls=rate_calls, rate_weight=rate_weight, @@ -721,11 +719,21 @@ def reduce(self, value: Dict[str, Any]) -> "func": ) 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"]) + print(transform_tree, file=sys.stderr) + + apply_params = core.gen_apply(store, self.inp.id, transform_tree) + if isinstance(apply_params, Err): + raise Exception(apply_params.value) + return func( - self.inp, + typedef(apply_params.value.query_input), self.out, self.mat, - parameter_transform=value, + parameter_transform=apply_params.value.parameter_transform, rate_calls=self.rate_calls, rate_weight=self.rate_weight, ) From 235f2f386745246af29ddc371424cb4ca9e513d0 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Sat, 10 Feb 2024 00:07:44 +0300 Subject: [PATCH 05/32] first working test --- typegate/src/engine/planner/args.ts | 25 ++- typegate/src/engine/planner/mod.ts | 10 +- .../engine/planner/parameter_transformer.ts | 154 ++++++++++++++++++ typegate/src/typegraph/types.ts | 23 ++- typegraph/core/src/lib.rs | 4 +- website/static/specs/0.0.3.json | 39 ++--- 6 files changed, 211 insertions(+), 44 deletions(-) create mode 100644 typegate/src/engine/planner/parameter_transformer.ts diff --git a/typegate/src/engine/planner/args.ts b/typegate/src/engine/planner/args.ts index 0e2706f1b..f7eceb4af 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,12 @@ export function collectArgs( } const validate = generateValidator(typegraph, typeIdx); + const parameterTransformer = parameterTransform == null + ? defaultParameterTransformer + : compileParameterTransformer( + parameterTransform.transform_root, + parentProps, + ); const policies = collector.policies; @@ -124,7 +139,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 +154,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..f4942e8f6 --- /dev/null +++ b/typegate/src/engine/planner/parameter_transformer.ts @@ -0,0 +1,154 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +import { + ParameterTransformNode, + ParameterTransformParentNode, +} from "../../typegraph/types.ts"; + +export type TransformParamsInput = { + args: Record; + context: Record; + // secrets: Record; + parent: Record; +}; + +export function defaultParameterTransformer(input: TransformParamsInput) { + return input.args; +} + +export type TransformParams = { + (input: TransformParamsInput): Record; +}; + +export function compileParameterTransformer( + transformerTreeRootFields: Record, + parentProps: Record, +): TransformParams { + const rootNode: ParameterTransformParentNode = { + type: "object", + fields: transformerTreeRootFields, + }; + const ctx = new TransformerCompilationContext(parentProps); + const fnBody = ctx.compile(rootNode); + return new Function("input", fnBody) as TransformParams; +} + +class TransformerCompilationContext { + #parentProps: Record; + #path: string[] = []; + #latestVarIndex = 0; + #collector: string[] = []; + + constructor(parentProps: Record) { + this.#parentProps = parentProps; + } + + #reset() { + this.#collector = [ + // TODO secrets + "const { args, context, parent } = input;\n", + ]; + } + + compile(rootNode: ParameterTransformParentNode) { + this.#reset(); + const varName = this.#compileNode(rootNode); + this.#collector.push(`return ${varName};`); + return this.#collector.join("\n"); + } + + #compileNode(node: ParameterTransformNode) { + if ("type" in node) { + switch (node.type) { + case "object": + return this.#compileObject(node.fields); + case "array": + return this.#compileArray(node.items); + default: + // unreachable + throw new Error( + `Unknown type: ${(node as any).type} at ${this.#path}`, + ); + } + } else { + switch (node.source) { + case "arg": + return this.#compileArgInjection(node.name); + case "context": + return this.#compileContextInjection(node.key); + // case "secret": + // return this.#compileSecretsInjection(node); + case "parent": + return this.#compileParentInjection(node.type_idx); + default: + throw new Error(`Unknown source: ${node.source} at ${this.#path}`); + } + } + } + + #compileObject(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}["${key}"] = ${propVarName};`); + } + + return varName; + } + + #compileArray(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});`); + } + + return varName; + } + + #compileArgInjection(name: string) { + // TODO type validation ? + const varName = this.#createVarName(); + this.#collector.push(`const ${varName} = args["${name}"];`); + return varName; + } + + #compileContextInjection(key: string) { + // TODO type validation ? + const varName = this.#createVarName(); + this.#collector.push(`const ${varName} = context["${key}"];`); + return varName; + } + + // #compileSecretsInjection(key: string) { + // // TODO type validation ? + // const varName = this.#createVarName(); + // this.#collector.push(`const ${varName} = secrets["${key}"];`); + // return varName; + // } + + #compileParentInjection(typeIdx: number) { + // TODO type validation ? + // TODO what if the value is lazy (a function?) + const key = Object.entries(this.#parentProps) + .find(([_key, idx]) => idx === typeIdx)!; + const varName = this.#createVarName(); + this.#collector.push(`const ${varName} = parent["${key}"];`); + return varName; + } + + #createVarName() { + return `var${++this.#latestVarIndex}`; + } +} diff --git a/typegate/src/typegraph/types.ts b/typegate/src/typegraph/types.ts index 57df3887c..1cb8891f1 100644 --- a/typegate/src/typegraph/types.ts +++ b/typegate/src/typegraph/types.ts @@ -244,28 +244,28 @@ export type ParameterTransformNode = | ParameterTransformLeafNode | ParameterTransformParentNode; export type ParameterTransformLeafNode = { - source: "Arg"; + source: "arg"; name: string; } | { - source: "Static"; - valueJson: string; + source: "static"; + value_json: string; } | { - source: "Secret"; + source: "secret"; key: string; } | { - source: "Context"; + source: "context"; key: string; } | { - source: "Parent"; - name: string; + source: "parent"; + type_idx: number; }; export type ParameterTransformParentNode = { - type: "Object"; + type: "object"; fields: { [k: string]: ParameterTransformNode; }; } | { - type: "Array"; + type: "array"; items: ParameterTransformNode[]; }; export type EffectType = "create" | "update" | "delete" | "read"; @@ -393,10 +393,7 @@ export interface SingleValueForUint32 { } export interface FunctionParameterTransform { resolver_input: number; - transform_root: ParameterTransformObjectNode; -} -export interface ParameterTransformObjectNode { - fields: { + transform_root: { [k: string]: ParameterTransformNode; }; } diff --git a/typegraph/core/src/lib.rs b/typegraph/core/src/lib.rs index f3737d9b4..ead91adbd 100644 --- a/typegraph/core/src/lib.rs +++ b/typegraph/core/src/lib.rs @@ -349,9 +349,9 @@ impl wit::core::Guest for Lib { })?, )?; Ok(ApplyParams { - query_input: resolver_input, + query_input: query_input.0, parameter_transform: ParameterTransform { - resolver_input: query_input.0, + resolver_input, transform_tree, }, }) diff --git a/website/static/specs/0.0.3.json b/website/static/specs/0.0.3.json index 563377a22..fc265379a 100644 --- a/website/static/specs/0.0.3.json +++ b/website/static/specs/0.0.3.json @@ -1323,17 +1323,6 @@ "minimum": 0.0 }, "transform_root": { - "$ref": "#/definitions/ParameterTransformObjectNode" - } - } - }, - "ParameterTransformObjectNode": { - "type": "object", - "required": [ - "fields" - ], - "properties": { - "fields": { "type": "object", "additionalProperties": { "$ref": "#/definitions/ParameterTransformNode" @@ -1363,7 +1352,7 @@ "source": { "type": "string", "enum": [ - "Arg" + "arg" ] }, "name": { @@ -1375,16 +1364,16 @@ "type": "object", "required": [ "source", - "valueJson" + "value_json" ], "properties": { "source": { "type": "string", "enum": [ - "Static" + "static" ] }, - "valueJson": { + "value_json": { "type": "string" } } @@ -1399,7 +1388,7 @@ "source": { "type": "string", "enum": [ - "Secret" + "secret" ] }, "key": { @@ -1417,7 +1406,7 @@ "source": { "type": "string", "enum": [ - "Context" + "context" ] }, "key": { @@ -1428,18 +1417,20 @@ { "type": "object", "required": [ - "name", - "source" + "source", + "type_idx" ], "properties": { "source": { "type": "string", "enum": [ - "Parent" + "parent" ] }, - "name": { - "type": "string" + "type_idx": { + "type": "integer", + "format": "uint32", + "minimum": 0.0 } } } @@ -1457,7 +1448,7 @@ "type": { "type": "string", "enum": [ - "Object" + "object" ] }, "fields": { @@ -1478,7 +1469,7 @@ "type": { "type": "string", "enum": [ - "Array" + "array" ] }, "items": { From f2286106ffe50d41b2d1719a503cf86c1956e673 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Sat, 10 Feb 2024 11:38:11 +0300 Subject: [PATCH 06/32] type aware transformer compiler --- .../src/typegraph/parameter_transform.rs | 26 +- typegate/src/engine/planner/args.ts | 3 +- .../engine/planner/parameter_transformer.ts | 61 ++-- typegate/src/typegraph/types.ts | 14 +- .../src/conversion/parameter_transform.rs | 51 ++-- typegraph/core/src/lib.rs | 22 +- typegraph/core/src/params/apply.rs | 280 ++++++++++++------ typegraph/core/src/typedef/func.rs | 4 +- typegraph/core/src/utils/mod.rs | 9 - typegraph/core/wit/typegraph.wit | 7 +- typegraph/python/typegraph/t.py | 12 +- website/static/specs/0.0.3.json | 32 +- 12 files changed, 332 insertions(+), 189 deletions(-) diff --git a/libs/common/src/typegraph/parameter_transform.rs b/libs/common/src/typegraph/parameter_transform.rs index 9f7598163..343f3560c 100644 --- a/libs/common/src/typegraph/parameter_transform.rs +++ b/libs/common/src/typegraph/parameter_transform.rs @@ -11,36 +11,50 @@ use serde::{Deserialize, Serialize}; #[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 }, - Parent { type_idx: u32 }, + #[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, }, - Array { - items: Vec, - }, + #[serde(rename_all = "camelCase")] + Array { items: Vec }, } #[cfg_attr(feature = "codegen", derive(JsonSchema))] #[derive(Serialize, Deserialize, Clone, Debug)] #[serde(untagged)] -pub enum ParameterTransformNode { +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: HashMap, + pub transform_root: ParameterTransformNode, } diff --git a/typegate/src/engine/planner/args.ts b/typegate/src/engine/planner/args.ts index f7eceb4af..860483769 100644 --- a/typegate/src/engine/planner/args.ts +++ b/typegate/src/engine/planner/args.ts @@ -120,8 +120,9 @@ export function collectArgs( const parameterTransformer = parameterTransform == null ? defaultParameterTransformer : compileParameterTransformer( - parameterTransform.transform_root, + typegraph, parentProps, + parameterTransform.transform_root, ); const policies = collector.policies; diff --git a/typegate/src/engine/planner/parameter_transformer.ts b/typegate/src/engine/planner/parameter_transformer.ts index f4942e8f6..911a47778 100644 --- a/typegate/src/engine/planner/parameter_transformer.ts +++ b/typegate/src/engine/planner/parameter_transformer.ts @@ -1,10 +1,8 @@ // Copyright Metatype OÜ, licensed under the Elastic License 2.0. // SPDX-License-Identifier: Elastic-2.0 -import { - ParameterTransformNode, - ParameterTransformParentNode, -} from "../../typegraph/types.ts"; +import { TypeGraph } from "../../typegraph/mod.ts"; +import { ParameterTransformNode } from "../../typegraph/types.ts"; export type TransformParamsInput = { args: Record; @@ -22,25 +20,24 @@ export type TransformParams = { }; export function compileParameterTransformer( - transformerTreeRootFields: Record, + typegraph: TypeGraph, parentProps: Record, + transformerTreeRoot: ParameterTransformNode, ): TransformParams { - const rootNode: ParameterTransformParentNode = { - type: "object", - fields: transformerTreeRootFields, - }; - const ctx = new TransformerCompilationContext(parentProps); - const fnBody = ctx.compile(rootNode); + const ctx = new TransformerCompilationContext(typegraph, parentProps); + const fnBody = ctx.compile(transformerTreeRoot); return new Function("input", fnBody) as TransformParams; } class TransformerCompilationContext { + #tg: TypeGraph; #parentProps: Record; #path: string[] = []; #latestVarIndex = 0; #collector: string[] = []; - constructor(parentProps: Record) { + constructor(typegraph: TypeGraph, parentProps: Record) { + this.#tg = typegraph; this.#parentProps = parentProps; } @@ -51,7 +48,7 @@ class TransformerCompilationContext { ]; } - compile(rootNode: ParameterTransformParentNode) { + compile(rootNode: ParameterTransformNode) { this.#reset(); const varName = this.#compileNode(rootNode); this.#collector.push(`return ${varName};`); @@ -59,35 +56,41 @@ class TransformerCompilationContext { } #compileNode(node: ParameterTransformNode) { - if ("type" in node) { - switch (node.type) { + const { typeIdx, data: nodeData } = node; + if ("type" in nodeData) { + switch (nodeData.type) { case "object": - return this.#compileObject(node.fields); + return this.#compileObject(typeIdx, nodeData.fields); case "array": - return this.#compileArray(node.items); + return this.#compileArray(typeIdx, nodeData.items); default: // unreachable throw new Error( - `Unknown type: ${(node as any).type} at ${this.#path}`, + `Unknown type: ${(nodeData as any).type} at ${this.#path}`, ); } } else { - switch (node.source) { + switch (nodeData.source) { case "arg": - return this.#compileArgInjection(node.name); + return this.#compileArgInjection(typeIdx, nodeData.name); case "context": - return this.#compileContextInjection(node.key); + return this.#compileContextInjection(typeIdx, nodeData.key); // case "secret": // return this.#compileSecretsInjection(node); case "parent": - return this.#compileParentInjection(node.type_idx); + return this.#compileParentInjection(typeIdx, nodeData.parentIdx); default: - throw new Error(`Unknown source: ${node.source} at ${this.#path}`); + throw new Error( + `Unknown source: ${nodeData.source} at ${this.#path}`, + ); } } } - #compileObject(fields: Record): string { + #compileObject( + _typeIdx: number, // TODO validation + fields: Record, + ): string { const varName = this.#createVarName(); this.#collector.push(`const ${varName} = {};`); @@ -102,7 +105,7 @@ class TransformerCompilationContext { return varName; } - #compileArray(items: ParameterTransformNode[]) { + #compileArray(_typeIdx: number, items: ParameterTransformNode[]) { const varName = this.#createVarName(); this.#collector.push(`const ${varName} = [];`); @@ -117,14 +120,14 @@ class TransformerCompilationContext { return varName; } - #compileArgInjection(name: string) { + #compileArgInjection(_typeIdx: number, name: string) { // TODO type validation ? const varName = this.#createVarName(); this.#collector.push(`const ${varName} = args["${name}"];`); return varName; } - #compileContextInjection(key: string) { + #compileContextInjection(_typeIdx: number, key: string) { // TODO type validation ? const varName = this.#createVarName(); this.#collector.push(`const ${varName} = context["${key}"];`); @@ -138,11 +141,11 @@ class TransformerCompilationContext { // return varName; // } - #compileParentInjection(typeIdx: number) { + #compileParentInjection(_typeIdx: number, parentIdx: number) { // TODO type validation ? // TODO what if the value is lazy (a function?) const key = Object.entries(this.#parentProps) - .find(([_key, idx]) => idx === typeIdx)!; + .find(([_key, idx]) => idx === parentIdx)!; const varName = this.#createVarName(); this.#collector.push(`const ${varName} = parent["${key}"];`); return varName; diff --git a/typegate/src/typegraph/types.ts b/typegate/src/typegraph/types.ts index 1cb8891f1..9ba5fc7fc 100644 --- a/typegate/src/typegraph/types.ts +++ b/typegate/src/typegraph/types.ts @@ -240,7 +240,7 @@ export type StringFormat = | "date" | "date-time" | "phone"; -export type ParameterTransformNode = +export type ParameterTransformNodeData = | ParameterTransformLeafNode | ParameterTransformParentNode; export type ParameterTransformLeafNode = { @@ -248,7 +248,7 @@ export type ParameterTransformLeafNode = { name: string; } | { source: "static"; - value_json: string; + valueJson: string; } | { source: "secret"; key: string; @@ -257,7 +257,7 @@ export type ParameterTransformLeafNode = { key: string; } | { source: "parent"; - type_idx: number; + parentIdx: number; }; export type ParameterTransformParentNode = { type: "object"; @@ -393,9 +393,11 @@ export interface SingleValueForUint32 { } export interface FunctionParameterTransform { resolver_input: number; - transform_root: { - [k: string]: ParameterTransformNode; - }; + transform_root: ParameterTransformNode; +} +export interface ParameterTransformNode { + typeIdx: number; + data: ParameterTransformNodeData; } export interface Materializer { name: string; diff --git a/typegraph/core/src/conversion/parameter_transform.rs b/typegraph/core/src/conversion/parameter_transform.rs index a0f604f82..1aeddbcfd 100644 --- a/typegraph/core/src/conversion/parameter_transform.rs +++ b/typegraph/core/src/conversion/parameter_transform.rs @@ -7,19 +7,23 @@ 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: &HashMap, + root_fields: &ParameterTransformNode, runtime_id: u32, -) -> Result> { - let object_node = convert_object_node(ctx, root_fields, runtime_id)?; - match object_node { - cm::ParameterTransformParentNode::Object { fields } => Ok(fields), - _ => unreachable!(), +) -> 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( @@ -27,12 +31,25 @@ fn convert_node( node: &ParameterTransformNode, runtime_id: u32, ) -> Result { - match node { - ParameterTransformNode::Leaf(leaf_node) => { - convert_leaf_node(ctx, leaf_node, runtime_id).map(cm::ParameterTransformNode::Leaf) + 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), + } + }) } - ParameterTransformNode::Parent(a) => { - convert_parent_node(ctx, a, runtime_id).map(cm::ParameterTransformNode::Parent) + 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), + } + }) } } } @@ -43,11 +60,9 @@ fn convert_leaf_node( runtime_id: u32, ) -> Result { match node { - ParameterTransformLeafNode::Arg { name } => Ok(cm::ParameterTransformLeafNode::Arg { - name: name.clone().ok_or_else(|| { - Into::::into("argument must have a know name".to_string()) - })?, - }), + ParameterTransformLeafNode::Arg { name } => { + Ok(cm::ParameterTransformLeafNode::Arg { name: name.clone() }) + } ParameterTransformLeafNode::Static { value_json } => { Ok(cm::ParameterTransformLeafNode::Static { value_json: value_json.clone(), @@ -62,8 +77,8 @@ fn convert_leaf_node( ParameterTransformLeafNode::Parent { name } => { let type_ref = t::ref_(name).build()?; let (_, type_def) = type_ref.resolve_ref()?; - let type_idx = ctx.register_type(type_def, Some(runtime_id))?.0; - Ok(cm::ParameterTransformLeafNode::Parent { type_idx }) + let parent_idx = ctx.register_type(type_def, Some(runtime_id))?.0; + Ok(cm::ParameterTransformLeafNode::Parent { parent_idx }) } } } diff --git a/typegraph/core/src/lib.rs b/typegraph/core/src/lib.rs index ead91adbd..abfd2bb24 100644 --- a/typegraph/core/src/lib.rs +++ b/typegraph/core/src/lib.rs @@ -30,9 +30,9 @@ use types::{ }; use wit::core::{ - ApplyParams, ContextCheck, ParameterTransform, 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}; @@ -341,20 +341,16 @@ impl wit::core::Guest for Lib { .into()) } - fn gen_apply(resolver_input: CoreTypeId, transform_tree: String) -> Result { - let query_input = apply::ParameterTransformValidator::new().query_input( + 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() })?, - )?; - Ok(ApplyParams { - query_input: query_input.0, - parameter_transform: ParameterTransform { - resolver_input, - transform_tree, - }, - }) + ) } fn with_injection(type_id: CoreTypeId, injection: String) -> Result { diff --git a/typegraph/core/src/params/apply.rs b/typegraph/core/src/params/apply.rs index 7790b0030..d8609a138 100644 --- a/typegraph/core/src/params/apply.rs +++ b/typegraph/core/src/params/apply.rs @@ -4,20 +4,55 @@ use crate::errors::{ErrorContext, Result, TgError}; use crate::t::{self, TypeBuilder}; use crate::types::{Type, TypeDef, TypeId}; -use serde::Deserialize; +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 { 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, Deserialize)] +#[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "source", rename_all = "lowercase")] pub enum ParameterTransformLeafNode { - Arg { name: Option }, + Arg { name: String }, Static { value_json: String }, Secret { key: String }, Context { key: String }, Parent { name: String }, } -#[derive(Debug, Clone, Deserialize)] +#[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "lowercase")] pub enum ParameterTransformParentNode { Object { @@ -28,27 +63,60 @@ pub enum ParameterTransformParentNode { }, } -#[derive(Debug, Clone, Deserialize)] -#[serde(untagged, rename_all = "lowercase")] -pub enum ParameterTransformNode { +#[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, } -pub struct ParameterTransformValidator { - query_params: HashMap, -} - +#[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; @@ -65,98 +133,133 @@ impl TryFrom for PathSeg { } } -impl ParameterTransformValidator { +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(provided: Option<&str>, path: &[String]) -> Result { + fn get_param_name(&self, provided: Option<&str>) -> Result { if let Some(provided) = provided { Ok(provided.to_string()) } else { - let name = path + let seg = self + .path .last() .ok_or_else(|| TgError::from("Cannot get param name from empty path"))?; - let seg = PathSeg::try_from(name.clone()).with_context(|| { - format!( - "Could not get path segment from {name:?} at {}", - path.join(".") - ) - })?; match seg { - PathSeg::Field(name) => Ok(name), + PathSeg::Field(name) => Ok(name.clone()), PathSeg::Index(_) => Err(format!( "Cannot get param name from array item at {}. Please provide an explicit name", - path.join(".") + stringify_path(&self.path).unwrap() ) .into()), } } } - // get query input type - pub fn query_input( - mut self, - resolver_input: TypeId, - root_fields: &HashMap, - ) -> Result { - self.check_object_node(resolver_input, root_fields, vec![])?; - - let mut query_input_type = t::struct_(); - for (name, param) in self.query_params.into_iter() { - query_input_type.prop(name, param.type_id); - } - - query_input_type.build() - } - fn check_leaf_node( &mut self, type_id: TypeId, - leaf: &ParameterTransformLeafNode, - path: Vec, - ) -> Result<()> { + leaf: &raw_tree::ParameterTransformLeafNode, + ) -> Result { + use raw_tree::ParameterTransformLeafNode as N; match leaf { - ParameterTransformLeafNode::Arg { name } => { - let param_name = Self::get_param_name(name.as_deref(), &path)?; + 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: path.clone(), + path: self.path.iter().map(|seg| seg.to_string()).collect(), type_id, }, ); if let Some(param) = old_param { - let path1 = path.join("."); + let path1 = stringify_path(&self.path)?; let path2 = param.path.join("."); Err( format!("Duplicate parameter {param_name:?} at {path1:?} and {path2:?}") .into(), ) } else { - Ok(()) + Ok(ParameterTransformNode { + type_id: type_id.0, + data: ParameterTransformNodeData::Leaf(ParameterTransformLeafNode::Arg { + name: param_name, + }), + }) } } - ParameterTransformLeafNode::Static { .. } => Ok(()), // TODO validate agains type - ParameterTransformLeafNode::Secret { .. } => Ok(()), - ParameterTransformLeafNode::Context { .. } => Ok(()), - ParameterTransformLeafNode::Parent { .. } => Ok(()), + 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 { name } => Ok(ParameterTransformNode { + type_id: type_id.0, + data: ParameterTransformNodeData::Leaf(ParameterTransformLeafNode::Parent { + name: name.clone(), + }), + }), } } fn check_object_node( &mut self, type_id: TypeId, - fields: &HashMap, - path: Vec, - ) -> Result<()> { + 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 = path.join(".") + path = stringify_path(&self.path).unwrap() ) })?; let mut available_fields = ty @@ -171,13 +274,14 @@ impl ParameterTransformValidator { "Field {field:?} not found in type {repr:?} at {path:?}", field = field, repr = type_id.repr().unwrap(), - path = path.join("."), + path = stringify_path(&self.path).unwrap() ) })?; - let mut path = path.clone(); - path.push(field.clone()); - self.check_node(prop_type_id.into(), node, path)?; + 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 @@ -195,7 +299,7 @@ impl ParameterTransformValidator { .with_context(|| { format!( "Error while resolving type #{type_id} at the field {k:?} at {path:?}", - path = path.join(".") + path = stringify_path(&self.path).unwrap() ) }) .transpose() @@ -205,53 +309,61 @@ impl ParameterTransformValidator { if !non_optional_fields.is_empty() { Err(format!( "Missing non-optional fields {non_optional_fields:?} at {path:?}", - path = path.join(".") + path = stringify_path(&self.path).unwrap() ) .into()) } else { - Ok(()) + 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: &[ParameterTransformNode], - path: Vec, - ) -> Result<()> { + 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 = path.join(".") + path = stringify_path(&self.path).unwrap() ) })?; let item_type_id = TypeId(ty.data.of); for (index, node) in items.iter().enumerate() { - let mut path = path.clone(); - path.push(format!("[{index}]")); - self.check_node(item_type_id, node, path)?; + 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(()) + Ok(ParameterTransformNode { + type_id: type_id.0, + data: ParameterTransformNodeData::Parent(ParameterTransformParentNode::Array { + items: new_items, + }), + }) } fn check_node( &mut self, type_id: TypeId, - node: &ParameterTransformNode, - path: Vec, - ) -> Result<()> { + node: &raw_tree::ParameterTransformNode, + ) -> Result { + use raw_tree::ParameterTransformNode as N; + use raw_tree::ParameterTransformParentNode as P; match node { - ParameterTransformNode::Leaf(leaf) => self.check_leaf_node(type_id, leaf, path), - ParameterTransformNode::Parent(parent) => match parent { - ParameterTransformParentNode::Object { fields } => { - self.check_object_node(type_id, fields, path) - } - ParameterTransformParentNode::Array { items } => { - self.check_array_node(type_id, items, path) - } + 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), }, } } @@ -264,7 +376,7 @@ mod test { #[test] fn identity() -> Result<()> { - let validator = ParameterTransformValidator::new(); + let validator = TransformTreeValidationContext::new(); let input = t::struct_() .propx("a", t::string())? .propx("b", t::string())? @@ -301,7 +413,7 @@ mod test { #[test] fn identity_named() -> Result<()> { - let validator = ParameterTransformValidator::new(); + let validator = TransformTreeValidationContext::new(); let input = t::struct_() .propx("a", t::string())? .propx("b", t::string())? @@ -341,7 +453,7 @@ mod test { #[test] fn array_items() -> Result<()> { - let validator = ParameterTransformValidator::new(); + let validator = TransformTreeValidationContext::new(); let input = t::struct_() .propx("a", t::string())? .propx("b", t::listx(t::string())?)? @@ -411,7 +523,7 @@ mod test { .into_iter() .collect(), }; - let query_input = ParameterTransformValidator::new().query_input(input, root)?; + let query_input = TransformTreeValidationContext::new().query_input(input, root)?; let print_options = tree::PrintOptions::new().no_indent_lines(); assert_eq!( diff --git a/typegraph/core/src/typedef/func.rs b/typegraph/core/src/typedef/func.rs index 7f5f7e655..675b4ccce 100644 --- a/typegraph/core/src/typedef/func.rs +++ b/typegraph/core/src/typedef/func.rs @@ -1,8 +1,6 @@ // Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. // SPDX-License-Identifier: MPL-2.0 -use std::collections::HashMap; - use common::typegraph::{ parameter_transform::FunctionParameterTransform, FunctionTypeData, TypeNode, }; @@ -37,7 +35,7 @@ impl TypeConversion for Func { .as_ref() .map(|transform| -> Result<_> { let resolver_input = TypeId(transform.resolver_input); - let transform_root: HashMap = + let transform_root: ParameterTransformNode = serde_json::from_str(&transform.transform_tree).map_err(|e| { TgError::from(format!("Failed to parse transform_root: {}", e)) })?; diff --git a/typegraph/core/src/utils/mod.rs b/typegraph/core/src/utils/mod.rs index c822b6356..4e9861329 100644 --- a/typegraph/core/src/utils/mod.rs +++ b/typegraph/core/src/utils/mod.rs @@ -9,7 +9,6 @@ use serde_json::json; use crate::errors::Result; use crate::global_store::Store; -use crate::params::apply::ParameterTransformValidator; use crate::types::TypeId; use crate::wit::core::{Guest, TypeBase, TypeId as CoreTypeId, TypeStruct}; use crate::wit::utils::{Auth as WitAuth, QueryBodyParams}; @@ -163,14 +162,6 @@ impl crate::wit::utils::Guest for crate::Lib { Ok(*root_id) } - fn check_parameter_transform(resolver_input: CoreTypeId, tree: String) -> Result { - let root_fields = serde_json::from_str(&tree) - .map_err(|e| format!("Error while parsing parameter transform tree: {e:?}"))?; - ParameterTransformValidator::new() - .query_input(resolver_input.into(), &root_fields) - .map(Into::into) - } - fn add_graphql_endpoint(graphql: String) -> Result { Store::add_graphql_endpoint(graphql) } diff --git a/typegraph/core/wit/typegraph.wit b/typegraph/core/wit/typegraph.wit index f5a2a65e4..035fe434e 100644 --- a/typegraph/core/wit/typegraph.wit +++ b/typegraph/core/wit/typegraph.wit @@ -155,11 +155,12 @@ interface core { funcb: func(data: type-func) -> result - record apply-params { + record transform-data { query-input: type-id, parameter-transform: parameter-transform, } - gen-apply: func(resolver-input: type-id, transform-tree: string) -> result + + get-transform-data: func(resolver-input: type-id, transform-tree: string) -> result type policy-id = u32 @@ -496,8 +497,6 @@ interface utils { gen-reduceb: func(supertype-id: type-id, data: reduce) -> result - check-parameter-transform: func(resolver-inp: type-id, transform: string) -> result - add-graphql-endpoint: func(graphql: string) -> result variant auth-protocol { diff --git a/typegraph/python/typegraph/t.py b/typegraph/python/typegraph/t.py index ba03eab99..865640c9e 100644 --- a/typegraph/python/typegraph/t.py +++ b/typegraph/python/typegraph/t.py @@ -4,7 +4,6 @@ import json as JsonLib from typing import Any, Dict, List, Optional, Tuple, Union import copy -import sys from typing_extensions import Self @@ -723,17 +722,16 @@ def apply(self, value: ApplyParamObjectNode) -> "func": assert isinstance(serialized, dict) assert serialized["type"] == "object" transform_tree = JsonLib.dumps(serialized["fields"]) - print(transform_tree, file=sys.stderr) - apply_params = core.gen_apply(store, self.inp.id, transform_tree) - if isinstance(apply_params, Err): - raise Exception(apply_params.value) + transform_data = core.get_transform_data(store, self.inp.id, transform_tree) + if isinstance(transform_data, Err): + raise Exception(transform_data.value) return func( - typedef(apply_params.value.query_input), + typedef(transform_data.value.query_input), self.out, self.mat, - parameter_transform=apply_params.value.parameter_transform, + parameter_transform=transform_data.value.parameter_transform, rate_calls=self.rate_calls, rate_weight=self.rate_weight, ) diff --git a/website/static/specs/0.0.3.json b/website/static/specs/0.0.3.json index fc265379a..845a327ca 100644 --- a/website/static/specs/0.0.3.json +++ b/website/static/specs/0.0.3.json @@ -1323,14 +1323,28 @@ "minimum": 0.0 }, "transform_root": { - "type": "object", - "additionalProperties": { - "$ref": "#/definitions/ParameterTransformNode" - } + "$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" @@ -1364,7 +1378,7 @@ "type": "object", "required": [ "source", - "value_json" + "valueJson" ], "properties": { "source": { @@ -1373,7 +1387,7 @@ "static" ] }, - "value_json": { + "valueJson": { "type": "string" } } @@ -1417,8 +1431,8 @@ { "type": "object", "required": [ - "source", - "type_idx" + "parentIdx", + "source" ], "properties": { "source": { @@ -1427,7 +1441,7 @@ "parent" ] }, - "type_idx": { + "parentIdx": { "type": "integer", "format": "uint32", "minimum": 0.0 From c3a9377d0da5289154fb0158844384d6be34faa3 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Sat, 10 Feb 2024 12:24:30 +0300 Subject: [PATCH 07/32] more tests/fixes --- .../engine/planner/parameter_transformer.ts | 28 ++++---- typegate/tests/params/apply.py | 68 +++++++++++++++++- typegate/tests/params/apply_test.ts | 70 ++++++++++++++++++- .../src/conversion/parameter_transform.rs | 4 +- typegraph/core/src/params/apply.rs | 8 +-- typegraph/python/typegraph/t.py | 3 + 6 files changed, 161 insertions(+), 20 deletions(-) diff --git a/typegate/src/engine/planner/parameter_transformer.ts b/typegate/src/engine/planner/parameter_transformer.ts index 911a47778..bcd02ca4f 100644 --- a/typegate/src/engine/planner/parameter_transformer.ts +++ b/typegate/src/engine/planner/parameter_transformer.ts @@ -7,7 +7,6 @@ import { ParameterTransformNode } from "../../typegraph/types.ts"; export type TransformParamsInput = { args: Record; context: Record; - // secrets: Record; parent: Record; }; @@ -26,7 +25,11 @@ export function compileParameterTransformer( ): TransformParams { const ctx = new TransformerCompilationContext(typegraph, parentProps); const fnBody = ctx.compile(transformerTreeRoot); - return new Function("input", fnBody) as TransformParams; + const fn = new Function("input", fnBody) as TransformParams; + return (input) => { + const res = fn(input); + return res; + }; } class TransformerCompilationContext { @@ -43,7 +46,6 @@ class TransformerCompilationContext { #reset() { this.#collector = [ - // TODO secrets "const { args, context, parent } = input;\n", ]; } @@ -75,8 +77,8 @@ class TransformerCompilationContext { return this.#compileArgInjection(typeIdx, nodeData.name); case "context": return this.#compileContextInjection(typeIdx, nodeData.key); - // case "secret": - // return this.#compileSecretsInjection(node); + case "secret": + return this.#compileSecretsInjection(typeIdx, nodeData.key); case "parent": return this.#compileParentInjection(typeIdx, nodeData.parentIdx); default: @@ -134,17 +136,19 @@ class TransformerCompilationContext { return varName; } - // #compileSecretsInjection(key: string) { - // // TODO type validation ? - // const varName = this.#createVarName(); - // this.#collector.push(`const ${varName} = secrets["${key}"];`); - // return varName; - // } + // return () => this.tg.parseSecret(typ, secretName); + #compileSecretsInjection(typeIdx: number, key: string) { + const secret = this.#tg.parseSecret(this.#tg.type(typeIdx), key); + // TODO type validation ? -- only additional constraints + const varName = this.#createVarName(); + this.#collector.push(`const ${varName} = ${JSON.stringify(secret)};`); + return varName; + } #compileParentInjection(_typeIdx: number, parentIdx: number) { // TODO type validation ? // TODO what if the value is lazy (a function?) - const key = Object.entries(this.#parentProps) + const [key] = Object.entries(this.#parentProps) .find(([_key, idx]) => idx === parentIdx)!; const varName = this.#createVarName(); this.#collector.push(`const ${varName} = parent["${key}"];`); diff --git a/typegate/tests/params/apply.py b/typegate/tests/params/apply.py index fd1fdf7e1..19d343d24 100644 --- a/typegate/tests/params/apply.py +++ b/typegate/tests/params/apply.py @@ -3,7 +3,7 @@ @typegraph() -def renamed_params(g: Graph): +def test_apply(g: Graph): deno = DenoRuntime() public = Policy.public() @@ -15,4 +15,70 @@ def renamed_params(g: Graph): "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 })""", + ), ) diff --git a/typegate/tests/params/apply_test.ts b/typegate/tests/params/apply_test.ts index 34e56f2d8..f9679faca 100644 --- a/typegate/tests/params/apply_test.ts +++ b/typegate/tests/params/apply_test.ts @@ -4,7 +4,11 @@ import { gql, Meta } from "../utils/mod.ts"; Meta.test("(python (sdk): apply)", async (t) => { - const e = await t.engine("params/apply.py"); + const e = await t.engine("params/apply.py", { + secrets: { + "MY_SECRET": "supersecret", + }, + }); await t.should("work with renamed params", async () => { await gql` @@ -19,4 +23,68 @@ Meta.test("(python (sdk): apply)", async (t) => { }) .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); + }); }); diff --git a/typegraph/core/src/conversion/parameter_transform.rs b/typegraph/core/src/conversion/parameter_transform.rs index 1aeddbcfd..7dcb48a24 100644 --- a/typegraph/core/src/conversion/parameter_transform.rs +++ b/typegraph/core/src/conversion/parameter_transform.rs @@ -74,8 +74,8 @@ fn convert_leaf_node( ParameterTransformLeafNode::Context { key } => { Ok(cm::ParameterTransformLeafNode::Context { key: key.clone() }) } - ParameterTransformLeafNode::Parent { name } => { - let type_ref = t::ref_(name).build()?; + 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 }) diff --git a/typegraph/core/src/params/apply.rs b/typegraph/core/src/params/apply.rs index d8609a138..5c5c87a57 100644 --- a/typegraph/core/src/params/apply.rs +++ b/typegraph/core/src/params/apply.rs @@ -20,7 +20,7 @@ pub mod raw_tree { Static { value_json: String }, Secret { key: String }, Context { key: String }, - Parent { name: String }, + Parent { type_name: String }, } #[derive(Debug, Clone, Deserialize)] @@ -49,7 +49,7 @@ pub enum ParameterTransformLeafNode { Static { value_json: String }, Secret { key: String }, Context { key: String }, - Parent { name: String }, + Parent { type_name: String }, } #[derive(Debug, Clone, Serialize, Deserialize)] @@ -240,10 +240,10 @@ impl TransformDataBuildContext { key: key.clone(), }), }), - N::Parent { name } => Ok(ParameterTransformNode { + N::Parent { type_name } => Ok(ParameterTransformNode { type_id: type_id.0, data: ParameterTransformNodeData::Leaf(ParameterTransformLeafNode::Parent { - name: name.clone(), + type_name: type_name.clone(), }), }), } diff --git a/typegraph/python/typegraph/t.py b/typegraph/python/typegraph/t.py index 865640c9e..87f8525e3 100644 --- a/typegraph/python/typegraph/t.py +++ b/typegraph/python/typegraph/t.py @@ -725,6 +725,9 @@ def apply(self, value: ApplyParamObjectNode) -> "func": 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( From 5403bbc627811022a2ce760869b5f6e6ac5724cc Mon Sep 17 00:00:00 2001 From: Natoandro Date: Sat, 10 Feb 2024 12:43:50 +0300 Subject: [PATCH 08/32] test in-list injection --- typegate/tests/params/apply.py | 14 ++++++++++++++ typegate/tests/params/apply_test.ts | 14 ++++++++++++++ typegraph/python/typegraph/t.py | 5 +++-- 3 files changed, 31 insertions(+), 2 deletions(-) diff --git a/typegate/tests/params/apply.py b/typegate/tests/params/apply.py index 19d343d24..42bddc43f 100644 --- a/typegate/tests/params/apply.py +++ b/typegate/tests/params/apply.py @@ -81,4 +81,18 @@ def test_apply(g: Graph): ), code="""() => ({ a: 1 })""", ), + withArray=deno.identity( + t.struct( + { + "a": t.list(t.integer()), + } + ) + ).apply( + { + "a": [ + g.as_arg("first"), + g.as_arg("second"), + ] + } + ), ) diff --git a/typegate/tests/params/apply_test.ts b/typegate/tests/params/apply_test.ts index f9679faca..c64253282 100644 --- a/typegate/tests/params/apply_test.ts +++ b/typegate/tests/params/apply_test.ts @@ -87,4 +87,18 @@ Meta.test("(python (sdk): apply)", async (t) => { }) .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); + }); }); diff --git a/typegraph/python/typegraph/t.py b/typegraph/python/typegraph/t.py index 87f8525e3..3f57651a8 100644 --- a/typegraph/python/typegraph/t.py +++ b/typegraph/python/typegraph/t.py @@ -633,9 +633,10 @@ def serialize_apply_param_node(node: ApplyParamNode) -> Any: "type": "object", "fields": {k: serialize_apply_param_node(v) for k, v in node.items()}, } - if isinstance(node, list): + 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}") + + raise Exception(f"unexpected node type: node={node}") class func(typedef): From 61d519eb2b7933a48efa5d669be71f105da5b7bd Mon Sep 17 00:00:00 2001 From: Natoandro Date: Mon, 12 Feb 2024 09:09:44 +0300 Subject: [PATCH 09/32] address comments (security) --- typegate/src/engine/planner/parameter_transformer.ts | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/typegate/src/engine/planner/parameter_transformer.ts b/typegate/src/engine/planner/parameter_transformer.ts index bcd02ca4f..48dacfb81 100644 --- a/typegate/src/engine/planner/parameter_transformer.ts +++ b/typegate/src/engine/planner/parameter_transformer.ts @@ -101,7 +101,9 @@ class TransformerCompilationContext { path.push(key); const propVarName = this.#compileNode(node); path.pop(); - this.#collector.push(`${varName}["${key}"] = ${propVarName};`); + this.#collector.push( + `${varName}[${JSON.stringify(key)}] = ${propVarName};`, + ); } return varName; @@ -125,14 +127,14 @@ class TransformerCompilationContext { #compileArgInjection(_typeIdx: number, name: string) { // TODO type validation ? const varName = this.#createVarName(); - this.#collector.push(`const ${varName} = args["${name}"];`); + this.#collector.push(`const ${varName} = args[${JSON.stringify(name)}];`); return varName; } #compileContextInjection(_typeIdx: number, key: string) { // TODO type validation ? const varName = this.#createVarName(); - this.#collector.push(`const ${varName} = context["${key}"];`); + this.#collector.push(`const ${varName} = context[${JSON.stringify(key)}];`); return varName; } @@ -151,7 +153,7 @@ class TransformerCompilationContext { const [key] = Object.entries(this.#parentProps) .find(([_key, idx]) => idx === parentIdx)!; const varName = this.#createVarName(); - this.#collector.push(`const ${varName} = parent["${key}"];`); + this.#collector.push(`const ${varName} = parent[${JSON.stringify(key)}];`); return varName; } From d8b869e8704357014afc768e60aa14eea35debc8 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Mon, 12 Feb 2024 18:32:32 +0300 Subject: [PATCH 10/32] inline validators --- .../engine/planner/parameter_transformer.ts | 121 +++++++++++++++++- .../typecheck/inline_validators/boolean.ts | 15 +++ .../typecheck/inline_validators/common.ts | 6 + .../inline_validators/constraints.ts | 61 +++++++++ .../typecheck/inline_validators/file.ts | 38 ++++++ .../typecheck/inline_validators/list.ts | 33 +++++ .../engine/typecheck/inline_validators/mod.ts | 6 + .../typecheck/inline_validators/number.ts | 30 +++++ .../typecheck/inline_validators/object.ts | 56 ++++++++ .../typecheck/inline_validators/string.ts | 55 ++++++++ 10 files changed, 415 insertions(+), 6 deletions(-) create mode 100644 typegate/src/engine/typecheck/inline_validators/boolean.ts create mode 100644 typegate/src/engine/typecheck/inline_validators/common.ts create mode 100644 typegate/src/engine/typecheck/inline_validators/constraints.ts create mode 100644 typegate/src/engine/typecheck/inline_validators/file.ts create mode 100644 typegate/src/engine/typecheck/inline_validators/list.ts create mode 100644 typegate/src/engine/typecheck/inline_validators/mod.ts create mode 100644 typegate/src/engine/typecheck/inline_validators/number.ts create mode 100644 typegate/src/engine/typecheck/inline_validators/object.ts create mode 100644 typegate/src/engine/typecheck/inline_validators/string.ts diff --git a/typegate/src/engine/planner/parameter_transformer.ts b/typegate/src/engine/planner/parameter_transformer.ts index 48dacfb81..164ec06eb 100644 --- a/typegate/src/engine/planner/parameter_transformer.ts +++ b/typegate/src/engine/planner/parameter_transformer.ts @@ -2,7 +2,16 @@ // 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; @@ -90,7 +99,7 @@ class TransformerCompilationContext { } #compileObject( - _typeIdx: number, // TODO validation + typeIdx: number, fields: Record, ): string { const varName = this.#createVarName(); @@ -106,10 +115,21 @@ class TransformerCompilationContext { ); } + 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[]) { + #compileArray(typeIdx: number, items: ParameterTransformNode[]) { const varName = this.#createVarName(); this.#collector.push(`const ${varName} = [];`); @@ -121,29 +141,118 @@ class TransformerCompilationContext { 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) { - // TODO type validation ? + // 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) { + #compileContextInjection(typeIdx: number, key: string) { // TODO type validation ? 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; } - // return () => this.tg.parseSecret(typ, secretName); #compileSecretsInjection(typeIdx: number, key: string) { - const secret = this.#tg.parseSecret(this.#tg.type(typeIdx), key); + 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)};`); + + switch (typeNode.type) { + case Type.STRING: + this.#collector.push( + ...generateStringValidator(typeNode, varName, this.#path.join(".")), + ); + break; + case Type.INTEGER: + case Type.FLOAT: + this.#collector.push( + ...generateNumberValidator(typeNode, varName, this.#path.join(".")), + ); + break; + default: + // TODO optional?? + throw new Error( + `At "${ + this.#path.join(".") + }": Unsupported type "${typeNode.type}" for secret injection`, + ); + } + return varName; } 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; +} From 188f13df71946b99bf2cb3c12455278e2fdc19b4 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Mon, 12 Feb 2024 20:41:22 +0300 Subject: [PATCH 11/32] visitor context --- libs/common/src/typegraph/validator.rs | 86 ++++++++++++-------- libs/common/src/typegraph/visitor.rs | 108 +++++++++++++++++++------ 2 files changed, 134 insertions(+), 60 deletions(-) diff --git a/libs/common/src/typegraph/validator.rs b/libs/common/src/typegraph/validator.rs index 1fc757785..aa7c978f0 100644 --- a/libs/common/src/typegraph/validator.rs +++ b/libs/common/src/typegraph/validator.rs @@ -8,14 +8,15 @@ use anyhow::{anyhow, bail, Result}; use serde_json::Value; use super::{ - visitor::{Path, PathSegment, TypeVisitor, VisitResult}, + visitor::{CurrentNode, Path, PathSegment, TypeVisitor, TypeVisitorContext, VisitResult}, EitherTypeData, FloatTypeData, Injection, IntegerTypeData, ListTypeData, ObjectTypeData, StringTypeData, UnionTypeData, }; pub fn validate_typegraph(tg: &Typegraph) -> Vec { + let context = ValidatorContext { typegraph: tg }; let validator = Validator::default(); - tg.traverse_types(validator).unwrap() + tg.traverse_types(validator, &context).unwrap() } #[derive(Debug)] @@ -24,7 +25,12 @@ pub struct ValidatorError { pub message: String, } -#[derive(Default)] +#[derive(Debug)] +pub struct ValidatorContext<'a> { + typegraph: &'a Typegraph, +} + +#[derive(Debug, Default)] struct Validator { errors: Vec, } @@ -61,34 +67,39 @@ impl Typegraph { } } -impl TypeVisitor for Validator { +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, - type_idx: u32, - path: &[PathSegment], - tg: &Typegraph, - as_input: bool, + current_node: CurrentNode<'_>, + context: &Self::Context, ) -> VisitResult { - let node = &tg.types[type_idx as usize]; - - if as_input { + let typegraph = context.get_typegraph(); + let type_node = current_node.type_node; + if current_node.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"); + if let TypeNode::Function { .. } = type_node { + self.push_error(current_node.path, "function is not allowed in input types"); return VisitResult::Continue(false); } } else { - match node { + match type_node { TypeNode::Union { .. } | TypeNode::Either { .. } => { let mut variants = vec![]; - tg.collect_nested_variants_into(&mut variants, &[type_idx]); + typegraph.collect_nested_variants_into(&mut variants, &[current_node.type_idx]); let mut object_count = 0; for variant_type in variants .iter() - .map(|idx| tg.types.get(*idx as usize).unwrap()) + .map(|idx| typegraph.types.get(*idx as usize).unwrap()) { match variant_type { TypeNode::Object { .. } => object_count += 1, @@ -99,10 +110,10 @@ impl TypeVisitor for Validator { // scalar } TypeNode::List { data, .. } => { - let item_type = tg.types.get(data.items as usize).unwrap(); + let item_type = typegraph.types.get(data.items as usize).unwrap(); if !item_type.is_scalar() { self.push_error( - path, + current_node.path, format!( "array of '{}' not allowed as union/either variant", item_type.type_name() @@ -113,7 +124,7 @@ impl TypeVisitor for Validator { } _ => { self.push_error( - path, + current_node.path, format!( "type '{}' not allowed as union/either variant", variant_type.type_name() @@ -126,7 +137,7 @@ impl TypeVisitor for Validator { if object_count != 0 && object_count != variants.len() { self.push_error( - path, + current_node.path, "union variants must either be all scalars or all objects", ); return VisitResult::Continue(false); @@ -140,21 +151,24 @@ impl TypeVisitor for Validator { } } - if let Some(enumeration) = &node.base().enumeration { - if matches!(node, TypeNode::Optional { .. }) { + if let Some(enumeration) = &type_node.base().enumeration { + if matches!(type_node, TypeNode::Optional { .. }) { self.push_error( - path, + current_node.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(val) => match context + .get_typegraph() + .validate_value(current_node.type_idx, &val) + { Ok(_) => {} - Err(err) => self.push_error(path, err.to_string()), + Err(err) => self.push_error(current_node.path, err.to_string()), }, Err(e) => self.push_error( - path, + current_node.path, format!("Error while deserializing enum value {value:?}: {e:?}"), ), } @@ -162,22 +176,24 @@ impl TypeVisitor for Validator { } } - if let Some(injection) = &node.base().injection { + if let Some(injection) = &type_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()), - }, + 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( - path, + current_node.path, format!( - "Error while parsing static injection value {value:?}: {e:?}", - value = value - ), + "Error while parsing static injection value {value:?}: {e:?}", + value = value + ), ); } } diff --git a/libs/common/src/typegraph/visitor.rs b/libs/common/src/typegraph/visitor.rs index 500f7e00b..ca36a2ffe 100644 --- a/libs/common/src/typegraph/visitor.rs +++ b/libs/common/src/typegraph/visitor.rs @@ -8,7 +8,11 @@ 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: TypeVisitor<'a> + Sized>( + &'a self, + visitor: V, + context: &'a V::Context, + ) -> Option { let mut traversal = TypegraphTraversal { tg: self, path: vec![], @@ -18,7 +22,7 @@ impl Typegraph { visitor, }; traversal - .visit_type(0) + .visit_type(0, context) .or_else(|| traversal.visitor.get_result()) // if let Some(ret) = traversal.visit_type(0) { // ret @@ -28,7 +32,7 @@ impl Typegraph { } } -struct TypegraphTraversal<'a, V: TypeVisitor + Sized> { +struct TypegraphTraversal<'a, V: TypeVisitor<'a> + Sized> { tg: &'a Typegraph, path: Vec>, as_input: bool, @@ -37,8 +41,8 @@ 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 { +impl<'a, V: TypeVisitor<'a> + Sized> TypegraphTraversal<'a, V> { + fn visit_type(&mut self, type_idx: u32, context: &'a V::Context) -> Option { if self.as_input { if self.visited_input_types.contains(&type_idx) { return None; @@ -51,20 +55,30 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { 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, + as_input: self.as_input, + }; + + let res = 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,7 +95,12 @@ 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, @@ -89,10 +108,16 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { }, 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, @@ -100,6 +125,7 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { }, item_type_idx, false, + context, ) } @@ -107,6 +133,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( @@ -116,6 +143,7 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { }, *prop_type, false, + context, ); if let Some(res) = res { return Some(res); @@ -124,7 +152,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 { @@ -133,6 +166,7 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { }, *variant_type, false, + context, ); if let Some(ret) = res { return Some(ret); @@ -141,7 +175,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 { @@ -150,11 +189,18 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { }, *t, false, + context, ) }) } - fn visit_function(&mut self, type_idx: u32, input: u32, output: u32) -> Option { + fn visit_function( + &mut self, + type_idx: u32, + input: u32, + output: u32, + context: &'a V::Context, + ) -> Option { [ (Edge::FunctionInput, input, true), (Edge::FunctionOutput, output, false), @@ -168,6 +214,7 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { }, t, as_input, + context, ) }) } @@ -177,6 +224,7 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { 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 { @@ -184,7 +232,7 @@ impl<'a, V: TypeVisitor + Sized> TypegraphTraversal<'a, V> { } 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 { @@ -242,16 +290,26 @@ pub enum VisitResult { Return(T), } -pub trait TypeVisitor { +pub struct CurrentNode<'a> { + pub type_idx: u32, + pub type_node: &'a TypeNode, + pub path: &'a [PathSegment<'a>], + pub as_input: bool, +} + +pub trait TypeVisitorContext { + fn get_typegraph(&self) -> &Typegraph; +} + +pub trait TypeVisitor<'a> { type Return: Sized; + type Context: TypeVisitorContext; /// 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 From 293e7ca531b64ce6fd71e2e5c321d5a640e05110 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Tue, 13 Feb 2024 11:48:20 +0300 Subject: [PATCH 12/32] inheritance validator --- Cargo.lock | 345 ++++++++-------- libs/common/src/typegraph/types.rs | 2 +- libs/common/src/typegraph/validator.rs | 264 +------------ libs/common/src/typegraph/validator/input.rs | 117 ++++++ libs/common/src/typegraph/validator/types.rs | 367 ++++++++++++++++++ libs/common/src/typegraph/validator/value.rs | 268 +++++++++++++ .../engine/planner/parameter_transformer.ts | 14 +- 7 files changed, 954 insertions(+), 423 deletions(-) create mode 100644 libs/common/src/typegraph/validator/input.rs create mode 100644 libs/common/src/typegraph/validator/types.rs create mode 100644 libs/common/src/typegraph/validator/value.rs diff --git a/Cargo.lock b/Cargo.lock index f3cf3c7d8..63309ed78 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -155,9 +155,9 @@ dependencies = [ [[package]] name = "ahash" -version = "0.7.7" +version = "0.7.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a824f2aa7e75a0c98c5a504fceb80649e9c35265d44525b5f94de4771a395cd" +checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" dependencies = [ "getrandom 0.2.12", "once_cell", @@ -166,9 +166,9 @@ dependencies = [ [[package]] name = "ahash" -version = "0.8.7" +version = "0.8.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77c3a9648d43b9cd48db467b3f87fdd6e146bcc88ab0180006cef2179fe11d01" +checksum = "42cd52102d3df161c77a887b608d7a4897d7cc112886a9537b738a887a03aaff" dependencies = [ "cfg-if", "getrandom 0.2.12", @@ -343,7 +343,7 @@ dependencies = [ "asn1-rs-impl", "displaydoc", "nom 7.1.3", - "num-traits 0.2.17", + "num-traits 0.2.18", "rusticata-macros", "thiserror", "time", @@ -401,13 +401,13 @@ dependencies = [ [[package]] name = "async-channel" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ca33f4bc4ed1babef42cad36cc1f51fa88be00420404e5b1e80ab1b18f7678c" +checksum = "f28243a43d821d11341ab73c80bed182dc015c514b951616cf79bd4af39af0c3" dependencies = [ "concurrent-queue", - "event-listener 4.0.3", - "event-listener-strategy", + "event-listener 5.0.0", + "event-listener-strategy 0.5.0", "futures-core", "pin-project-lite", ] @@ -481,7 +481,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d034b430882f8381900d3fe6f0aaa3ad94f2cb4ac519b429692a1bc2dda4ae7b" dependencies = [ "event-listener 4.0.3", - "event-listener-strategy", + "event-listener-strategy 0.4.0", "pin-project-lite", ] @@ -807,7 +807,7 @@ checksum = "a6773ddc0eafc0e509fb60e48dff7f450f8e674a0686ae8605e8d9901bd5eefa" dependencies = [ "num-bigint", "num-integer", - "num-traits 0.2.17", + "num-traits 0.2.18", ] [[package]] @@ -1000,12 +1000,12 @@ version = "2.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ce21468c1c9c154a85696bb25c20582511438edb6ad67f846ba1378ffdd80222" dependencies = [ - "ahash 0.8.7", + "ahash 0.8.8", "base64 0.13.1", "bitvec", "chrono", "hex", - "indexmap 2.2.2", + "indexmap 2.2.3", "js-sys", "once_cell", "rand 0.8.5", @@ -1072,9 +1072,9 @@ dependencies = [ [[package]] name = "bytemuck" -version = "1.14.2" +version = "1.14.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ea31d69bda4949c1c1562c1e6f042a1caefac98cdc8a298260a2ff41c1e2d42b" +checksum = "a2ef034f05691a48569bd920a96c81b9d91bbad1ab5ac7c4616c1f6ef36cb79f" [[package]] name = "byteorder" @@ -1126,11 +1126,10 @@ dependencies = [ [[package]] name = "cc" -version = "1.0.83" +version = "1.0.85" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" +checksum = "9b918671670962b48bc23753aef0c51d072dca6f52f01f800854ada6ddb7f7d3" dependencies = [ - "jobserver", "libc", ] @@ -1157,14 +1156,14 @@ checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e" [[package]] name = "chrono" -version = "0.4.33" +version = "0.4.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f13690e35a5e4ace198e7beea2895d29f3a9cc55015fcebe6336bd2010af9eb" +checksum = "5bc015644b92d5890fab7489e49d21f879d5c990186827d42ec511919404f38b" dependencies = [ "android-tzdata", "iana-time-zone", "js-sys", - "num-traits 0.2.17", + "num-traits 0.2.18", "serde 1.0.196", "wasm-bindgen", "windows-targets 0.52.0", @@ -1360,14 +1359,14 @@ dependencies = [ "colored", "flate2", "ignore", - "indexmap 2.2.2", + "indexmap 2.2.3", "indoc", "itertools 0.11.0", "reqwest", "schemars", "serde 1.0.196", "serde_json", - "serde_with 3.6.0", + "serde_with 3.6.1", "tar", ] @@ -1567,9 +1566,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", ] @@ -1950,7 +1949,7 @@ dependencies = [ "glob", "hex", "import_map", - "indexmap 2.2.2", + "indexmap 2.2.3", "jsonc-parser", "junction", "lazy-regex", @@ -2068,7 +2067,7 @@ checksum = "2bbb245d9a3719b5eb2b5195aaaa25108c3c93d1762b181a20fb1af1c7703eaf" dependencies = [ "anyhow", "deno_media_type", - "indexmap 2.2.2", + "indexmap 2.2.3", "log", "once_cell", "parking_lot 0.12.1", @@ -2099,7 +2098,7 @@ checksum = "aca0a5b9d2693efb14c8c80d66a052464f24cbf6b3473648037e282c0c616917" dependencies = [ "anyhow", "glob", - "indexmap 2.2.2", + "indexmap 2.2.3", "jsonc-parser", "log", "percent-encoding", @@ -2176,7 +2175,7 @@ dependencies = [ "deno_core", "deno_web", "elliptic-curve", - "num-traits 0.2.17", + "num-traits 0.2.18", "once_cell", "p256", "p384", @@ -2210,7 +2209,7 @@ dependencies = [ "handlebars", "html-escape", "import_map", - "indexmap 2.2.2", + "indexmap 2.2.3", "lazy_static 1.4.0", "regex", "serde 1.0.196", @@ -2313,7 +2312,7 @@ dependencies = [ "deno_semver", "futures", "import_map", - "indexmap 2.2.2", + "indexmap 2.2.3", "log", "monch", "once_cell", @@ -2428,9 +2427,9 @@ dependencies = [ [[package]] name = "deno_lockfile" -version = "0.18.0" +version = "0.18.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfe06eda519ed05b69da567bcba1d728c482fd553ddaa2ffe008468158da6de0" +checksum = "9f348633cc4425b2a9011436e256b1ae8f6c8026ec2705d852baee8643dc5562" dependencies = [ "ring 0.17.7", "serde 1.0.196", @@ -2517,7 +2516,7 @@ dependencies = [ "hkdf", "http 0.2.11", "idna 0.3.0", - "indexmap 2.2.2", + "indexmap 2.2.3", "k256", "lazy-regex", "libc", @@ -2528,7 +2527,7 @@ dependencies = [ "num-bigint", "num-bigint-dig", "num-integer", - "num-traits 0.2.17", + "num-traits 0.2.18", "once_cell", "p224", "p256", @@ -2893,7 +2892,7 @@ dependencies = [ "displaydoc", "nom 7.1.3", "num-bigint", - "num-traits 0.2.17", + "num-traits 0.2.18", "rusticata-macros", ] @@ -3142,7 +3141,7 @@ checksum = "7227b28d24aafee21ff72512336c797fa00bb3ea803186b1b105a68abc97660b" dependencies = [ "anyhow", "bumpalo", - "indexmap 2.2.2", + "indexmap 2.2.3", "rustc-hash", "serde 1.0.196", "unicode-width", @@ -3225,7 +3224,7 @@ checksum = "48bc224a9084ad760195584ce5abb3c2c34a225fa312a128ad245a6b412b7689" dependencies = [ "digest 0.10.7", "num-bigint-dig", - "num-traits 0.2.17", + "num-traits 0.2.18", "pkcs8", "rfc6979", "sha2 0.10.8", @@ -3290,9 +3289,9 @@ dependencies = [ [[package]] name = "either" -version = "1.9.0" +version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" +checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a" [[package]] name = "elliptic-curve" @@ -3453,9 +3452,9 @@ dependencies = [ [[package]] name = "enumflags2" -version = "0.7.8" +version = "0.7.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5998b4f30320c9d93aed72f63af821bfdac50465b75428fce77b48ec482c3939" +checksum = "3278c9d5fb675e0a51dabcf4c0d355f692b064171535ba72361be1528a9d8e8d" dependencies = [ "enumflags2_derive", "serde 1.0.196", @@ -3463,9 +3462,9 @@ dependencies = [ [[package]] name = "enumflags2_derive" -version = "0.7.8" +version = "0.7.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f95e2801cd355d4a1a3e3953ce6ee5ae9603a5c833455343a8bfe3f44d418246" +checksum = "5c785274071b1b420972453b306eeca06acf4633829db4223b58a2a8c5953bc4" dependencies = [ "proc-macro2", "quote", @@ -3624,6 +3623,17 @@ dependencies = [ "pin-project-lite", ] +[[package]] +name = "event-listener" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b72557800024fabbaa2449dd4bf24e37b93702d457a4d4f2b0dd1f0f039f20c1" +dependencies = [ + "concurrent-queue", + "parking", + "pin-project-lite", +] + [[package]] name = "event-listener-strategy" version = "0.4.0" @@ -3634,6 +3644,16 @@ dependencies = [ "pin-project-lite", ] +[[package]] +name = "event-listener-strategy" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "feedafcaa9b749175d5ac357452a9d41ea2911da598fde46ce1fe02c37751291" +dependencies = [ + "event-listener 5.0.0", + "pin-project-lite", +] + [[package]] name = "failure" version = "0.1.8" @@ -3807,7 +3827,7 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4" dependencies = [ - "num-traits 0.2.17", + "num-traits 0.2.18", ] [[package]] @@ -4406,7 +4426,7 @@ dependencies = [ "futures-sink", "futures-util", "http 0.2.11", - "indexmap 2.2.2", + "indexmap 2.2.3", "slab", "tokio", "tokio-util 0.7.10", @@ -4425,7 +4445,7 @@ dependencies = [ "futures-sink", "futures-util", "http 1.0.0", - "indexmap 2.2.2", + "indexmap 2.2.3", "slab", "tokio", "tokio-util 0.7.10", @@ -4463,7 +4483,7 @@ version = "0.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e" dependencies = [ - "ahash 0.7.7", + "ahash 0.7.8", ] [[package]] @@ -4472,7 +4492,7 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" dependencies = [ - "ahash 0.7.7", + "ahash 0.7.8", ] [[package]] @@ -4481,7 +4501,7 @@ version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" dependencies = [ - "ahash 0.8.7", + "ahash 0.8.8", ] [[package]] @@ -4490,7 +4510,7 @@ version = "0.14.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604" dependencies = [ - "ahash 0.8.7", + "ahash 0.8.8", "allocator-api2", ] @@ -4575,6 +4595,29 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "hoot" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df22a4d90f1b0e65fe3e0d6ee6a4608cc4d81f4b2eb3e670f44bb6bde711e452" +dependencies = [ + "httparse", + "log", +] + +[[package]] +name = "hootbin" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "354e60868e49ea1a39c44b9562ad207c4259dc6eabf9863bf3b0f058c55cfdb2" +dependencies = [ + "fastrand 2.0.1", + "hoot", + "serde 1.0.196", + "serde_json", + "thiserror", +] + [[package]] name = "hostname" version = "0.3.1" @@ -4881,7 +4924,7 @@ dependencies = [ "bytemuck", "byteorder", "color_quant", - "num-traits 0.2.17", + "num-traits 0.2.18", "png", ] @@ -4891,7 +4934,7 @@ version = "0.18.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "556779a5de0289679854a5344c22f466698fd2661f7170db90df7fa5013b281e" dependencies = [ - "indexmap 2.2.2", + "indexmap 2.2.3", "log", "serde 1.0.196", "serde_json", @@ -4930,9 +4973,9 @@ dependencies = [ [[package]] name = "indexmap" -version = "2.2.2" +version = "2.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "824b2ae422412366ba479e8111fd301f7b5faece8149317bb81925979a53f520" +checksum = "233cf39063f058ea2caae4091bf4a3ef70a653afbc026f5c4a4135d114e3c177" dependencies = [ "equivalent", "hashbrown 0.14.3", @@ -4941,9 +4984,9 @@ dependencies = [ [[package]] name = "indicatif" -version = "0.17.7" +version = "0.17.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fb28741c9db9a713d93deb3bb9515c20788cef5815265bee4980e87bde7e0f25" +checksum = "763a5a8f45087d6bcea4222e7b72c291a054edf80e4ef6efd2a4979878c7bea3" dependencies = [ "console", "instant", @@ -5061,12 +5104,12 @@ dependencies = [ [[package]] name = "is-terminal" -version = "0.4.10" +version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bad00257d07be169d870ab665980b06cdb366d792ad690bf2e76876dc503455" +checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b" dependencies = [ "hermit-abi 0.3.5", - "rustix 0.38.31", + "libc", "windows-sys 0.52.0", ] @@ -5109,15 +5152,6 @@ version = "1.0.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c" -[[package]] -name = "jobserver" -version = "0.1.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c37f63953c4c63420ed5fd3d6d398c719489b9f872b9fa683262f8edd363c7d" -dependencies = [ - "libc", -] - [[package]] name = "js-sys" version = "0.3.68" @@ -5731,7 +5765,7 @@ dependencies = [ "grep", "ignore", "include_dir", - "indexmap 2.2.2", + "indexmap 2.2.3", "indoc", "insta", "itertools 0.11.0", @@ -5782,7 +5816,7 @@ version = "0.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2e52eb6380b6d2a10eb3434aec0885374490f5b82c8aaf5cd487a183c98be834" dependencies = [ - "ahash 0.7.7", + "ahash 0.7.8", "metrics-macros", ] @@ -5792,7 +5826,7 @@ version = "0.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "142c53885123b68d94108295a09d4afe1a1388ed95b54d5dacd9a454753030f2" dependencies = [ - "ahash 0.7.7", + "ahash 0.7.8", "metrics-macros", ] @@ -5924,9 +5958,9 @@ checksum = "b52c1b33ff98142aecea13138bd399b68aa7ab5d9546c300988c345004001eea" [[package]] name = "mongodb" -version = "2.8.0" +version = "2.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46c30763a5c6c52079602be44fa360ca3bfacee55fca73f4734aecd23706a7f2" +checksum = "de59562e5c71656c098d8e966641b31da87b89dc3dcb6e761d3b37dcdfa0cb72" dependencies = [ "async-trait", "base64 0.13.1", @@ -6064,7 +6098,7 @@ checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a" [[package]] name = "mysql_async" version = "0.31.3" -source = "git+https://github.com/prisma/mysql_async?branch=vendored-openssl#dad187b50dc7e8ce2b61fec126822e8e172a9c8a" +source = "git+https://github.com/prisma/mysql_async?branch=vendored-openssl#d8ffc297874bf4b12ce8387c4a01836b52fd3216" dependencies = [ "bytes", "crossbeam", @@ -6114,7 +6148,7 @@ dependencies = [ "lazy_static 1.4.0", "lexical", "num-bigint", - "num-traits 0.2.17", + "num-traits 0.2.18", "rand 0.8.5", "regex", "rust_decimal", @@ -6140,9 +6174,9 @@ dependencies = [ "bitflags 2.4.2", "codespan-reporting", "hexf-parse", - "indexmap 2.2.2", + "indexmap 2.2.3", "log", - "num-traits 0.2.17", + "num-traits 0.2.18", "rustc-hash", "serde 1.0.196", "spirv", @@ -6353,7 +6387,7 @@ dependencies = [ "num-integer", "num-iter", "num-rational", - "num-traits 0.2.17", + "num-traits 0.2.18", ] [[package]] @@ -6364,7 +6398,7 @@ checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0" dependencies = [ "autocfg", "num-integer", - "num-traits 0.2.17", + "num-traits 0.2.18", "rand 0.8.5", "serde 1.0.196", ] @@ -6380,7 +6414,7 @@ dependencies = [ "libm", "num-integer", "num-iter", - "num-traits 0.2.17", + "num-traits 0.2.18", "rand 0.8.5", "serde 1.0.196", "smallvec", @@ -6393,7 +6427,7 @@ version = "0.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23c6602fda94a57c990fe0df199a035d83576b496aa29f4e634a8ac6004e68a6" dependencies = [ - "num-traits 0.2.17", + "num-traits 0.2.18", ] [[package]] @@ -6426,23 +6460,22 @@ dependencies = [ [[package]] name = "num-integer" -version = "0.1.45" +version = "0.1.46" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" dependencies = [ - "autocfg", - "num-traits 0.2.17", + "num-traits 0.2.18", ] [[package]] name = "num-iter" -version = "0.1.43" +version = "0.1.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252" +checksum = "d869c01cc0c455284163fd0092f1f93835385ccab5a98a0dcc497b2f8bf055a9" dependencies = [ "autocfg", "num-integer", - "num-traits 0.2.17", + "num-traits 0.2.18", ] [[package]] @@ -6454,7 +6487,7 @@ dependencies = [ "autocfg", "num-bigint", "num-integer", - "num-traits 0.2.17", + "num-traits 0.2.18", ] [[package]] @@ -6463,14 +6496,14 @@ version = "0.1.43" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92e5113e9fd4cc14ded8e499429f396a20f98c772a47cc8622a736e1ec843c31" dependencies = [ - "num-traits 0.2.17", + "num-traits 0.2.18", ] [[package]] name = "num-traits" -version = "0.2.17" +version = "0.2.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c" +checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a" dependencies = [ "autocfg", "libm", @@ -6584,9 +6617,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", ] @@ -6698,7 +6731,7 @@ version = "2.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c" dependencies = [ - "num-traits 0.2.17", + "num-traits 0.2.18", ] [[package]] @@ -7016,7 +7049,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9" dependencies = [ "fixedbitset 0.4.2", - "indexmap 2.2.2", + "indexmap 2.2.3", ] [[package]] @@ -7774,7 +7807,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1b9599bffc2cd7511355996e0cfd979266b2cfa3f3ff5247d07a3a6e1ded6158" dependencies = [ "chrono", - "indexmap 2.2.2", + "indexmap 2.2.3", "nextest-workspace-hack", "quick-xml 0.31.0", "strip-ansi-escapes", @@ -8233,7 +8266,7 @@ dependencies = [ "digest 0.10.7", "num-bigint-dig", "num-integer", - "num-traits 0.2.17", + "num-traits 0.2.18", "pkcs1", "pkcs8", "rand_core 0.6.4", @@ -8276,14 +8309,14 @@ dependencies = [ [[package]] name = "rust_decimal" -version = "1.34.2" +version = "1.34.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "755392e1a2f77afd95580d3f0d0e94ac83eeeb7167552c9b5bca549e61a94d83" +checksum = "b39449a79f45e8da28c57c341891b69a183044b29518bb8f86dbac9df60bb7df" dependencies = [ "arrayvec 0.7.4", "borsh", "bytes", - "num-traits 0.2.17", + "num-traits 0.2.18", "rand 0.8.5", "rkyv", "serde 1.0.196", @@ -8597,7 +8630,7 @@ checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29" dependencies = [ "dyn-clone", "indexmap 1.9.3", - "indexmap 2.2.2", + "indexmap 2.2.3", "schemars_derive", "serde 1.0.196", "serde_json", @@ -8941,7 +8974,7 @@ version = "1.0.113" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69801b70b1c3dac963ecb03a364ba0ceda9cf60c71cfe475e99864759c8b8a79" dependencies = [ - "indexmap 2.2.2", + "indexmap 2.2.3", "itoa", "ryu", "serde 1.0.196", @@ -9006,18 +9039,19 @@ dependencies = [ [[package]] name = "serde_with" -version = "3.6.0" +version = "3.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b0ed1662c5a68664f45b76d18deb0e234aff37207086803165c961eb695e981" +checksum = "15d167997bd841ec232f5b2b8e0e26606df2e7caa4c31b95ea9ca52b200bd270" dependencies = [ "base64 0.21.7", "chrono", "hex", "indexmap 1.9.3", - "indexmap 2.2.2", + "indexmap 2.2.3", "serde 1.0.196", + "serde_derive", "serde_json", - "serde_with_macros 3.6.0", + "serde_with_macros 3.6.1", "time", ] @@ -9035,9 +9069,9 @@ dependencies = [ [[package]] name = "serde_with_macros" -version = "3.6.0" +version = "3.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "568577ff0ef47b879f736cd66740e022f3672788cdf002a05a4e609ea5a6fb15" +checksum = "865f9743393e638991566a8b7a479043c2c8da94a33e0a31f18214c9cae0a64d" dependencies = [ "darling 0.20.5", "proc-macro2", @@ -9051,7 +9085,7 @@ version = "0.9.31" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "adf8a49373e98a4c5f0ceb5d05aa7c648d75f63774981ed95b7c7443bbd50c6e" dependencies = [ - "indexmap 2.2.2", + "indexmap 2.2.3", "itoa", "ryu", "serde 1.0.196", @@ -9372,7 +9406,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "246bfa38fe3db3f1dfc8ca5a2cdeb7348c78be2112740cc0ec8ef18b6d94f830" dependencies = [ "bitflags 1.3.2", - "num-traits 0.2.17", + "num-traits 0.2.18", ] [[package]] @@ -9609,7 +9643,7 @@ checksum = "4d7530df85b1a56f6a879ca102dc59718db4bcd6bfff55fb8bb379fbeab6c88c" dependencies = [ "anyhow", "crc", - "indexmap 2.2.2", + "indexmap 2.2.3", "is-macro", "once_cell", "parking_lot 0.12.1", @@ -9665,7 +9699,7 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "112884e66b60e614c0f416138b91b8b82b7fea6ed0ecc5e26bad4726c57a6c99" dependencies = [ - "indexmap 2.2.2", + "indexmap 2.2.3", "serde 1.0.196", "serde_json", "swc_config_macro", @@ -9766,7 +9800,7 @@ dependencies = [ "either", "new_debug_unreachable", "num-bigint", - "num-traits 0.2.17", + "num-traits 0.2.18", "phf", "serde 1.0.196", "smallvec", @@ -9787,7 +9821,7 @@ checksum = "6d4ab26ec124b03e47f54d4daade8e9a9dcd66d3a4ca3cd47045f138d267a60e" dependencies = [ "better_scoped_tls", "bitflags 2.4.2", - "indexmap 2.2.2", + "indexmap 2.2.3", "once_cell", "phf", "rustc-hash", @@ -9835,7 +9869,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fec185cf4d18e90b7c8b18b0d1f04a5707e6f4c7b57c1bfd5086392cd07b75a9" dependencies = [ "dashmap", - "indexmap 2.2.2", + "indexmap 2.2.3", "once_cell", "petgraph 0.6.4", "rustc-hash", @@ -9880,7 +9914,7 @@ checksum = "e31a2f879fd21d18080b6c42e633e0ae8c6f3d54b83c1de876767d82b458c999" dependencies = [ "base64 0.21.7", "dashmap", - "indexmap 2.2.2", + "indexmap 2.2.3", "once_cell", "serde 1.0.196", "sha-1", @@ -9919,7 +9953,7 @@ version = "0.125.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7cead1083e46b0f072a82938f16d366014468f7510350957765bb4d013496890" dependencies = [ - "indexmap 2.2.2", + "indexmap 2.2.3", "num_cpus", "once_cell", "rustc-hash", @@ -9962,7 +9996,7 @@ version = "0.21.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8acfc056067a0fbfe26a4763c1eb246e813fdbe6b376415d07915e96e15481b6" dependencies = [ - "indexmap 2.2.2", + "indexmap 2.2.3", "petgraph 0.6.4", "rustc-hash", "swc_common", @@ -10192,18 +10226,18 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.56" +version = "1.0.57" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d54378c645627613241d077a3a79db965db602882668f9136ac42af9ecb730ad" +checksum = "1e45bcbe8ed29775f228095caf2cd67af7a4ccf756ebff23a306bf3e8b47b24b" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.56" +version = "1.0.57" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa0faa943b50f3db30a20aa7e265dbc66076993efed8463e8de414e5d06d3471" +checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81" dependencies = [ "proc-macro2", "quote", @@ -10239,7 +10273,7 @@ dependencies = [ "futures", "futures-sink", "futures-util", - "num-traits 0.2.17", + "num-traits 0.2.18", "once_cell", "opentls", "pin-project-lite", @@ -10525,7 +10559,7 @@ version = "0.21.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1" dependencies = [ - "indexmap 2.2.2", + "indexmap 2.2.3", "toml_datetime", "winnow", ] @@ -10536,7 +10570,7 @@ version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0c9ffdf896f8daaabf9b66ba8e77ea1ed5ed0f72821b398aba62352e95062951" dependencies = [ - "indexmap 2.2.2", + "indexmap 2.2.3", "serde 1.0.196", "serde_spanned", "toml_datetime", @@ -11019,7 +11053,7 @@ dependencies = [ "log", "mt_deno", "num-derive 0.4.2", - "num-traits 0.2.17", + "num-traits 0.2.18", "once_cell", "prisma-models", "psl", @@ -11052,7 +11086,7 @@ dependencies = [ "common", "enum_dispatch", "graphql-parser 0.4.0", - "indexmap 2.2.2", + "indexmap 2.2.3", "indoc", "insta", "once_cell", @@ -11314,11 +11348,12 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "ureq" -version = "2.9.1" +version = "2.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8cdd25c339e200129fe4de81451814e5228c9b771d57378817d6117cc2b3f97" +checksum = "0b52731d03d6bb2fd18289d4028aee361d6c28d44977846793b994b13cdcc64d" dependencies = [ "base64 0.21.7", + "hootbin", "log", "native-tls", "once_cell", @@ -11411,9 +11446,9 @@ dependencies = [ [[package]] name = "v8" -version = "0.83.1" +version = "0.83.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "546dcbb978f58aea3ad9286bd1df553f4ab7bbdc2e191cd4ae6c9a98fa95d1cd" +checksum = "9f6c8a960dd2eb74b22eda64f7e9f3d1688f82b80202828dc0425ebdeda826ef" dependencies = [ "bitflags 2.4.2", "fslock", @@ -11614,27 +11649,27 @@ dependencies = [ [[package]] name = "wasm-encoder" -version = "0.41.0" +version = "0.41.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e09bca7d6388637d27fb5edbeab11f56bfabcef8743c55ae34370e1e5030a071" +checksum = "972f97a5d8318f908dded23594188a90bcd09365986b1163e66d70170e5287ae" dependencies = [ "leb128", ] [[package]] name = "wasm-metadata" -version = "0.10.17" +version = "0.10.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c853d3809fc9fccf3bc0ad63f4f51d8eefad0bacf88f957aa991c1d9b88b016e" +checksum = "18ebaa7bd0f9e7a5e5dd29b9a998acf21c4abed74265524dd7e85934597bfb10" dependencies = [ "anyhow", - "indexmap 2.2.2", + "indexmap 2.2.3", "serde 1.0.196", "serde_derive", "serde_json", "spdx", - "wasm-encoder 0.41.0", - "wasmparser 0.121.0", + "wasm-encoder 0.41.2", + "wasmparser 0.121.2", ] [[package]] @@ -11670,7 +11705,7 @@ dependencies = [ "anyhow", "cfg-if", "num-derive 0.3.3", - "num-traits 0.2.17", + "num-traits 0.2.18", "thiserror", "wasmedge-macro", "wasmedge-sys", @@ -11720,39 +11755,39 @@ version = "0.113.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "286049849b5a5bd09a8773171be96824afabffc7cc3df6caaf33a38db6cd07ae" dependencies = [ - "indexmap 2.2.2", + "indexmap 2.2.3", "semver 1.0.21", ] [[package]] name = "wasmparser" -version = "0.121.0" +version = "0.121.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "953cf6a7606ab31382cb1caa5ae403e77ba70c7f8e12eeda167e7040d42bfda8" +checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab" dependencies = [ "bitflags 2.4.2", - "indexmap 2.2.2", + "indexmap 2.2.3", "semver 1.0.21", ] [[package]] name = "wast" -version = "70.0.2" +version = "71.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3d5061300042ff5065123dae1e27d00c03f567d34a2937c8472255148a216dc" +checksum = "647c3ac4354da32688537e8fc4d2fe6c578df51896298cb64727d98088a1fd26" dependencies = [ "bumpalo", "leb128", "memchr", "unicode-width", - "wasm-encoder 0.41.0", + "wasm-encoder 0.41.2", ] [[package]] name = "wat" -version = "1.0.85" +version = "1.0.88" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "afd7357b6cc46d46a2509c43dcb1dd4131dafbf4e75562d87017b5a05ffad2d6" +checksum = "b69c36f634411568a2c6d24828b674961e37ea03340fe1d605c337ed8162d901" dependencies = [ "wast", ] @@ -12108,9 +12143,9 @@ checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04" [[package]] name = "winnow" -version = "0.5.39" +version = "0.5.40" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5389a154b01683d28c77f8f68f49dea75f0a4da32557a58f68ee51ebba472d29" +checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876" dependencies = [ "memchr", ] @@ -12202,7 +12237,7 @@ checksum = "66981fe851118de3b6b7a92f51ce8a86b919569c37becbeca8df9bd30141da25" dependencies = [ "anyhow", "bitflags 2.4.2", - "indexmap 2.2.2", + "indexmap 2.2.3", "log", "serde 1.0.196", "serde_json", @@ -12220,7 +12255,7 @@ checksum = "a39edca9abb16309def3843af73b58d47d243fe33a9ceee572446bcc57556b9a" dependencies = [ "anyhow", "id-arena", - "indexmap 2.2.2", + "indexmap 2.2.3", "log", "pulldown-cmark", "semver 1.0.21", @@ -12367,7 +12402,7 @@ dependencies = [ "futures-task", "futures-util", "log", - "num-traits 0.2.17", + "num-traits 0.2.18", "once_cell", "parking_lot 0.12.1", "rand 0.8.5", diff --git a/libs/common/src/typegraph/types.rs b/libs/common/src/typegraph/types.rs index 5adafe315..575df5867 100644 --- a/libs/common/src/typegraph/types.rs +++ b/libs/common/src/typegraph/types.rs @@ -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, diff --git a/libs/common/src/typegraph/validator.rs b/libs/common/src/typegraph/validator.rs index aa7c978f0..36e2a8e43 100644 --- a/libs/common/src/typegraph/validator.rs +++ b/libs/common/src/typegraph/validator.rs @@ -1,16 +1,16 @@ // Copyright Metatype OÜ, licensed under the Elastic License 2.0. // SPDX-License-Identifier: Elastic-2.0 -use std::collections::HashSet; +mod input; +mod types; +mod value; use crate::typegraph::{TypeNode, Typegraph}; -use anyhow::{anyhow, bail, Result}; use serde_json::Value; use super::{ visitor::{CurrentNode, Path, PathSegment, TypeVisitor, TypeVisitorContext, VisitResult}, - EitherTypeData, FloatTypeData, Injection, IntegerTypeData, ListTypeData, ObjectTypeData, - StringTypeData, UnionTypeData, + EitherTypeData, Injection, UnionTypeData, }; pub fn validate_typegraph(tg: &Typegraph) -> Vec { @@ -44,10 +44,6 @@ impl Validator { } } -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 { @@ -216,255 +212,3 @@ impl<'a> TypeVisitor<'a> for Validator { Some(self.errors) } } - -// TODO validation path -impl Typegraph { - fn validate_value(&self, type_idx: u32, value: &Value) -> Result<()> { - let type_node = &self.types[type_idx as usize]; - - match type_node { - TypeNode::Any { .. } => Ok(()), - TypeNode::Integer { data, .. } => self.validate_integer(data, value), - TypeNode::Float { data, .. } => self.validate_float(data, value), - TypeNode::Boolean { .. } => value.as_bool().map(|_| ()).ok_or_else(|| { - anyhow!("Expected a boolean got '{value}'", value = to_string(value)) - }), - TypeNode::String { data, .. } => self.validate_string(data, value), - TypeNode::File { .. } => bail!("Literal file not supported"), - TypeNode::Optional { data, .. } => { - if value.is_null() { - Ok(()) - } else { - self.validate_value(data.item, value) - } - } - TypeNode::List { data, .. } => self.validate_array(data, value), - TypeNode::Object { data, .. } => self.validate_object(data, value), - TypeNode::Function { .. } => Err(anyhow!("Unexpected function type")), - TypeNode::Union { data, .. } => self.validate_union(data, value), - TypeNode::Either { data, .. } => self.validate_either(data, value), - } - } - - fn validate_integer(&self, data: &IntegerTypeData, value: &Value) -> Result<()> { - let Value::Number(n) = value else { - bail!("Expected number got '{}'", to_string(value)); - }; - let Some(value) = n.as_i64().map(|value| value.try_into()).transpose()? else { - bail!("Number value {value:?} cannot be stored in f64"); - }; - if let Some(min) = data.minimum { - number_validator::expect_min(min, value)?; - } - if let Some(max) = data.maximum { - number_validator::expect_max(max, value)?; - } - if let Some(xmin) = data.exclusive_minimum { - number_validator::expect_xmin(xmin, value)?; - } - if let Some(xmax) = data.exclusive_maximum { - number_validator::expect_xmax(xmax, value)?; - } - if let Some(divisor) = data.multiple_of.as_ref() { - if value % divisor == 0 { - bail!("Expected a multiple of {divisor}, got {value}"); - } - } - Ok(()) - } - - fn validate_float(&self, data: &FloatTypeData, value: &Value) -> Result<()> { - let Value::Number(n) = value else { - bail!("Expected float got '{}'", to_string(value)); - }; - let Some(value) = n.as_f64() else { - bail!("Float value {value:?} cannot be stored in f64"); - }; - if let Some(min) = data.minimum { - number_validator::expect_min(min, value)?; - } - if let Some(max) = data.maximum { - number_validator::expect_max(max, value)?; - } - if let Some(xmin) = data.exclusive_minimum { - number_validator::expect_xmin(xmin, value)?; - } - if let Some(xmax) = data.exclusive_maximum { - number_validator::expect_xmax(xmax, value)?; - } - if let Some(divisor) = data.multiple_of.as_ref() { - let quot = value / divisor; - if quot.round() != quot { - bail!("Expected a multiple of {divisor}, got {value}"); - } - } - Ok(()) - } - - fn validate_string(&self, data: &StringTypeData, value: &Value) -> Result<()> { - let s = value - .as_str() - .ok_or_else(|| anyhow!("Expected a string, got '{}'", to_string(value)))?; - if let Some(min_length) = data.min_length { - if s.len() < min_length as usize { - bail!( - "Expected a minimum length of {min_length}, got {s:?} (len={})", - s.len() - ); - } - } - if let Some(max_length) = data.max_length { - if s.len() > max_length as usize { - bail!( - "Expected a maximun length of {max_length}, got {s:?} (len={})", - s.len() - ); - } - } - // TODO pattern, format - Ok(()) - } - - fn validate_array(&self, data: &ListTypeData, value: &Value) -> Result<()> { - let array = value - .as_array() - .ok_or_else(|| anyhow!("Expected an array got '{}'", to_string(value)))?; - - if let Some(max_items) = data.max_items { - if array.len() > max_items as usize { - bail!( - "Expected a maximum item count of {max_items} in array '{arr}' (len={})", - array.len(), - arr = to_string(value), - ); - } - } - - if let Some(min_items) = data.min_items { - if array.len() < min_items as usize { - bail!( - "Expected a minimum item count of {min_items} in array '{arr}' (len={})", - array.len(), - arr = to_string(value), - ); - } - } - - for item in array { - self.validate_value(data.items, item)?; - } - Ok(()) - } - - fn validate_object(&self, data: &ObjectTypeData, value: &Value) -> Result<()> { - let object = value.as_object().ok_or_else(|| { - anyhow!( - "Expected an object, got '{value}'", - value = to_string(value) - ) - })?; - - let mut remaining_keys = object.keys().collect::>(); - for (key, typ) in data.properties.iter() { - match object.get(key) { - None => { - if !matches!(self.types[*typ as usize], TypeNode::Optional { .. }) { - bail!( - "Required field {key:?} not found in object '{value}'", - value = to_string(value) - ); - } - } - Some(val) => { - self.validate_value(*typ, val)?; - remaining_keys.remove(key); - } - } - } - - // additional properties? - if !remaining_keys.is_empty() { - bail!( - "Unexpected fields {} in object {:?}", - remaining_keys - .iter() - .map(|k| format!("{k:?}")) - .collect::>() - .join(", "), - to_string(value), - ); - } - - Ok(()) - } - - fn validate_union(&self, data: &UnionTypeData, value: &Value) -> Result<()> { - for &variant in data.any_of.iter() { - if self.validate_value(variant, value).is_ok() { - return Ok(()); - } - } - bail!( - "Value '{value}' did not match any of the variants of the union", - value = to_string(value) - ); - } - - fn validate_either(&self, data: &EitherTypeData, value: &Value) -> Result<()> { - let mut valid_variants = vec![]; - for &variant in data.one_of.iter() { - if self.validate_value(variant, value).is_ok() { - valid_variants.push(variant); - } - } - match valid_variants.len() { - 0 => bail!( - "Value '{value}' did not match any of the variants of the either", - value = to_string(value) - ), - 1 => Ok(()), - _ => bail!( - "Value '{value}' matched to more than one variant onf the either: {}", - valid_variants - .iter() - .map(|v| format!("#{v}")) - .collect::>() - .join(", "), - value = to_string(value) - ), - } - } -} - -mod number_validator { - use anyhow::{bail, Result}; - use std::fmt::Display; - - pub fn expect_min(min: T, value: T) -> Result<()> { - if value < min { - bail!("Expected a minimum value of {min}, got {value}"); - } - Ok(()) - } - - pub fn expect_max(max: T, value: T) -> Result<()> { - if value > max { - bail!("Expected a maximum value of {max}, got {value}"); - } - Ok(()) - } - - pub fn expect_xmin(xmin: T, value: T) -> Result<()> { - if value <= xmin { - bail!("Expected an exclusive minimum value of {xmin}, got {value}"); - } - Ok(()) - } - - pub fn expect_xmax(xmax: T, value: T) -> Result<()> { - if value >= xmax { - bail!("Expected an exclusive maximum value of {xmax}, got {value}"); - } - 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..dd4928098 --- /dev/null +++ b/libs/common/src/typegraph/validator/input.rs @@ -0,0 +1,117 @@ +// 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, Path, PathSegment, TypeVisitor, TypeVisitorContext, VisitResult}, + Injection, TypeNode, Typegraph, +}; + +use super::types::{EnsureSubtypeOf, ErrorCollector, ExtendedTypeNode}; + +#[derive(Debug)] +pub struct InputValidationError { + path: String, // param_path != fn_path + message: String, +} + +pub struct InputValidationContext<'a> { + typegraph: &'a Typegraph, + fn_path: String, + fn_idx: u32, + parent_struct_idx: u32, +} + +impl TypeVisitorContext for InputValidationContext<'_> { + fn get_typegraph(&self) -> &Typegraph { + self.typegraph + } +} + +pub struct InputValidator { + errors: Vec, +} + +impl InputValidator { + fn push_error(&mut self, path: &[PathSegment], message: impl Into) { + self.errors.push(InputValidationError { + path: Path(path).to_string(), + message: message.into(), + }); + } +} + +impl<'a> TypeVisitor<'a> for InputValidator { + type Return = Vec; + type Context = InputValidationContext<'a>; + + fn visit( + &mut self, + current_node: CurrentNode<'_>, + context: &Self::Context, + ) -> VisitResult { + 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); + } + + return VisitResult::Continue(true); + } +} + +impl InputValidator { + fn validate_injection( + &mut self, + injection: &Injection, + current_node: CurrentNode<'_>, + context: &InputValidationContext<'_>, + ) { + 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) => { + // TODO match type to parent type + } + _ => (), + } + } + + fn validate_parent_injection( + &mut self, + source_idx: u32, + current_node: CurrentNode<'_>, + context: &InputValidationContext<'_>, + ) { + 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); + } +} diff --git a/libs/common/src/typegraph/validator/types.rs b/libs/common/src/typegraph/validator/types.rs new file mode 100644 index 000000000..6c5614c6b --- /dev/null +++ b/libs/common/src/typegraph/validator/types.rs @@ -0,0 +1,367 @@ +// 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::{any::Any, 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 { + errors: Vec, +} + +impl ErrorCollector { + fn single_error(message: impl Into) -> Self { + ErrorCollector { + errors: vec![message.into()], + } + } + + 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: &IntegerTypeData, + 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: &FloatTypeData, 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: &StringTypeData, 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: &FileTypeData, 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: &ObjectTypeData, 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 error_collector = ErrorCollector::default(); + let mut found = false; + for sup_idx in sup.0 { + let sup_type = ExtendedTypeNode::new(typegraph, *sup_idx); + + 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::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 { .. }, _) | (_, TypeNode::Function { .. }) => { + errors.push("Function types are not supported"); + } + _ => errors.push("Type mismatch"), + } + } + } +} diff --git a/libs/common/src/typegraph/validator/value.rs b/libs/common/src/typegraph/validator/value.rs new file mode 100644 index 000000000..dc9527ce4 --- /dev/null +++ b/libs/common/src/typegraph/validator/value.rs @@ -0,0 +1,268 @@ +// Copyright Metatype OÜ, licensed under the Elastic License 2.0. +// SPDX-License-Identifier: Elastic-2.0 + +use std::collections::HashSet; + +use anyhow::{anyhow, bail, Result}; +use serde_json::Value; + +use crate::typegraph::{ + EitherTypeData, FloatTypeData, IntegerTypeData, ListTypeData, ObjectTypeData, StringTypeData, + TypeNode, Typegraph, UnionTypeData, +}; + +fn to_string(value: &Value) -> String { + serde_json::to_string(value).unwrap() +} + +// TODO validation path +impl Typegraph { + pub fn validate_value(&self, type_idx: u32, value: &Value) -> Result<()> { + let type_node = &self.types[type_idx as usize]; + + match type_node { + TypeNode::Any { .. } => Ok(()), + TypeNode::Integer { data, .. } => self.validate_integer(data, value), + TypeNode::Float { data, .. } => self.validate_float(data, value), + TypeNode::Boolean { .. } => value.as_bool().map(|_| ()).ok_or_else(|| { + anyhow!("Expected a boolean got '{value}'", value = to_string(value)) + }), + TypeNode::String { data, .. } => self.validate_string(data, value), + TypeNode::File { .. } => bail!("Literal file not supported"), + TypeNode::Optional { data, .. } => { + if value.is_null() { + Ok(()) + } else { + self.validate_value(data.item, value) + } + } + TypeNode::List { data, .. } => self.validate_array(data, value), + TypeNode::Object { data, .. } => self.validate_object(data, value), + TypeNode::Function { .. } => Err(anyhow!("Unexpected function type")), + TypeNode::Union { data, .. } => self.validate_union(data, value), + TypeNode::Either { data, .. } => self.validate_either(data, value), + } + } + + fn validate_integer(&self, data: &IntegerTypeData, value: &Value) -> Result<()> { + let Value::Number(n) = value else { + bail!("Expected number got '{}'", to_string(value)); + }; + let Some(value) = n.as_i64().map(|value| value.try_into()).transpose()? else { + bail!("Number value {value:?} cannot be stored in f64"); + }; + if let Some(min) = data.minimum { + number_validator::expect_min(min, value)?; + } + if let Some(max) = data.maximum { + number_validator::expect_max(max, value)?; + } + if let Some(xmin) = data.exclusive_minimum { + number_validator::expect_xmin(xmin, value)?; + } + if let Some(xmax) = data.exclusive_maximum { + number_validator::expect_xmax(xmax, value)?; + } + if let Some(divisor) = data.multiple_of.as_ref() { + if value % divisor == 0 { + bail!("Expected a multiple of {divisor}, got {value}"); + } + } + Ok(()) + } + + fn validate_float(&self, data: &FloatTypeData, value: &Value) -> Result<()> { + let Value::Number(n) = value else { + bail!("Expected float got '{}'", to_string(value)); + }; + let Some(value) = n.as_f64() else { + bail!("Float value {value:?} cannot be stored in f64"); + }; + if let Some(min) = data.minimum { + number_validator::expect_min(min, value)?; + } + if let Some(max) = data.maximum { + number_validator::expect_max(max, value)?; + } + if let Some(xmin) = data.exclusive_minimum { + number_validator::expect_xmin(xmin, value)?; + } + if let Some(xmax) = data.exclusive_maximum { + number_validator::expect_xmax(xmax, value)?; + } + if let Some(divisor) = data.multiple_of.as_ref() { + let quot = value / divisor; + if quot.round() != quot { + bail!("Expected a multiple of {divisor}, got {value}"); + } + } + Ok(()) + } + + fn validate_string(&self, data: &StringTypeData, value: &Value) -> Result<()> { + let s = value + .as_str() + .ok_or_else(|| anyhow!("Expected a string, got '{}'", to_string(value)))?; + if let Some(min_length) = data.min_length { + if s.len() < min_length as usize { + bail!( + "Expected a minimum length of {min_length}, got {s:?} (len={})", + s.len() + ); + } + } + if let Some(max_length) = data.max_length { + if s.len() > max_length as usize { + bail!( + "Expected a maximun length of {max_length}, got {s:?} (len={})", + s.len() + ); + } + } + // TODO pattern, format + Ok(()) + } + + fn validate_array(&self, data: &ListTypeData, value: &Value) -> Result<()> { + let array = value + .as_array() + .ok_or_else(|| anyhow!("Expected an array got '{}'", to_string(value)))?; + + if let Some(max_items) = data.max_items { + if array.len() > max_items as usize { + bail!( + "Expected a maximum item count of {max_items} in array '{arr}' (len={})", + array.len(), + arr = to_string(value), + ); + } + } + + if let Some(min_items) = data.min_items { + if array.len() < min_items as usize { + bail!( + "Expected a minimum item count of {min_items} in array '{arr}' (len={})", + array.len(), + arr = to_string(value), + ); + } + } + + for item in array { + self.validate_value(data.items, item)?; + } + Ok(()) + } + + fn validate_object(&self, data: &ObjectTypeData, value: &Value) -> Result<()> { + let object = value.as_object().ok_or_else(|| { + anyhow!( + "Expected an object, got '{value}'", + value = to_string(value) + ) + })?; + + let mut remaining_keys = object.keys().collect::>(); + for (key, typ) in data.properties.iter() { + match object.get(key) { + None => { + if !matches!(self.types[*typ as usize], TypeNode::Optional { .. }) { + bail!( + "Required field {key:?} not found in object '{value}'", + value = to_string(value) + ); + } + } + Some(val) => { + self.validate_value(*typ, val)?; + remaining_keys.remove(key); + } + } + } + + // additional properties? + if !remaining_keys.is_empty() { + bail!( + "Unexpected fields {} in object {:?}", + remaining_keys + .iter() + .map(|k| format!("{k:?}")) + .collect::>() + .join(", "), + to_string(value), + ); + } + + Ok(()) + } + + fn validate_union(&self, data: &UnionTypeData, value: &Value) -> Result<()> { + for &variant in data.any_of.iter() { + if self.validate_value(variant, value).is_ok() { + return Ok(()); + } + } + bail!( + "Value '{value}' did not match any of the variants of the union", + value = to_string(value) + ); + } + + fn validate_either(&self, data: &EitherTypeData, value: &Value) -> Result<()> { + let mut valid_variants = vec![]; + for &variant in data.one_of.iter() { + if self.validate_value(variant, value).is_ok() { + valid_variants.push(variant); + } + } + match valid_variants.len() { + 0 => bail!( + "Value '{value}' did not match any of the variants of the either", + value = to_string(value) + ), + 1 => Ok(()), + _ => bail!( + "Value '{value}' matched to more than one variant onf the either: {}", + valid_variants + .iter() + .map(|v| format!("#{v}")) + .collect::>() + .join(", "), + value = to_string(value) + ), + } + } +} + +mod number_validator { + use anyhow::{bail, Result}; + use std::fmt::Display; + + pub fn expect_min(min: T, value: T) -> Result<()> { + if value < min { + bail!("Expected a minimum value of {min}, got {value}"); + } + Ok(()) + } + + pub fn expect_max(max: T, value: T) -> Result<()> { + if value > max { + bail!("Expected a maximum value of {max}, got {value}"); + } + Ok(()) + } + + pub fn expect_xmin(xmin: T, value: T) -> Result<()> { + if value <= xmin { + bail!("Expected an exclusive minimum value of {xmin}, got {value}"); + } + Ok(()) + } + + pub fn expect_xmax(xmax: T, value: T) -> Result<()> { + if value >= xmax { + bail!("Expected an exclusive maximum value of {xmax}, got {value}"); + } + Ok(()) + } +} diff --git a/typegate/src/engine/planner/parameter_transformer.ts b/typegate/src/engine/planner/parameter_transformer.ts index 164ec06eb..4082eaaa7 100644 --- a/typegate/src/engine/planner/parameter_transformer.ts +++ b/typegate/src/engine/planner/parameter_transformer.ts @@ -158,7 +158,6 @@ class TransformerCompilationContext { } #compileContextInjection(typeIdx: number, key: string) { - // TODO type validation ? const varName = this.#createVarName(); let typeNode = this.#tg.type(typeIdx); let optional = false; @@ -232,24 +231,24 @@ class TransformerCompilationContext { 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, this.#path.join(".")), + ...generateStringValidator(typeNode, varName, path), ); break; case Type.INTEGER: case Type.FLOAT: this.#collector.push( - ...generateNumberValidator(typeNode, varName, this.#path.join(".")), + ...generateNumberValidator(typeNode, varName, path), ); break; default: // TODO optional?? throw new Error( - `At "${ - this.#path.join(".") - }": Unsupported type "${typeNode.type}" for secret injection`, + `At "${path}": Unsupported type "${typeNode.type}" for secret injection`, ); } @@ -257,7 +256,8 @@ class TransformerCompilationContext { } #compileParentInjection(_typeIdx: number, parentIdx: number) { - // TODO type validation ? + // TODO type validation ?: the source is validated in the arg computation step; + // type inclusion 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)!; From 5d4875f63c146a560d9706dd2a9ccac8a324863d Mon Sep 17 00:00:00 2001 From: Natoandro Date: Wed, 14 Feb 2024 09:47:52 +0300 Subject: [PATCH 13/32] fix validators --- libs/common/src/typegraph/validator.rs | 214 ------------------ libs/common/src/typegraph/validator/common.rs | 93 ++++++++ libs/common/src/typegraph/validator/input.rs | 109 ++++----- libs/common/src/typegraph/validator/mod.rs | 125 ++++++++++ libs/common/src/typegraph/validator/types.rs | 59 ++--- libs/common/src/typegraph/visitor.rs | 162 ++++++++----- typegate/deno.lock | 55 +++++ .../__snapshots__/validator_test.ts.snap | 14 +- 8 files changed, 456 insertions(+), 375 deletions(-) delete mode 100644 libs/common/src/typegraph/validator.rs create mode 100644 libs/common/src/typegraph/validator/common.rs create mode 100644 libs/common/src/typegraph/validator/mod.rs diff --git a/libs/common/src/typegraph/validator.rs b/libs/common/src/typegraph/validator.rs deleted file mode 100644 index 36e2a8e43..000000000 --- a/libs/common/src/typegraph/validator.rs +++ /dev/null @@ -1,214 +0,0 @@ -// Copyright Metatype OÜ, licensed under the Elastic License 2.0. -// SPDX-License-Identifier: Elastic-2.0 - -mod input; -mod types; -mod value; - -use crate::typegraph::{TypeNode, Typegraph}; -use serde_json::Value; - -use super::{ - visitor::{CurrentNode, Path, PathSegment, TypeVisitor, TypeVisitorContext, VisitResult}, - EitherTypeData, Injection, UnionTypeData, -}; - -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)] -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 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<'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; - if current_node.as_input { - // do not allow t.func in input types - if let TypeNode::Function { .. } = type_node { - self.push_error(current_node.path, "function is not allowed in input types"); - return VisitResult::Continue(false); - } - } else { - match type_node { - TypeNode::Union { .. } | TypeNode::Either { .. } => { - let mut variants = vec![]; - typegraph.collect_nested_variants_into(&mut variants, &[current_node.type_idx]); - let mut object_count = 0; - - for variant_type in variants - .iter() - .map(|idx| typegraph.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 = typegraph.types.get(data.items as usize).unwrap(); - if !item_type.is_scalar() { - self.push_error( - current_node.path, - format!( - "array of '{}' not allowed as union/either variant", - item_type.type_name() - ), - ); - return VisitResult::Continue(false); - } - } - _ => { - self.push_error( - current_node.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( - current_node.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) = &type_node.base().enumeration { - if matches!(type_node, TypeNode::Optional { .. }) { - self.push_error( - current_node.path, - "optional not cannot have enumerated values".to_owned(), - ); - } else { - for value in enumeration.iter() { - match serde_json::from_str::(value) { - Ok(val) => match context - .get_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 deserializing enum value {value:?}: {e:?}"), - ), - } - } - } - } - - if let Some(injection) = &type_node.base().injection { - 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) => { - // TODO match type to parent type - } - _ => (), - } - - // - VisitResult::Continue(false) - } else { - VisitResult::Continue(true) - } - } - - fn get_result(self) -> Option { - Some(self.errors) - } -} 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 index dd4928098..458a8c289 100644 --- a/libs/common/src/typegraph/validator/input.rs +++ b/libs/common/src/typegraph/validator/input.rs @@ -4,74 +4,72 @@ use serde_json::Value; use crate::typegraph::{ - visitor::{CurrentNode, Path, PathSegment, TypeVisitor, TypeVisitorContext, VisitResult}, - Injection, TypeNode, Typegraph, + visitor::{CurrentNode, TypeVisitor, VisitResult}, + Injection, TypeNode, }; -use super::types::{EnsureSubtypeOf, ErrorCollector, ExtendedTypeNode}; - -#[derive(Debug)] -pub struct InputValidationError { - path: String, // param_path != fn_path - message: String, -} - -pub struct InputValidationContext<'a> { - typegraph: &'a Typegraph, - fn_path: String, - fn_idx: u32, - parent_struct_idx: u32, -} - -impl TypeVisitorContext for InputValidationContext<'_> { - fn get_typegraph(&self) -> &Typegraph { - self.typegraph - } -} - -pub struct InputValidator { - errors: Vec, -} - -impl InputValidator { - fn push_error(&mut self, path: &[PathSegment], message: impl Into) { - self.errors.push(InputValidationError { - path: Path(path).to_string(), - message: message.into(), - }); - } -} - -impl<'a> TypeVisitor<'a> for InputValidator { - type Return = Vec; - type Context = InputValidationContext<'a>; +use super::{ + types::{EnsureSubtypeOf, ErrorCollector, ExtendedTypeNode}, + TypeVisitorContext, Validator, ValidatorContext, +}; - fn visit( +impl Validator { + pub fn visit_input_type_impl( &mut self, current_node: CurrentNode<'_>, - context: &Self::Context, - ) -> VisitResult { + context: &::Context, + ) -> VisitResult<::Return> { + let typegraph = context.get_typegraph(); 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); + match type_node { + TypeNode::Function { .. } => { + // TODO suggest to use composition-- when available + self.push_error(current_node.path, "Function is not allowed in input types."); + return VisitResult::Continue(false); + } + 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); + } + } + } + _ => (), } + if let Some(injection) = &type_node.base().injection { self.validate_injection(injection, current_node, context); } - return VisitResult::Continue(true); + 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 InputValidator { +impl Validator { fn validate_injection( &mut self, injection: &Injection, current_node: CurrentNode<'_>, - context: &InputValidationContext<'_>, + context: &ValidatorContext<'_>, ) { let typegraph = context.get_typegraph(); @@ -95,8 +93,11 @@ impl InputValidator { } } } - Injection::Parent(_data) => { - // TODO match type to parent type + Injection::Parent(data) => { + let sources = data.values(); + for source_idx in sources.iter().copied() { + self.validate_parent_injection(*source_idx, ¤t_node, context); + } } _ => (), } @@ -105,13 +106,13 @@ impl InputValidator { fn validate_parent_injection( &mut self, source_idx: u32, - current_node: CurrentNode<'_>, - context: &InputValidationContext<'_>, + 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); + source.ensure_subtype_of(&target, typegraph, &mut errors); } } diff --git a/libs/common/src/typegraph/validator/mod.rs b/libs/common/src/typegraph/validator/mod.rs new file mode 100644 index 000000000..6d18759c1 --- /dev/null +++ b/libs/common/src/typegraph/validator/mod.rs @@ -0,0 +1,125 @@ +// 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, 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; + + 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 index 6c5614c6b..d3e4aa3ec 100644 --- a/libs/common/src/typegraph/validator/types.rs +++ b/libs/common/src/typegraph/validator/types.rs @@ -5,7 +5,7 @@ use crate::typegraph::{ EitherTypeData, FileTypeData, FloatTypeData, IntegerTypeData, ListTypeData, ObjectTypeData, StringTypeData, TypeNode, Typegraph, UnionTypeData, }; -use std::{any::Any, collections::HashSet, fmt::Display}; +use std::{collections::HashSet, fmt::Display}; pub struct ExtendedTypeNode<'a>(u32, &'a TypeNode); @@ -21,12 +21,6 @@ pub struct ErrorCollector { } impl ErrorCollector { - fn single_error(message: impl Into) -> Self { - ErrorCollector { - errors: vec![message.into()], - } - } - fn push(&mut self, message: impl Into) { self.errors.push(message.into()); } @@ -50,10 +44,8 @@ fn ensure_subtype_of_for_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")); - } + } else if sup_min.is_some() { + errors.push(format!("{key} is not defined in the subtype")); } } @@ -71,10 +63,8 @@ fn ensure_subtype_of_for_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")); - } + } else if sup_max.is_some() { + errors.push(format!("{key} is not defined in the subtype")); } } @@ -94,20 +84,13 @@ fn ensure_subtype_of_for_multiple_of( )); } } - } else { - if sup_multiple_of.is_some() { - errors.push(format!("{key} is not defined in the subtype")); - } + } 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: &IntegerTypeData, - tg: &Typegraph, - errors: &mut ErrorCollector, - ) { + 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( @@ -127,7 +110,7 @@ impl EnsureSubtypeOf for IntegerTypeData { } impl EnsureSubtypeOf for FloatTypeData { - fn ensure_subtype_of(&self, sup: &FloatTypeData, tg: &Typegraph, errors: &mut ErrorCollector) { + 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( @@ -147,7 +130,7 @@ impl EnsureSubtypeOf for FloatTypeData { } impl EnsureSubtypeOf for StringTypeData { - fn ensure_subtype_of(&self, sup: &StringTypeData, tg: &Typegraph, errors: &mut ErrorCollector) { + 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); @@ -157,10 +140,8 @@ impl EnsureSubtypeOf for StringTypeData { 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"); - } + } else if sup.pattern.is_some() { + errors.push("pattern is not defined in the subtype"); } if let Some(sub_format) = &self.format { @@ -169,16 +150,14 @@ impl EnsureSubtypeOf for StringTypeData { 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"); - } + } 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: &FileTypeData, tg: &Typegraph, errors: &mut ErrorCollector) { + 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); @@ -192,16 +171,14 @@ impl EnsureSubtypeOf for FileTypeData { 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"); - } + } 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: &ObjectTypeData, tg: &Typegraph, errors: &mut ErrorCollector) { + 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 { diff --git a/libs/common/src/typegraph/visitor.rs b/libs/common/src/typegraph/visitor.rs index ca36a2ffe..b75a995b9 100644 --- a/libs/common/src/typegraph/visitor.rs +++ b/libs/common/src/typegraph/visitor.rs @@ -8,62 +8,77 @@ use super::{TypeNode, Typegraph}; impl Typegraph { /// Depth-first traversal over all the types - pub fn traverse_types<'a, V: TypeVisitor<'a> + Sized>( - &'a self, - visitor: V, - context: &'a V::Context, - ) -> 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, + input_parent_function: None, }; traversal .visit_type(0, context) - .or_else(|| traversal.visitor.get_result()) - // if let Some(ret) = traversal.visit_type(0) { - // ret - // } else { - // traversal.visitor.get_result() - // } + .or_else(|| traversal.visitor.take_result()) } } -struct TypegraphTraversal<'a, V: TypeVisitor<'a> + 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, + input_parent_function: Option, visited_types: HashSet, // non input types visited_input_types: HashSet, visitor: V, } -impl<'a, V: TypeVisitor<'a> + Sized> TypegraphTraversal<'a, V> { +impl<'a, V> TypegraphTraversal<'a, V> +where + V: TypeVisitor<'a> + Sized, +{ fn visit_type(&mut self, type_idx: u32, context: &'a V::Context) -> Option { - if self.as_input { + let res = if self.input_parent_function.as_ref().is_some() { 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 type_node = &context.get_typegraph().types[type_idx as usize]; - let node = CurrentNode { - type_idx, - type_node, - path: &self.path, - as_input: 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 res = self.visitor.visit(node, context); let type_node = &self.tg.types[type_idx as usize]; match res { @@ -107,7 +122,6 @@ impl<'a, V: TypeVisitor<'a> + Sized> TypegraphTraversal<'a, V> { edge: Edge::OptionalItem, }, item_type_idx, - false, context, ) } @@ -124,7 +138,6 @@ impl<'a, V: TypeVisitor<'a> + Sized> TypegraphTraversal<'a, V> { edge: Edge::ArrayItem, }, item_type_idx, - false, context, ) } @@ -142,7 +155,6 @@ impl<'a, V: TypeVisitor<'a> + Sized> TypegraphTraversal<'a, V> { edge: Edge::ObjectProp(prop_name), }, *prop_type, - false, context, ); if let Some(res) = res { @@ -165,7 +177,6 @@ impl<'a, V: TypeVisitor<'a> + Sized> TypegraphTraversal<'a, V> { edge: Edge::UnionVariant(i), }, *variant_type, - false, context, ); if let Some(ret) = res { @@ -188,7 +199,6 @@ impl<'a, V: TypeVisitor<'a> + Sized> TypegraphTraversal<'a, V> { edge: Edge::EitherVariant(i), }, *t, - false, context, ) }) @@ -201,43 +211,65 @@ impl<'a, V: TypeVisitor<'a> + Sized> TypegraphTraversal<'a, V> { output: u32, context: &'a V::Context, ) -> 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, - context, - ) - }) + if self.input_parent_function.as_ref().is_some() { + return Some(V::Return::from_error( + Path(&self.path).to_string(), + "Function is not allowed in input types.".to_string(), + )); + } + 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(), + )); + } + } + + let parent_struct_idx = last_path_seg.from; + self.input_parent_function = Some(FunctionMetadata { + idx: type_idx, + path: Path(&self.path).to_string(), + parent_struct_idx, + }); + + let res = self.visit_child( + PathSegment { + from: type_idx, + edge: Edge::FunctionInput, + }, + input, + context, + ); + self.input_parent_function = None; + + 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, context); self.path.pop().unwrap(); - - if root_input { - self.as_input = false; - } res } } @@ -290,11 +322,11 @@ pub enum VisitResult { Return(T), } +#[derive(Clone, Copy)] pub struct CurrentNode<'a> { pub type_idx: u32, pub type_node: &'a TypeNode, pub path: &'a [PathSegment<'a>], - pub as_input: bool, } pub trait TypeVisitorContext { @@ -302,8 +334,8 @@ pub trait TypeVisitorContext { } pub trait TypeVisitor<'a> { - type Return: Sized; - type Context: TypeVisitorContext; + type Return: Sized + VisitorResult; + type Context: TypeVisitorContext + Clone; /// return true to continue the traversal on the subgraph fn visit( @@ -312,10 +344,22 @@ pub trait TypeVisitor<'a> { 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/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap b/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap index f820a3551..f70aa5e5b 100644 --- a/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap +++ b/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap @@ -8,13 +8,13 @@ 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:/test/[out]/a: Injection is not allowed in output types +[ERROR] at validator:/test/[out]/b: Injection is not allowed in output types +[ERROR] at validator:/test/[out]/c: Injection is not allowed in output types +[ERROR] at validator:/test/[out]/d: Injection is not allowed in output types +[ERROR] at validator:/test/[out]/e: Injection is not allowed in output types +[ERROR] at validator:/test/[out]/f: Injection is not allowed in output types +[ERROR] at validator:/test/[out]/g: Injection is not allowed in output types [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"' From 47da8bcb9231779899d77f6bc58ebf34867b8d89 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Wed, 14 Feb 2024 09:59:08 +0300 Subject: [PATCH 14/32] test from_parent validation --- libs/common/src/typegraph/validator/input.rs | 6 +++++ libs/common/src/typegraph/validator/types.rs | 2 +- .../__snapshots__/validator_test.ts.snap | 4 +++ typegate/tests/e2e/typegraph/validator.py | 27 +++++++++++++++++++ 4 files changed, 38 insertions(+), 1 deletion(-) diff --git a/libs/common/src/typegraph/validator/input.rs b/libs/common/src/typegraph/validator/input.rs index 458a8c289..a084c42d2 100644 --- a/libs/common/src/typegraph/validator/input.rs +++ b/libs/common/src/typegraph/validator/input.rs @@ -114,5 +114,11 @@ impl Validator { 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/types.rs b/libs/common/src/typegraph/validator/types.rs index d3e4aa3ec..af2ad189a 100644 --- a/libs/common/src/typegraph/validator/types.rs +++ b/libs/common/src/typegraph/validator/types.rs @@ -17,7 +17,7 @@ impl<'a> ExtendedTypeNode<'a> { #[derive(Debug, Default)] pub struct ErrorCollector { - errors: Vec, + pub errors: Vec, } impl ErrorCollector { diff --git a/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap b/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap index f70aa5e5b..c8721825d 100644 --- a/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap +++ b/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap @@ -21,6 +21,10 @@ snapshot[`typegraph validation 1`] = ` [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 +[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..3b664e5fa 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="...", + ), + } + ), ) From 2a214a0bc726f7207874eb6aeae8732ef930f3cc Mon Sep 17 00:00:00 2001 From: Natoandro Date: Wed, 14 Feb 2024 10:06:31 +0300 Subject: [PATCH 15/32] some doc comments --- typegate/src/engine/planner/parameter_transformer.ts | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/typegate/src/engine/planner/parameter_transformer.ts b/typegate/src/engine/planner/parameter_transformer.ts index 4082eaaa7..988bc8ea3 100644 --- a/typegate/src/engine/planner/parameter_transformer.ts +++ b/typegate/src/engine/planner/parameter_transformer.ts @@ -256,9 +256,12 @@ class TransformerCompilationContext { } #compileParentInjection(_typeIdx: number, parentIdx: number) { - // TODO type validation ?: the source is validated in the arg computation step; - // type inclusion is checked AOT with the typegraph + // 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(); From b3eb8076aafc13f005f5ad007dfb88bae679724a Mon Sep 17 00:00:00 2001 From: Natoandro Date: Wed, 14 Feb 2024 16:25:58 +0300 Subject: [PATCH 16/32] TypeScript client SDK for apply --- typegraph/node/sdk/src/runtimes/deno.ts | 15 ++-- typegraph/node/sdk/src/runtimes/graphql.ts | 10 +-- typegraph/node/sdk/src/runtimes/http.ts | 30 +++----- typegraph/node/sdk/src/runtimes/python.ts | 5 +- typegraph/node/sdk/src/runtimes/wasmedge.ts | 5 +- typegraph/node/sdk/src/typegraph.ts | 35 ++++++++- typegraph/node/sdk/src/types.ts | 81 ++++++++++++++++++--- 7 files changed, 130 insertions(+), 51 deletions(-) diff --git a/typegraph/node/sdk/src/runtimes/deno.ts b/typegraph/node/sdk/src/runtimes/deno.ts index 660e45e36..273ec2aee 100644 --- a/typegraph/node/sdk/src/runtimes/deno.ts +++ b/typegraph/node/sdk/src/runtimes/deno.ts @@ -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,9 +85,8 @@ 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", 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 fd2d7b94c..73a021aa9 100644 --- a/typegraph/node/sdk/src/typegraph.ts +++ b/typegraph/node/sdk/src/typegraph.ts @@ -29,7 +29,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; @@ -68,7 +98,7 @@ export class InheritDef { export type TypegraphBuilder = (g: TypegraphBuilderArgs) => void; export class RawAuth { - constructor(readonly jsonStr: string) {} + constructor(readonly jsonStr: string) { } } export interface TypegraphOutput { @@ -164,6 +194,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..2eafc31b8 100644 --- a/typegraph/node/sdk/src/types.ts +++ b/typegraph/node/sdk/src/types.ts @@ -14,6 +14,8 @@ import { TypeOptional, TypeString, TypeUnion, + TypeId, + 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 +29,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 +512,57 @@ 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; } reduce(value: Record) { @@ -538,19 +576,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 +626,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, ); } From d3734fcca23b983fe8a9cf17a3bf6de41f28a63a Mon Sep 17 00:00:00 2001 From: Natoandro Date: Wed, 14 Feb 2024 21:42:26 +0300 Subject: [PATCH 17/32] docs: Add doc for parameter transformation --- .../types/parameter-transformation.mdx | 281 ++++++++++++++++++ 1 file changed, 281 insertions(+) create mode 100644 website/docs/reference/types/parameter-transformation.mdx diff --git a/website/docs/reference/types/parameter-transformation.mdx b/website/docs/reference/types/parameter-transformation.mdx new file mode 100644 index 000000000..46cfd32ba --- /dev/null +++ b/website/docs/reference/types/parameter-transformation.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. + From 46fb12671e3f8d85f0011250e00eff97b23c1a85 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Wed, 14 Feb 2024 22:59:22 +0300 Subject: [PATCH 18/32] upgrade pnpm --- .ghjk/lock.json | 7 ++++++- CHANGELOG.md | 2 -- Cargo.lock | 55 ++++++++++++++++++++++++++++++++++--------------- dev/lock.yml | 2 +- ghjk.ts | 2 +- 5 files changed, 46 insertions(+), 22 deletions(-) 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/CHANGELOG.md b/CHANGELOG.md index 274959f52..c4c6296c8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2081,5 +2081,3 @@ Make `with_store` and `with_store_mut` private in `global_store` module ( - - diff --git a/Cargo.lock b/Cargo.lock index ac7de5eec..8ab79549d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1126,10 +1126,11 @@ dependencies = [ [[package]] name = "cc" -version = "1.0.85" +version = "1.0.83" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b918671670962b48bc23753aef0c51d072dca6f52f01f800854ada6ddb7f7d3" +checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" dependencies = [ + "jobserver", "libc", ] @@ -1208,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", @@ -4552,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" @@ -5067,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", ] @@ -5108,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", ] @@ -5152,6 +5153,15 @@ version = "1.0.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c" +[[package]] +name = "jobserver" +version = "0.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab46a6e9526ddef3ae7f787c06f0f2600639ba80ea3eade3d8e670a2230f51d6" +dependencies = [ + "libc", +] + [[package]] name = "js-sys" version = "0.3.68" @@ -6098,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", @@ -6107,6 +6117,7 @@ dependencies = [ "futures-sink", "futures-util", "lazy_static 1.4.0", + "lexical", "lru 0.8.1", "mio", "mysql_common", @@ -6116,6 +6127,7 @@ dependencies = [ "percent-encoding", "pin-project", "priority-queue", + "regex", "serde 1.0.196", "serde_json", "socket2 0.4.10", @@ -6515,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", ] @@ -7160,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" @@ -10541,7 +10553,7 @@ dependencies = [ "serde 1.0.196", "serde_spanned", "toml_datetime", - "toml_edit 0.22.4", + "toml_edit 0.22.5", ] [[package]] @@ -10561,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]] @@ -12150,6 +12162,15 @@ dependencies = [ "memchr", ] +[[package]] +name = "winnow" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d90f4e0f530c4c69f62b80d839e9ef3855edc9cba471a160c4d692deed62b401" +dependencies = [ + "memchr", +] + [[package]] name = "winreg" version = "0.50.0" diff --git a/dev/lock.yml b/dev/lock.yml index 622b2279d..92b35894c 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/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"; From 78c619ca708c8aa4cf095478737b5769571e1b5f Mon Sep 17 00:00:00 2001 From: Natoandro Date: Thu, 15 Feb 2024 04:22:10 +0300 Subject: [PATCH 19/32] tests: fix typegraph_core tests --- typegraph/core/src/params/apply.rs | 169 +- ...ere_expr__tests__Post__QueryWhereExpr.snap | 426 +- ...ere_expr__tests__User__QueryWhereExpr.snap | 818 ++-- ..._generation__test__aggregate Post out.snap | 42 +- ...eneration__test__aggregate Record out.snap | 42 +- ..._generation__test__aggregate User out.snap | 42 +- ...eneration__test__create_many Post inp.snap | 1640 +++---- ...eneration__test__create_many Post out.snap | 2 +- ...eration__test__create_many Record inp.snap | 14 +- ...eration__test__create_many Record out.snap | 2 +- ...eneration__test__create_many User inp.snap | 1744 +++---- ...eneration__test__create_many User out.snap | 2 +- ...generation__test__create_one Post inp.snap | 1638 +++---- ...neration__test__create_one Record inp.snap | 12 +- ...generation__test__create_one User inp.snap | 1742 +++---- ...generation__test__find_first Post out.snap | 12 +- ...neration__test__find_first Record out.snap | 10 +- ...generation__test__find_first User out.snap | 14 +- ..._generation__test__find_many Post inp.snap | 508 +- ..._generation__test__find_many Post out.snap | 16 +- ...eneration__test__find_many Record inp.snap | 380 +- ...eneration__test__find_many Record out.snap | 10 +- ..._generation__test__find_many User inp.snap | 928 ++-- ..._generation__test__find_many User out.snap | 20 +- ...eneration__test__find_unique Post inp.snap | 8 +- ...eneration__test__find_unique Post out.snap | 16 +- ...eration__test__find_unique Record inp.snap | 8 +- ...eration__test__find_unique Record out.snap | 10 +- ...eneration__test__find_unique User inp.snap | 8 +- ...eneration__test__find_unique User out.snap | 20 +- ...e_generation__test__group_by Post inp.snap | 1916 ++++---- ...e_generation__test__group_by Post out.snap | 50 +- ...generation__test__group_by Record inp.snap | 1236 ++--- ...generation__test__group_by Record out.snap | 52 +- ...e_generation__test__group_by User inp.snap | 3616 +++++++------- ...e_generation__test__group_by User out.snap | 52 +- ...eneration__test__update_many Post inp.snap | 2132 ++++---- ...eration__test__update_many Record inp.snap | 360 +- ...eneration__test__update_many User inp.snap | 4330 ++++++++--------- ...generation__test__update_one Post inp.snap | 1708 +++---- ...neration__test__update_one Record inp.snap | 54 +- ...generation__test__update_one User inp.snap | 3514 ++++++------- ..._generation__where___test__where Post.snap | 410 +- ...eneration__where___test__where Record.snap | 292 +- ..._generation__where___test__where User.snap | 802 +-- 45 files changed, 15403 insertions(+), 15424 deletions(-) diff --git a/typegraph/core/src/params/apply.rs b/typegraph/core/src/params/apply.rs index 5c5c87a57..064a8a5dd 100644 --- a/typegraph/core/src/params/apply.rs +++ b/typegraph/core/src/params/apply.rs @@ -373,10 +373,12 @@ impl TransformDataBuildContext { mod test { use super::*; use crate::test_utils::tree; + use raw_tree::{ + ParameterTransformLeafNode, ParameterTransformNode, ParameterTransformParentNode, + }; #[test] fn identity() -> Result<()> { - let validator = TransformTreeValidationContext::new(); let input = t::struct_() .propx("a", t::string())? .propx("b", t::string())? @@ -385,23 +387,20 @@ mod test { let mut map = HashMap::new(); map.insert( "a".to_string(), - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { - name: None, - })), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { name: None }), ); map.insert( "b".to_string(), - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { - name: None, - })), + ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg { name: None }), ); map }; - let query_input = validator.query_input(input, root)?; + + let transform_data = build_transform_data(input, &root_fields)?; let print_options = tree::PrintOptions::new().no_indent_lines(); assert_eq!( - print_options.print(query_input), + print_options.print(transform_data.query_input.into()), indoc::indoc! {" root: struct #3 [a]: string #0 @@ -413,35 +412,32 @@ mod test { #[test] fn identity_named() -> Result<()> { - let validator = TransformTreeValidationContext::new(); let input = t::struct_() .propx("a", t::string())? .propx("b", t::string())? .build()?; - let root = ParameterTransformObjectNode { - fields: vec![ - ( - "a".to_string(), - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { - name: Some("first".to_string()), - })), - ), - ( - "b".to_string(), - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { - name: Some("second".to_string()), - })), - ), - ] - .into_iter() - .collect(), - }; + 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 query_input = validator.query_input(input, root)?; + let transform_data = build_transform_data(input, &root)?; let print_options = tree::PrintOptions::new().no_indent_lines(); assert_eq!( - print_options.print(query_input), + print_options.print(transform_data.query_input.into()), indoc::indoc! {" root: struct #3 [first]: string #0 @@ -453,81 +449,64 @@ mod test { #[test] fn array_items() -> Result<()> { - let validator = TransformTreeValidationContext::new(); let input = t::struct_() .propx("a", t::string())? .propx("b", t::listx(t::string())?)? .build()?; - let root = ParameterTransformObjectNode { - fields: vec![ - ( - "a".to_string(), - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { - name: None, - })), - ), - ( - "b".to_string(), - ParameterTransformNode::Parent(ParameterTransformParentNode::Array( - ParameterTransformArrayNode { - items: vec![ - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg( - ApplyFromArg { name: None }, - )), - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg( - ApplyFromArg { name: None }, - )), - ], - }, - )), - ), - ] - .into_iter() - .collect(), - }; - - let query_input = validator.query_input(input, root); - assert!(query_input.is_err()); - let err = query_input.unwrap_err().to_string(); + 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 = ParameterTransformObjectNode { - fields: vec![ - ( - "a".to_string(), - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg(ApplyFromArg { - name: None, - })), - ), - ( - "b".to_string(), - ParameterTransformNode::Parent(ParameterTransformParentNode::Array( - ParameterTransformArrayNode { - items: vec![ - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg( - ApplyFromArg { - name: Some("first".to_string()), - }, - )), - ParameterTransformNode::Leaf(ParameterTransformLeafNode::Arg( - ApplyFromArg { - name: Some("second".to_string()), - }, - )), - ], - }, - )), - ), - ] - .into_iter() - .collect(), - }; - let query_input = TransformTreeValidationContext::new().query_input(input, root)?; + 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(query_input), + print_options.print(transform_data.query_input.into()), indoc::indoc! {" root: struct #4 [a]: string #0 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..d393d5d75 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 @@ -3,25 +3,25 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: struct #49 -├─ [_count]: struct '_Post_AggrCount' #40 -│ ├─ [_all]: optional #39 -│ │ └─ item: integer #38 -│ ├─ [id]: optional #39 -│ │ └─ item: integer #38 -│ ├─ [title]: optional #39 -│ │ └─ item: integer #38 -│ └─ [author]: optional #39 -│ └─ item: integer #38 -├─ [_avg]: struct '_Post_NumberAgg_avg' #43 -│ └─ [id]: optional #42 -│ └─ item: float #41 -├─ [_sum]: 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 - └─ [id]: optional #47 - └─ item: integer #46 +├── [_avg]: struct '_Post_NumberAgg_avg' #43 +│ └── [id]: optional #42 +│ └── item: float #41 +├── [_count]: struct '_Post_AggrCount' #40 +│ ├── [_all]: optional #39 +│ │ └── item: integer #38 +│ ├── [author]: optional #39 +│ │ └── item: integer #38 +│ ├── [id]: optional #39 +│ │ └── item: integer #38 +│ └── [title]: optional #39 +│ └── item: integer #38 +├── [_max]: struct '_Post_NumberAgg' #48 +│ └── [id]: optional #47 +│ └── item: integer #46 +├── [_min]: struct '_Post_NumberAgg' #48 +│ └── [id]: optional #47 +│ └── item: integer #46 +└── [_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..6158bf2fa 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 @@ -3,25 +3,25 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: struct #16 -├─ [_count]: struct '_Record_AggrCount' #7 -│ ├─ [_all]: optional #6 -│ │ └─ item: integer #5 -│ ├─ [id]: optional #6 -│ │ └─ item: integer #5 -│ ├─ [name]: optional #6 -│ │ └─ item: integer #5 -│ └─ [age]: optional #6 -│ └─ item: integer #5 -├─ [_avg]: struct '_Record_NumberAgg_avg' #10 -│ └─ [age]: optional #9 -│ └─ item: float #8 -├─ [_sum]: 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 - └─ [age]: optional #14 - └─ item: integer #13 +├── [_avg]: struct '_Record_NumberAgg_avg' #10 +│ └── [age]: optional #9 +│ └── item: float #8 +├── [_count]: struct '_Record_AggrCount' #7 +│ ├── [_all]: optional #6 +│ │ └── item: integer #5 +│ ├── [age]: optional #6 +│ │ └── item: integer #5 +│ ├── [id]: optional #6 +│ │ └── item: integer #5 +│ └── [name]: optional #6 +│ └── item: integer #5 +├── [_max]: struct '_Record_NumberAgg' #15 +│ └── [age]: optional #14 +│ └── item: integer #13 +├── [_min]: struct '_Record_NumberAgg' #15 +│ └── [age]: optional #14 +│ └── item: integer #13 +└── [_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..f125180d8 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 @@ -3,25 +3,25 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: struct #37 -├─ [_count]: struct '_User_AggrCount' #28 -│ ├─ [_all]: optional #27 -│ │ └─ item: integer #26 -│ ├─ [id]: optional #27 -│ │ └─ item: integer #26 -│ ├─ [name]: optional #27 -│ │ └─ 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 -│ └─ [id]: optional #35 -│ └─ item: integer #34 -├─ [_min]: struct '_User_NumberAgg' #36 -│ └─ [id]: optional #35 -│ └─ item: integer #34 -└─ [_max]: struct '_User_NumberAgg' #36 - └─ [id]: optional #35 - └─ item: integer #34 +├── [_avg]: struct '_User_NumberAgg_avg' #31 +│ └── [id]: optional #30 +│ └── item: float #29 +├── [_count]: struct '_User_AggrCount' #28 +│ ├── [_all]: optional #27 +│ │ └── item: integer #26 +│ ├── [id]: optional #27 +│ │ └── item: integer #26 +│ ├── [name]: optional #27 +│ │ └── item: integer #26 +│ └── [posts]: optional #27 +│ └── item: integer #26 +├── [_max]: struct '_User_NumberAgg' #36 +│ └── [id]: optional #35 +│ └── item: integer #34 +├── [_min]: struct '_User_NumberAgg' #36 +│ └── [id]: optional #35 +│ └── item: integer #34 +└── [_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..6bdb1cae4 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 @@ -3,824 +3,824 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #110 -└─ [data]: list '_109__Post_CreateInput[]' #109 - └─ item: struct '_Post_CreateInput' #108 - ├─ [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 +└── [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 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..314f9b44c 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 @@ -3,5 +3,5 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: struct #112 -└─ [count]: integer #111 +└── [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..2b856061b 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 @@ -3,11 +3,11 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #8 -└─ [data]: list '_7__Record_CreateInput[]' #7 - └─ item: struct '_Record_CreateInput' #6 - ├─ [id]: optional #5 - │ └─ item: string #0 - ├─ [name]: string #1 - └─ [age]: optional #3 - └─ item: integer #2 +└── [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 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..298d13e54 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 @@ -3,5 +3,5 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: struct #10 -└─ [count]: integer #9 +└── [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..f86d49c86 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 @@ -3,876 +3,876 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #82 -└─ [data]: list '_81__User_CreateInput[]' #81 - └─ item: struct '_User_CreateInput' #80 - ├─ [id]: integer #11 - ├─ [name]: string #12 - └─ [posts]: optional #79 - └─ item: union #78 - ├─ variant_0: struct #71 - │ └─ [create]: union #23 - │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - │ │ ├─ [id]: optional #20 - │ │ │ └─ item: integer #16 - │ │ └─ [title]: string #17 - │ └─ variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 - │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - │ ├─ [id]: optional #20 - │ │ └─ item: integer #16 - │ └─ [title]: string #17 - ├─ variant_1: struct #72 - │ └─ [connect]: union #69 - │ ├─ variant_0: struct 'PostWhere' #67 - │ │ ├─ [id]: optional '_36__integer_filter_c?' #36 - │ │ │ └─ 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 '_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 - │ └─ variant_1: list '_68_PostWhere[]' #68 - │ └─ item: struct 'PostWhere' #67 - │ ├─ [id]: optional '_36__integer_filter_c?' #36 - │ │ └─ 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 '_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 - ├─ variant_2: struct #73 - │ └─ [connectOrCreate]: struct #70 - │ ├─ [create]: union #23 - │ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - │ │ │ ├─ [id]: optional #20 - │ │ │ │ └─ item: integer #16 - │ │ │ └─ [title]: string #17 - │ │ └─ variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 - │ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - │ │ ├─ [id]: optional #20 - │ │ │ └─ item: integer #16 - │ │ └─ [title]: string #17 - │ └─ [where]: union #69 - │ ├─ variant_0: struct 'PostWhere' #67 - │ │ ├─ [id]: optional '_36__integer_filter_c?' #36 - │ │ │ └─ 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 '_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 - │ └─ variant_1: list '_68_PostWhere[]' #68 - │ └─ item: struct 'PostWhere' #67 - │ ├─ [id]: optional '_36__integer_filter_c?' #36 - │ │ └─ 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 '_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 - └─ variant_3: struct #77 - └─ [createMany]: optional #76 - └─ item: struct #75 - └─ [data]: list #74 - └─ item: union #23 - ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - │ ├─ [id]: optional #20 - │ │ └─ item: integer #16 - │ └─ [title]: string #17 - └─ variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 - └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - ├─ [id]: optional #20 - │ └─ item: integer #16 - └─ [title]: string #17 +└── [data]: list '_81__User_CreateInput[]' #81 + └── item: struct '_User_CreateInput' #80 + ├── [id]: integer #11 + ├── [name]: string #12 + └── [posts]: optional #79 + └── item: union #78 + ├── variant_0: struct #71 + │ └── [create]: union #23 + │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + │ │ ├── [id]: optional #20 + │ │ │ └── item: integer #16 + │ │ └── [title]: string #17 + │ └── variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 + │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + │ ├── [id]: optional #20 + │ │ └── item: integer #16 + │ └── [title]: string #17 + ├── 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 + │ │ │ ├── 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 '_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 + │ │ ├── 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 '_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 + │ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + │ │ │ ├── [id]: optional #20 + │ │ │ │ └── item: integer #16 + │ │ │ └── [title]: string #17 + │ │ └── variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 + │ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + │ │ ├── [id]: optional #20 + │ │ │ └── item: integer #16 + │ │ └── [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 + │ │ │ ├── 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 '_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 + │ │ ├── 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 '_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 + └── [data]: list #74 + └── item: union #23 + ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + │ ├── [id]: optional #20 + │ │ └── item: integer #16 + │ └── [title]: string #17 + └── variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 + └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + ├── [id]: optional #20 + │ └── item: integer #16 + └── [title]: string #17 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..a1548102b 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 @@ -3,5 +3,5 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: struct #84 -└─ [count]: integer #83 +└── [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..e1947f5f0 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 @@ -3,823 +3,823 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #103 -└─ [data]: struct '_Post_CreateInput' #102 - ├─ [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 +└── [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 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..f2221579f 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 @@ -3,10 +3,10 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #7 -└─ [data]: struct '_Record_CreateInput' #6 - ├─ [id]: optional #5 - │ └─ item: string #0 - ├─ [name]: string #1 - └─ [age]: optional #3 - └─ item: integer #2 +└── [data]: struct '_Record_CreateInput' #6 + ├── [age]: optional #3 + │ └── item: integer #2 + ├── [id]: optional #5 + │ └── item: string #0 + └── [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..39994fc21 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 @@ -3,875 +3,875 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #78 -└─ [data]: struct '_User_CreateInput' #77 - ├─ [id]: integer #8 - ├─ [name]: string #9 - └─ [posts]: optional #76 - └─ item: union #75 - ├─ variant_0: struct #68 - │ └─ [create]: union #20 - │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - │ │ ├─ [id]: optional #17 - │ │ │ └─ item: integer #13 - │ │ └─ [title]: string #14 - │ └─ variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 - │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - │ ├─ [id]: optional #17 - │ │ └─ item: integer #13 - │ └─ [title]: string #14 - ├─ variant_1: struct #69 - │ └─ [connect]: union #66 - │ ├─ variant_0: struct 'PostWhere' #64 - │ │ ├─ [id]: optional '_33__integer_filter_c?' #33 - │ │ │ └─ 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 '_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 - │ └─ variant_1: list '_65_PostWhere[]' #65 - │ └─ item: struct 'PostWhere' #64 - │ ├─ [id]: optional '_33__integer_filter_c?' #33 - │ │ └─ 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 '_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 - ├─ variant_2: struct #70 - │ └─ [connectOrCreate]: struct #67 - │ ├─ [create]: union #20 - │ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - │ │ │ ├─ [id]: optional #17 - │ │ │ │ └─ item: integer #13 - │ │ │ └─ [title]: string #14 - │ │ └─ variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 - │ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - │ │ ├─ [id]: optional #17 - │ │ │ └─ item: integer #13 - │ │ └─ [title]: string #14 - │ └─ [where]: union #66 - │ ├─ variant_0: struct 'PostWhere' #64 - │ │ ├─ [id]: optional '_33__integer_filter_c?' #33 - │ │ │ └─ 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 '_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 - │ └─ variant_1: list '_65_PostWhere[]' #65 - │ └─ item: struct 'PostWhere' #64 - │ ├─ [id]: optional '_33__integer_filter_c?' #33 - │ │ └─ 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 '_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 - └─ variant_3: struct #74 - └─ [createMany]: optional #73 - └─ item: struct #72 - └─ [data]: list #71 - └─ item: union #20 - ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - │ ├─ [id]: optional #17 - │ │ └─ item: integer #13 - │ └─ [title]: string #14 - └─ variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 - └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - ├─ [id]: optional #17 - │ └─ item: integer #13 - └─ [title]: string #14 +└── [data]: struct '_User_CreateInput' #77 + ├── [id]: integer #8 + ├── [name]: string #9 + └── [posts]: optional #76 + └── item: union #75 + ├── variant_0: struct #68 + │ └── [create]: union #20 + │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + │ │ ├── [id]: optional #17 + │ │ │ └── item: integer #13 + │ │ └── [title]: string #14 + │ └── variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 + │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + │ ├── [id]: optional #17 + │ │ └── item: integer #13 + │ └── [title]: string #14 + ├── 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 + │ │ │ ├── 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 '_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 + │ │ ├── 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 '_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 + │ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + │ │ │ ├── [id]: optional #17 + │ │ │ │ └── item: integer #13 + │ │ │ └── [title]: string #14 + │ │ └── variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 + │ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + │ │ ├── [id]: optional #17 + │ │ │ └── item: integer #13 + │ │ └── [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 + │ │ │ ├── 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 '_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 + │ │ ├── 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 '_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 + └── [data]: list #71 + └── item: union #20 + ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + │ ├── [id]: optional #17 + │ │ └── item: integer #13 + │ └── [title]: string #14 + └── variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 + └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + ├── [id]: optional #17 + │ └── item: integer #13 + └── [title]: string #14 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..315f49d18 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 @@ -3,10 +3,10 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: optional '_22__PostOutputType?' #22 -└─ item: struct '_PostOutputType' #21 - ├─ [id]: integer #12 - ├─ [title]: string #13 - └─ [author]: struct '_UserOutputType_excluding___rel_Post_User_1' #20 - ├─ [id]: integer #7 - └─ [name]: string #8 +└── 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 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..7cda9466d 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 @@ -3,9 +3,9 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: optional '_6__RecordOutputType?' #6 -└─ item: struct '_RecordOutputType' #5 - ├─ [id]: string #0 - ├─ [name]: string #1 - └─ [age]: optional #3 - └─ item: integer #2 +└── item: struct '_RecordOutputType' #5 + ├── [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__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..e5f6ef357 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 @@ -3,11 +3,11 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: optional '_19__UserOutputType?' #19 -└─ item: struct '_UserOutputType' #18 - ├─ [id]: integer #7 - ├─ [name]: string #8 - └─ [posts]: list '_17__PostOutputType_excluding___rel_Post_User_1[]' #17 - └─ item: struct '_PostOutputType_excluding___rel_Post_User_1' #16 - ├─ [id]: integer #12 - └─ [title]: string #13 +└── item: struct '_UserOutputType' #18 + ├── [id]: integer #7 + ├── [name]: string #8 + └── [posts]: list '_17__PostOutputType_excluding___rel_Post_User_1[]' #17 + └── item: struct '_PostOutputType_excluding___rel_Post_User_1' #16 + ├── [id]: integer #12 + └── [title]: string #13 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..484d9c4b6 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 @@ -3,258 +3,258 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::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 -├─ [orderBy]: optional '_149__Post_OrderBy?' #149 -│ └─ item: list '_Post_OrderBy' #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"' } -│ ├─ [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 -├─ [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"' } +├── [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"' } +├── [skip]: optional '_151__Skip?' #151 +│ └── item: integer '_Skip' #56 +├── [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..eab527b04 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 @@ -3,12 +3,12 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: list '_161_PostWithNestedCount[]' #161 -└─ item: struct 'PostWithNestedCount' #160 - ├─ [id]: integer #74 - ├─ [title]: string #75 - └─ [author]: struct 'User' #73 - ├─ [id]: integer #69 - ├─ [name]: string #70 - └─ [posts]: list '_72_Post[]' #72 - └─ item: &Post #71 +└── 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 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..443be946a 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 @@ -3,194 +3,194 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::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 -├─ [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 -│ │ │ └─ [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"' } -│ └─ [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"' } -├─ [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"' } +├── [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 +│ ├── [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"' } +│ ├── [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"' } +├── [skip]: optional '_57__Skip?' #57 +│ └── item: integer '_Skip' #56 +├── [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..d7ce65c58 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 @@ -3,9 +3,9 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: list '_68_RecordWithNestedCount[]' #68 -└─ item: struct 'RecordWithNestedCount' #67 - ├─ [id]: string #0 - ├─ [name]: string #1 - └─ [age]: optional #3 - └─ item: integer #2 +└── item: struct 'RecordWithNestedCount' #67 + ├── [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__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..033bf0a9b 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 @@ -3,468 +3,468 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::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 -├─ [orderBy]: optional '_104__User_OrderBy?' #104 -│ └─ item: list '_User_OrderBy' #103 -│ └─ item: struct #102 -│ ├─ [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"' } -│ └─ [posts]: optional '_SortByAggregates' #101 -│ └─ item: struct #100 -│ ├─ [_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"' } -│ ├─ [_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"' } -│ ├─ [_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"' } -│ ├─ [_min]: 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"' } -│ └─ [_max]: 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"' } +├── [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 +│ ├── [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"' } +│ └── [posts]: optional '_SortByAggregates' #101 +│ └── item: struct #100 +│ ├── [_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"' } +│ ├── [_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"' } +│ ├── [_max]: 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"' } +│ ├── [_min]: 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 +│ └── item: union #46 +│ ├── variant_0: struct #45 +│ │ └── [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ └── variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +├── [skip]: optional '_106__Skip?' #106 +│ └── item: integer '_Skip' #56 +├── [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..52bdf7195 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 @@ -3,14 +3,14 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: list '_121_UserWithNestedCount[]' #121 -└─ item: struct 'UserWithNestedCount' #120 - ├─ [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 +└── 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 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 12738b05a..b2fc927a9 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 @@ -3,8 +3,8 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #34 -└─ [where]: optional '_33_QueryUniquePostWhereInput?' #33 - └─ item: struct 'QueryUniquePostWhereInput' #32 - └─ [id]: optional #31 - └─ item: integer #16 +└── [where]: optional '_33_QueryUniquePostWhereInput?' #33 + └── item: struct 'QueryUniquePostWhereInput' #32 + └── [id]: optional #31 + └── item: integer #16 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 26d183ce3..ff54d838a 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 @@ -3,12 +3,12 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: optional '_36_PostWithNestedCount?' #36 -└─ item: struct 'PostWithNestedCount' #35 - ├─ [id]: integer #16 - ├─ [title]: string #17 - └─ [author]: struct 'User' #15 - ├─ [id]: integer #11 - ├─ [name]: string #12 - └─ [posts]: list '_14_Post[]' #14 - └─ item: &Post #13 +└── item: struct 'PostWithNestedCount' #35 + ├── [author]: struct 'User' #15 + │ ├── [id]: integer #11 + │ ├── [name]: string #12 + │ └── [posts]: list '_14_Post[]' #14 + │ └── item: &Post #13 + ├── [id]: integer #16 + └── [title]: string #17 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 82fde2a1d..6f38f5f5f 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 @@ -3,8 +3,8 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #8 -└─ [where]: optional '_7_QueryUniqueRecordWhereInput?' #7 - └─ item: struct 'QueryUniqueRecordWhereInput' #6 - └─ [id]: optional #5 - └─ item: string #0 +└── [where]: optional '_7_QueryUniqueRecordWhereInput?' #7 + └── item: struct 'QueryUniqueRecordWhereInput' #6 + └── [id]: optional #5 + └── item: string #0 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 db2d89dff..5959f6a00 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 @@ -3,9 +3,9 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: optional '_10_RecordWithNestedCount?' #10 -└─ item: struct 'RecordWithNestedCount' #9 - ├─ [id]: string #0 - ├─ [name]: string #1 - └─ [age]: optional #3 - └─ item: integer #2 +└── item: struct 'RecordWithNestedCount' #9 + ├── [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__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 d58e064b7..517ff9883 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 @@ -3,8 +3,8 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #23 -└─ [where]: optional '_22_QueryUniqueUserWhereInput?' #22 - └─ item: struct 'QueryUniqueUserWhereInput' #21 - └─ [id]: optional #20 - └─ item: integer #11 +└── [where]: optional '_22_QueryUniqueUserWhereInput?' #22 + └── item: struct 'QueryUniqueUserWhereInput' #21 + └── [id]: optional #20 + └── item: integer #11 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 e8cbec310..6dd6d61a8 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 @@ -3,14 +3,14 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: optional '_30_UserWithNestedCount?' #30 -└─ item: struct 'UserWithNestedCount' #29 - ├─ [id]: integer #11 - ├─ [name]: string #12 - ├─ [posts]: list '_25_PostWithNestedCount_excluding___rel_Post_User_1[]' #25 - │ └─ item: struct 'PostWithNestedCount_excluding___rel_Post_User_1' #24 - │ ├─ [id]: integer #16 - │ └─ [title]: string #17 - └─ [_count]: struct #28 - └─ [posts]: optional '_Count' #27 - └─ item: integer #26 +└── item: struct 'UserWithNestedCount' #29 + ├── [_count]: struct #28 + │ └── [posts]: optional '_Count' #27 + │ └── item: integer #26 + ├── [id]: integer #11 + ├── [name]: string #12 + └── [posts]: list '_25_PostWithNestedCount_excluding___rel_Post_User_1[]' #25 + └── item: struct 'PostWithNestedCount_excluding___rel_Post_User_1' #24 + ├── [id]: integer #16 + └── [title]: string #17 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..454777c93 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 @@ -3,962 +3,962 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::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 -├─ [orderBy]: optional '_233__Post_OrderBy_with_aggregates?' #233 -│ └─ item: list '_Post_OrderBy_with_aggregates' #232 -│ └─ item: struct #231 -│ ├─ [_count]: optional #224 -│ │ └─ item: struct #223 -│ │ ├─ [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 '_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 -│ │ └─ 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 -│ │ └─ 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"' } -│ ├─ [_min]: 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"' } -│ ├─ [_max]: 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"' } -│ ├─ [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 -├─ [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 +├── [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 +│ │ ├── [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"' } +│ │ ├── [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"' } +│ ├── [_max]: 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"' } +│ ├── [_min]: 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"' } +│ ├── [_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"' } +├── [skip]: optional '_235__Skip?' #235 +│ └── item: integer '_Skip' #61 +├── [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..47e28d357 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 @@ -3,29 +3,29 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: list '_Post_GroupByResult' #279 -└─ item: struct #278 - ├─ [id]: integer #119 - ├─ [title]: string #120 - ├─ [author]: &User #121 - ├─ [_count]: struct '_Post_AggrCount' #269 - │ ├─ [_all]: optional #268 - │ │ └─ item: integer #267 - │ ├─ [id]: optional #268 - │ │ └─ item: integer #267 - │ ├─ [title]: optional #268 - │ │ └─ item: integer #267 - │ └─ [author]: optional #268 - │ └─ item: integer #267 - ├─ [_avg]: struct '_Post_SelectNumbers__1' #272 - │ └─ [id]: optional #271 - │ └─ item: float #270 - ├─ [_sum]: 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 +└── item: struct #278 + ├── [_avg]: struct '_Post_SelectNumbers__1' #272 + │ └── [id]: optional #271 + │ └── item: float #270 + ├── [_count]: struct '_Post_AggrCount' #269 + │ ├── [_all]: optional #268 + │ │ └── item: integer #267 + │ ├── [author]: optional #268 + │ │ └── item: integer #267 + │ ├── [id]: optional #268 + │ │ └── item: integer #267 + │ └── [title]: optional #268 + │ └── item: integer #267 + ├── [_max]: struct '_Post_SelectNumbers_' #277 + │ └── [id]: optional #276 + │ └── item: integer #275 + ├── [_min]: 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..fd9f8dc59 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 @@ -3,622 +3,622 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::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 -├─ [orderBy]: optional '_58__Record_OrderBy_with_aggregates?' #58 -│ └─ item: list '_Record_OrderBy_with_aggregates' #57 -│ └─ item: struct #56 -│ ├─ [_count]: optional #52 -│ │ └─ item: struct #51 -│ │ ├─ [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"' } -│ │ └─ [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"' } -│ ├─ [_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 -│ │ └─ 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"' } -│ ├─ [_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"' } -│ │ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ ├─ [_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"' } -│ │ └─ 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"' } -│ ├─ [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"' } -│ └─ [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"' } -├─ [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 +├── [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 +│ │ ├── [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"' } +│ │ ├── [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"' } +│ ├── [_max]: 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"' } +│ ├── [_min]: 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"' } +│ ├── [_sum]: 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"' } +│ ├── [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"' } +│ ├── [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"' } +├── [skip]: optional '_62__Skip?' #62 +│ └── item: integer '_Skip' #61 +├── [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..36a42bfdf 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 @@ -3,30 +3,30 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: list '_Record_GroupByResult' #113 -└─ item: struct #112 - ├─ [id]: string #0 - ├─ [name]: string #1 - ├─ [age]: optional #3 - │ └─ item: integer #2 - ├─ [_count]: struct '_Record_AggrCount' #103 - │ ├─ [_all]: optional #102 - │ │ └─ item: integer #101 - │ ├─ [id]: optional #102 - │ │ └─ item: integer #101 - │ ├─ [name]: optional #102 - │ │ └─ item: integer #101 - │ └─ [age]: optional #102 - │ └─ item: integer #101 - ├─ [_avg]: struct '_Record_SelectNumbers__1' #106 - │ └─ [age]: optional #105 - │ └─ item: float #104 - ├─ [_sum]: 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 +└── item: struct #112 + ├── [_avg]: struct '_Record_SelectNumbers__1' #106 + │ └── [age]: optional #105 + │ └── item: float #104 + ├── [_count]: struct '_Record_AggrCount' #103 + │ ├── [_all]: optional #102 + │ │ └── item: integer #101 + │ ├── [age]: optional #102 + │ │ └── item: integer #101 + │ ├── [id]: optional #102 + │ │ └── item: integer #101 + │ └── [name]: optional #102 + │ └── item: integer #101 + ├── [_max]: struct '_Record_SelectNumbers_' #111 + │ └── [age]: optional #110 + │ └── item: integer #109 + ├── [_min]: 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..440225263 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 @@ -3,1812 +3,1812 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::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 -├─ [orderBy]: optional '_154__User_OrderBy_with_aggregates?' #154 -│ └─ item: list '_User_OrderBy_with_aggregates' #153 -│ └─ item: struct #152 -│ ├─ [_count]: optional #146 -│ │ └─ item: struct #145 -│ │ ├─ [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"' } -│ │ └─ [posts]: 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 #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 -│ │ └─ 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"' } -│ ├─ [_min]: 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"' } -│ ├─ [_max]: 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"' } -│ ├─ [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"' } -│ └─ [posts]: optional '_SortByAggregates' #151 -│ └─ item: struct #150 -│ ├─ [_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"' } -│ ├─ [_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"' } -│ ├─ [_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"' } -│ ├─ [_min]: 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"' } -│ └─ [_max]: 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 +├── [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 +│ │ │ └── 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"' } +│ │ └── [posts]: 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"' } +│ ├── [_max]: 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"' } +│ ├── [_min]: 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 +│ │ └── 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"' } +│ ├── [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"' } +│ └── [posts]: optional '_SortByAggregates' #151 +│ └── item: struct #150 +│ ├── [_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"' } +│ ├── [_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"' } +│ ├── [_max]: 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"' } +│ ├── [_min]: 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 +│ └── item: union #46 +│ ├── variant_0: struct #45 +│ │ └── [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ └── variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +├── [skip]: optional '_156__Skip?' #156 +│ └── item: integer '_Skip' #61 +├── [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..d45bd36e2 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 @@ -3,30 +3,30 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(out)" --- root: list '_User_GroupByResult' #200 -└─ item: struct #199 - ├─ [id]: integer #114 - ├─ [name]: string #115 - ├─ [posts]: list '_117_Post[]' #117 - │ └─ item: &Post #116 - ├─ [_count]: struct '_User_AggrCount' #190 - │ ├─ [_all]: optional #189 - │ │ └─ item: integer #188 - │ ├─ [id]: optional #189 - │ │ └─ item: integer #188 - │ ├─ [name]: optional #189 - │ │ └─ 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 - │ └─ [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 +└── item: struct #199 + ├── [_avg]: struct '_User_SelectNumbers__1' #193 + │ └── [id]: optional #192 + │ └── item: float #191 + ├── [_count]: struct '_User_AggrCount' #190 + │ ├── [_all]: optional #189 + │ │ └── item: integer #188 + │ ├── [id]: optional #189 + │ │ └── item: integer #188 + │ ├── [name]: optional #189 + │ │ └── item: integer #188 + │ └── [posts]: optional #189 + │ └── item: integer #188 + ├── [_max]: struct '_User_SelectNumbers_' #198 + │ └── [id]: optional #197 + │ └── item: integer #196 + ├── [_min]: 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..02da9b58f 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 @@ -3,1070 +3,1070 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #182 -├─ [data]: struct '_Post_UpdateInput' #175 -│ ├─ [id]: optional #153 -│ │ └─ item: union #152 -│ │ ├─ variant_0: integer #62 -│ │ ├─ variant_1: struct #148 -│ │ │ └─ [set]: integer #62 -│ │ ├─ variant_2: struct #149 -│ │ │ └─ [multiply]: integer #62 -│ │ ├─ variant_3: struct #150 -│ │ │ └─ [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 -└─ [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 - ├─ [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 - ├─ [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 +├── [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 +│ │ ├── variant_1: struct #148 +│ │ │ └── [set]: integer #62 +│ │ ├── variant_2: struct #149 +│ │ │ └── [multiply]: integer #62 +│ │ ├── variant_3: struct #150 +│ │ │ └── [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 +└── [where]: optional '_181_QueryPostWhereInput?' #181 + └── item: struct 'QueryPostWhereInput' #180 + ├── [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 + │ │ └── 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 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..922a7f937 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 @@ -3,184 +3,184 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #56 -├─ [data]: struct '_Record_UpdateInput' #17 -│ ├─ [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 -└─ [where]: optional '_55_QueryRecordWhereInput?' #55 - └─ item: struct 'QueryRecordWhereInput' #54 - ├─ [id]: optional '_34__string_filter_c?' #34 - │ └─ 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 - ├─ [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 +├── [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 +└── [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 + │ ├── 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 + └── [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..688d4144f 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 @@ -3,2169 +3,2169 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #147 -├─ [data]: struct '_User_UpdateInput' #124 -│ ├─ [id]: optional #71 -│ │ └─ item: union #70 -│ │ ├─ variant_0: integer #57 -│ │ ├─ variant_1: struct #66 -│ │ │ └─ [set]: integer #57 -│ │ ├─ variant_2: struct #67 -│ │ │ └─ [multiply]: integer #57 -│ │ ├─ variant_3: struct #68 -│ │ │ └─ [decrement]: integer #57 -│ │ └─ variant_4: struct #69 -│ │ └─ [increment]: integer #57 -│ ├─ [name]: optional #74 -│ │ └─ item: union #73 -│ │ ├─ variant_0: string #58 -│ │ └─ variant_1: struct #72 -│ │ └─ [set]: string #58 -│ └─ [posts]: optional #123 -│ └─ item: union #122 -│ ├─ variant_0: struct #98 -│ │ └─ [create]: union #78 -│ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ │ │ ├─ [id]: optional #75 -│ │ │ │ └─ item: integer #62 -│ │ │ └─ [title]: string #63 -│ │ └─ variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 -│ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ │ ├─ [id]: optional #75 -│ │ │ └─ item: integer #62 -│ │ └─ [title]: string #63 -│ ├─ variant_1: struct #99 -│ │ └─ [connect]: 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 -│ ├─ variant_2: struct #100 -│ │ └─ [connectOrCreate]: struct #97 -│ │ ├─ [create]: union #78 -│ │ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ │ │ │ ├─ [id]: optional #75 -│ │ │ │ │ └─ item: integer #62 -│ │ │ │ └─ [title]: string #63 -│ │ │ └─ variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 -│ │ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ │ │ ├─ [id]: optional #75 -│ │ │ │ └─ item: integer #62 -│ │ │ └─ [title]: string #63 -│ │ └─ [where]: 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 -│ ├─ variant_3: struct #111 -│ │ └─ [update]: 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 -│ ├─ 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 -│ ├─ variant_5: struct #117 -│ │ └─ [deleteMany]: struct #116 -│ │ └─ [where]: optional #115 -│ │ └─ 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 -│ └─ variant_6: struct #121 -│ └─ [createMany]: optional #120 -│ └─ item: struct #119 -│ └─ [data]: list #118 -│ └─ item: union #78 -│ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ │ ├─ [id]: optional #75 -│ │ │ └─ item: integer #62 -│ │ └─ [title]: string #63 -│ └─ variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 -│ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ ├─ [id]: optional #75 -│ │ └─ item: integer #62 -│ └─ [title]: string #63 -└─ [where]: optional '_146_QueryUserWhereInput?' #146 - └─ item: struct 'QueryUserWhereInput' #145 - ├─ [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 - ├─ [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 +├── [data]: struct '_User_UpdateInput' #124 +│ ├── [id]: optional #71 +│ │ └── item: union #70 +│ │ ├── variant_0: integer #57 +│ │ ├── variant_1: struct #66 +│ │ │ └── [set]: integer #57 +│ │ ├── variant_2: struct #67 +│ │ │ └── [multiply]: integer #57 +│ │ ├── variant_3: struct #68 +│ │ │ └── [decrement]: integer #57 +│ │ └── variant_4: struct #69 +│ │ └── [increment]: integer #57 +│ ├── [name]: optional #74 +│ │ └── item: union #73 +│ │ ├── variant_0: string #58 +│ │ └── variant_1: struct #72 +│ │ └── [set]: string #58 +│ └── [posts]: optional #123 +│ └── item: union #122 +│ ├── variant_0: struct #98 +│ │ └── [create]: union #78 +│ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ │ │ ├── [id]: optional #75 +│ │ │ │ └── item: integer #62 +│ │ │ └── [title]: string #63 +│ │ └── variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 +│ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ │ ├── [id]: optional #75 +│ │ │ └── item: integer #62 +│ │ └── [title]: string #63 +│ ├── 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 +│ │ │ │ ├── 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_2: struct #100 +│ │ └── [connectOrCreate]: struct #97 +│ │ ├── [create]: union #78 +│ │ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ │ │ │ ├── [id]: optional #75 +│ │ │ │ │ └── item: integer #62 +│ │ │ │ └── [title]: string #63 +│ │ │ └── variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 +│ │ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ │ │ ├── [id]: optional #75 +│ │ │ │ └── item: integer #62 +│ │ │ └── [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 +│ │ │ │ ├── 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_3: struct #111 +│ │ └── [update]: 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 +│ ├── variant_4: struct #114 +│ │ └── [updateMany]: struct #113 +│ │ ├── [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 +│ │ │ │ ├── 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_6: struct #121 +│ └── [createMany]: optional #120 +│ └── item: struct #119 +│ └── [data]: list #118 +│ └── item: union #78 +│ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ │ ├── [id]: optional #75 +│ │ │ └── item: integer #62 +│ │ └── [title]: string #63 +│ └── variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 +│ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ ├── [id]: optional #75 +│ │ └── item: integer #62 +│ └── [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 + │ ├── 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 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 47bff2595..50d485010 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 @@ -3,858 +3,858 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #166 -├─ [data]: struct '_Post_UpdateInput' #163 -│ ├─ [id]: optional #125 -│ │ └─ item: union #124 -│ │ ├─ variant_0: integer #26 -│ │ ├─ variant_1: struct #120 -│ │ │ └─ [set]: integer #26 -│ │ ├─ variant_2: struct #121 -│ │ │ └─ [multiply]: integer #26 -│ │ ├─ variant_3: struct #122 -│ │ │ └─ [decrement]: integer #26 -│ │ └─ variant_4: struct #123 -│ │ └─ [increment]: integer #26 -│ ├─ [title]: optional #128 -│ │ └─ item: union #127 -│ │ ├─ variant_0: string #27 -│ │ └─ variant_1: struct #126 -│ │ └─ [set]: string #27 -│ └─ [author]: optional #162 -│ └─ item: union #161 -│ ├─ variant_0: struct #147 -│ │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #129 -│ │ ├─ [id]: integer #21 -│ │ └─ [name]: string #22 -│ ├─ variant_1: struct #148 -│ │ └─ [connect]: struct 'UserWhere' #145 -│ │ ├─ [id]: optional '_130__integer_filter_c?' #130 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [gte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ ├─ [name]: optional '_131__string_filter_c?' #131 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [posts]: optional #144 -│ │ └─ item: union #143 -│ │ ├─ variant_0: struct #138 -│ │ │ └─ [every]: optional '_137_PostWhere__skip_25_UserWhere?' #137 -│ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [author]: optional '_135_UserWhere?' #135 -│ │ │ └─ item: &UserWhere #134 -│ │ ├─ variant_1: struct #140 -│ │ │ └─ [some]: optional '_139_PostWhere__skip_25_UserWhere?' #139 -│ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [author]: optional '_135_UserWhere?' #135 -│ │ │ └─ item: &UserWhere #134 -│ │ └─ variant_2: struct #142 -│ │ └─ [none]: optional '_141_PostWhere__skip_25_UserWhere?' #141 -│ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [gte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ ├─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [author]: optional '_135_UserWhere?' #135 -│ │ └─ item: &UserWhere #134 -│ ├─ variant_2: struct #149 -│ │ └─ [connectOrCreate]: struct #146 -│ │ ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #129 -│ │ │ ├─ [id]: integer #21 -│ │ │ └─ [name]: string #22 -│ │ └─ [where]: struct 'UserWhere' #145 -│ │ ├─ [id]: optional '_130__integer_filter_c?' #130 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [gte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ ├─ [name]: optional '_131__string_filter_c?' #131 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [posts]: optional #144 -│ │ └─ item: union #143 -│ │ ├─ variant_0: struct #138 -│ │ │ └─ [every]: optional '_137_PostWhere__skip_25_UserWhere?' #137 -│ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [author]: optional '_135_UserWhere?' #135 -│ │ │ └─ item: &UserWhere #134 -│ │ ├─ variant_1: struct #140 -│ │ │ └─ [some]: optional '_139_PostWhere__skip_25_UserWhere?' #139 -│ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [author]: optional '_135_UserWhere?' #135 -│ │ │ └─ item: &UserWhere #134 -│ │ └─ variant_2: struct #142 -│ │ └─ [none]: optional '_141_PostWhere__skip_25_UserWhere?' #141 -│ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [gte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ ├─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [author]: optional '_135_UserWhere?' #135 -│ │ └─ item: &UserWhere #134 -│ └─ variant_3: struct #160 -│ └─ [update]: struct '_User_UpdateInput_excluding___rel_Post_User_1' #159 -│ ├─ [id]: optional #155 -│ │ └─ item: union #154 -│ │ ├─ variant_0: integer #21 -│ │ ├─ variant_1: struct #150 -│ │ │ └─ [set]: integer #21 -│ │ ├─ variant_2: struct #151 -│ │ │ └─ [multiply]: integer #21 -│ │ ├─ variant_3: struct #152 -│ │ │ └─ [decrement]: integer #21 -│ │ └─ variant_4: struct #153 -│ │ └─ [increment]: integer #21 -│ └─ [name]: optional #158 -│ └─ item: union #157 -│ ├─ variant_0: string #22 -│ └─ variant_1: struct #156 -│ └─ [set]: string #22 -└─ [where]: struct 'QueryUniquePostWhereInput' #165 - └─ [id]: optional #164 - └─ item: integer #26 +├── [data]: struct '_Post_UpdateInput' #163 +│ ├── [author]: optional #162 +│ │ └── item: union #161 +│ │ ├── variant_0: struct #147 +│ │ │ └── [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #129 +│ │ │ ├── [id]: integer #21 +│ │ │ └── [name]: string #22 +│ │ ├── variant_1: struct #148 +│ │ │ └── [connect]: struct 'UserWhere' #145 +│ │ │ ├── [id]: optional '_130__integer_filter_c?' #130 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ ├── [name]: optional '_131__string_filter_c?' #131 +│ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ └── item: union #70 +│ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── variant_1: struct #69 +│ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [posts]: optional #144 +│ │ │ └── item: union #143 +│ │ │ ├── variant_0: struct #138 +│ │ │ │ └── [every]: optional '_137_PostWhere__skip_25_UserWhere?' #137 +│ │ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ │ ├── [author]: optional '_135_UserWhere?' #135 +│ │ │ │ │ └── item: &UserWhere #134 +│ │ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ │ └── item: union #53 +│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_1: struct #52 +│ │ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── [title]: optional '_133__string_filter_c?' #133 +│ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ └── item: union #70 +│ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── variant_1: struct #69 +│ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_1: struct #140 +│ │ │ │ └── [some]: optional '_139_PostWhere__skip_25_UserWhere?' #139 +│ │ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ │ ├── [author]: optional '_135_UserWhere?' #135 +│ │ │ │ │ └── item: &UserWhere #134 +│ │ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ │ └── item: union #53 +│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_1: struct #52 +│ │ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── [title]: optional '_133__string_filter_c?' #133 +│ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ └── item: union #70 +│ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── variant_1: struct #69 +│ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── variant_2: struct #142 +│ │ │ └── [none]: optional '_141_PostWhere__skip_25_UserWhere?' #141 +│ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ ├── [author]: optional '_135_UserWhere?' #135 +│ │ │ │ └── item: &UserWhere #134 +│ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── [title]: optional '_133__string_filter_c?' #133 +│ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ └── item: union #70 +│ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── variant_1: struct #69 +│ │ │ └── [not]: union '_string_filter' #68 +│ │ │ ├── variant_0: string #56 +│ │ │ ├── variant_1: struct #59 +│ │ │ │ └── [equals]: string #56 +│ │ │ ├── variant_2: struct #60 +│ │ │ │ └── [not]: string #56 +│ │ │ ├── variant_3: struct #61 +│ │ │ │ └── [in]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_4: struct #62 +│ │ │ │ └── [notIn]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_5: struct #65 +│ │ │ │ ├── [contains]: string #56 +│ │ │ │ └── [mode]: optional #64 +│ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #66 +│ │ │ │ └── [search]: string #56 +│ │ │ └── variant_7: struct #67 +│ │ │ ├── [endsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [startsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ ├── variant_2: struct #149 +│ │ │ └── [connectOrCreate]: struct #146 +│ │ │ ├── [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #129 +│ │ │ │ ├── [id]: integer #21 +│ │ │ │ └── [name]: string #22 +│ │ │ └── [where]: struct 'UserWhere' #145 +│ │ │ ├── [id]: optional '_130__integer_filter_c?' #130 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ ├── [name]: optional '_131__string_filter_c?' #131 +│ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ └── item: union #70 +│ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── variant_1: struct #69 +│ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [posts]: optional #144 +│ │ │ └── item: union #143 +│ │ │ ├── variant_0: struct #138 +│ │ │ │ └── [every]: optional '_137_PostWhere__skip_25_UserWhere?' #137 +│ │ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ │ ├── [author]: optional '_135_UserWhere?' #135 +│ │ │ │ │ └── item: &UserWhere #134 +│ │ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ │ └── item: union #53 +│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_1: struct #52 +│ │ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── [title]: optional '_133__string_filter_c?' #133 +│ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ └── item: union #70 +│ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── variant_1: struct #69 +│ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_1: struct #140 +│ │ │ │ └── [some]: optional '_139_PostWhere__skip_25_UserWhere?' #139 +│ │ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ │ ├── [author]: optional '_135_UserWhere?' #135 +│ │ │ │ │ └── item: &UserWhere #134 +│ │ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ │ └── item: union #53 +│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_1: struct #52 +│ │ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── [title]: optional '_133__string_filter_c?' #133 +│ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ └── item: union #70 +│ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── variant_1: struct #69 +│ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── variant_2: struct #142 +│ │ │ └── [none]: optional '_141_PostWhere__skip_25_UserWhere?' #141 +│ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ ├── [author]: optional '_135_UserWhere?' #135 +│ │ │ │ └── item: &UserWhere #134 +│ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── [title]: optional '_133__string_filter_c?' #133 +│ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ └── item: union #70 +│ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── variant_1: struct #69 +│ │ │ └── [not]: union '_string_filter' #68 +│ │ │ ├── variant_0: string #56 +│ │ │ ├── variant_1: struct #59 +│ │ │ │ └── [equals]: string #56 +│ │ │ ├── variant_2: struct #60 +│ │ │ │ └── [not]: string #56 +│ │ │ ├── variant_3: struct #61 +│ │ │ │ └── [in]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_4: struct #62 +│ │ │ │ └── [notIn]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_5: struct #65 +│ │ │ │ ├── [contains]: string #56 +│ │ │ │ └── [mode]: optional #64 +│ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #66 +│ │ │ │ └── [search]: string #56 +│ │ │ └── variant_7: struct #67 +│ │ │ ├── [endsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [startsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── variant_3: struct #160 +│ │ └── [update]: struct '_User_UpdateInput_excluding___rel_Post_User_1' #159 +│ │ ├── [id]: optional #155 +│ │ │ └── item: union #154 +│ │ │ ├── variant_0: integer #21 +│ │ │ ├── variant_1: struct #150 +│ │ │ │ └── [set]: integer #21 +│ │ │ ├── variant_2: struct #151 +│ │ │ │ └── [multiply]: integer #21 +│ │ │ ├── variant_3: struct #152 +│ │ │ │ └── [decrement]: integer #21 +│ │ │ └── variant_4: struct #153 +│ │ │ └── [increment]: integer #21 +│ │ └── [name]: optional #158 +│ │ └── item: union #157 +│ │ ├── variant_0: string #22 +│ │ └── variant_1: struct #156 +│ │ └── [set]: string #22 +│ ├── [id]: optional #125 +│ │ └── item: union #124 +│ │ ├── variant_0: integer #26 +│ │ ├── variant_1: struct #120 +│ │ │ └── [set]: integer #26 +│ │ ├── variant_2: struct #121 +│ │ │ └── [multiply]: integer #26 +│ │ ├── variant_3: struct #122 +│ │ │ └── [decrement]: integer #26 +│ │ └── variant_4: struct #123 +│ │ └── [increment]: integer #26 +│ └── [title]: optional #128 +│ └── item: union #127 +│ ├── variant_0: string #27 +│ └── variant_1: struct #126 +│ └── [set]: string #27 +└── [where]: struct 'QueryUniquePostWhereInput' #165 + └── [id]: optional #164 + └── item: integer #26 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 7ea462bbb..3a55f13ad 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 @@ -3,31 +3,31 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #20 -├─ [data]: struct '_Record_UpdateInput' #17 -│ ├─ [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 -└─ [where]: struct 'QueryUniqueRecordWhereInput' #19 - └─ [id]: optional #18 - └─ item: string #0 +├── [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 +└── [where]: struct 'QueryUniqueRecordWhereInput' #19 + └── [id]: optional #18 + └── item: string #0 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 e94f4bf67..f892b46f7 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 @@ -3,1761 +3,1761 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: "tree::print(inp)" --- root: struct #119 -├─ [data]: struct '_User_UpdateInput' #116 -│ ├─ [id]: optional #35 -│ │ └─ item: union #34 -│ │ ├─ variant_0: integer #21 -│ │ ├─ variant_1: struct #30 -│ │ │ └─ [set]: integer #21 -│ │ ├─ variant_2: struct #31 -│ │ │ └─ [multiply]: integer #21 -│ │ ├─ variant_3: struct #32 -│ │ │ └─ [decrement]: integer #21 -│ │ └─ variant_4: struct #33 -│ │ └─ [increment]: integer #21 -│ ├─ [name]: optional #38 -│ │ └─ item: union #37 -│ │ ├─ variant_0: string #22 -│ │ └─ variant_1: struct #36 -│ │ └─ [set]: string #22 -│ └─ [posts]: optional #115 -│ └─ item: union #114 -│ ├─ variant_0: struct #90 -│ │ └─ [create]: union #42 -│ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ │ ├─ [id]: optional #39 -│ │ │ │ └─ item: integer #26 -│ │ │ └─ [title]: string #27 -│ │ └─ variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 -│ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ ├─ [id]: optional #39 -│ │ │ └─ item: integer #26 -│ │ └─ [title]: string #27 -│ ├─ variant_1: struct #91 -│ │ └─ [connect]: union #88 -│ │ ├─ variant_0: struct 'PostWhere' #86 -│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [posts]: optional #83 -│ │ │ └─ item: union #82 -│ │ │ ├─ variant_0: struct #77 -│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ variant_1: struct #79 -│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ └─ variant_2: struct #81 -│ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ └─ item: &PostWhere #75 -│ │ └─ variant_1: list '_87_PostWhere[]' #87 -│ │ └─ item: struct 'PostWhere' #86 -│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [gte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ ├─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [gte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [posts]: optional #83 -│ │ └─ item: union #82 -│ │ ├─ variant_0: struct #77 -│ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ └─ item: &PostWhere #75 -│ │ ├─ variant_1: struct #79 -│ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ └─ item: &PostWhere #75 -│ │ └─ variant_2: struct #81 -│ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ └─ item: &PostWhere #75 -│ ├─ variant_2: struct #92 -│ │ └─ [connectOrCreate]: struct #89 -│ │ ├─ [create]: union #42 -│ │ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ │ │ ├─ [id]: optional #39 -│ │ │ │ │ └─ item: integer #26 -│ │ │ │ └─ [title]: string #27 -│ │ │ └─ variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 -│ │ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ │ ├─ [id]: optional #39 -│ │ │ │ └─ item: integer #26 -│ │ │ └─ [title]: string #27 -│ │ └─ [where]: union #88 -│ │ ├─ variant_0: struct 'PostWhere' #86 -│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [posts]: optional #83 -│ │ │ └─ item: union #82 -│ │ │ ├─ variant_0: struct #77 -│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ variant_1: struct #79 -│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ └─ variant_2: struct #81 -│ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ └─ item: &PostWhere #75 -│ │ └─ variant_1: list '_87_PostWhere[]' #87 -│ │ └─ item: struct 'PostWhere' #86 -│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [gte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ ├─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [gte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [posts]: optional #83 -│ │ └─ item: union #82 -│ │ ├─ variant_0: struct #77 -│ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ └─ item: &PostWhere #75 -│ │ ├─ variant_1: struct #79 -│ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ └─ item: &PostWhere #75 -│ │ └─ variant_2: struct #81 -│ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ └─ item: &PostWhere #75 -│ ├─ variant_3: struct #103 -│ │ └─ [update]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #102 -│ │ ├─ [id]: optional #98 -│ │ │ └─ item: union #97 -│ │ │ ├─ variant_0: integer #26 -│ │ │ ├─ variant_1: struct #93 -│ │ │ │ └─ [set]: integer #26 -│ │ │ ├─ variant_2: struct #94 -│ │ │ │ └─ [multiply]: integer #26 -│ │ │ ├─ variant_3: struct #95 -│ │ │ │ └─ [decrement]: integer #26 -│ │ │ └─ variant_4: struct #96 -│ │ │ └─ [increment]: integer #26 -│ │ └─ [title]: optional #101 -│ │ └─ item: union #100 -│ │ ├─ variant_0: string #27 -│ │ └─ variant_1: struct #99 -│ │ └─ [set]: string #27 -│ ├─ variant_4: struct #106 -│ │ └─ [updateMany]: struct #105 -│ │ ├─ [where]: optional #104 -│ │ │ └─ item: union #88 -│ │ │ ├─ variant_0: struct 'PostWhere' #86 -│ │ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ │ └─ item: union #53 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_1: struct #52 -│ │ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ │ └─ item: union #70 -│ │ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ variant_1: struct #69 -│ │ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ │ └─ item: union #53 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_1: struct #52 -│ │ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ │ └─ item: union #70 -│ │ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ variant_1: struct #69 -│ │ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [posts]: optional #83 -│ │ │ │ └─ item: union #82 -│ │ │ │ ├─ variant_0: struct #77 -│ │ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ │ └─ item: &PostWhere #75 -│ │ │ │ ├─ variant_1: struct #79 -│ │ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ │ └─ item: &PostWhere #75 -│ │ │ │ └─ variant_2: struct #81 -│ │ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ └─ variant_1: list '_87_PostWhere[]' #87 -│ │ │ └─ item: struct 'PostWhere' #86 -│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [posts]: optional #83 -│ │ │ └─ item: union #82 -│ │ │ ├─ variant_0: struct #77 -│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ variant_1: struct #79 -│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ └─ variant_2: struct #81 -│ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ └─ item: &PostWhere #75 -│ │ └─ [data]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #102 -│ │ ├─ [id]: optional #98 -│ │ │ └─ item: union #97 -│ │ │ ├─ variant_0: integer #26 -│ │ │ ├─ variant_1: struct #93 -│ │ │ │ └─ [set]: integer #26 -│ │ │ ├─ variant_2: struct #94 -│ │ │ │ └─ [multiply]: integer #26 -│ │ │ ├─ variant_3: struct #95 -│ │ │ │ └─ [decrement]: integer #26 -│ │ │ └─ variant_4: struct #96 -│ │ │ └─ [increment]: integer #26 -│ │ └─ [title]: optional #101 -│ │ └─ item: union #100 -│ │ ├─ variant_0: string #27 -│ │ └─ variant_1: struct #99 -│ │ └─ [set]: string #27 -│ ├─ variant_5: struct #109 -│ │ └─ [deleteMany]: struct #108 -│ │ └─ [where]: optional #107 -│ │ └─ item: union #88 -│ │ ├─ variant_0: struct 'PostWhere' #86 -│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [posts]: optional #83 -│ │ │ └─ item: union #82 -│ │ │ ├─ variant_0: struct #77 -│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ variant_1: struct #79 -│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ └─ variant_2: struct #81 -│ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ └─ item: &PostWhere #75 -│ │ └─ variant_1: list '_87_PostWhere[]' #87 -│ │ └─ item: struct 'PostWhere' #86 -│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [gte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ ├─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [gte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [posts]: optional #83 -│ │ └─ item: union #82 -│ │ ├─ variant_0: struct #77 -│ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ └─ item: &PostWhere #75 -│ │ ├─ variant_1: struct #79 -│ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ └─ item: &PostWhere #75 -│ │ └─ variant_2: struct #81 -│ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ └─ item: &PostWhere #75 -│ └─ variant_6: struct #113 -│ └─ [createMany]: optional #112 -│ └─ item: struct #111 -│ └─ [data]: list #110 -│ └─ item: union #42 -│ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ ├─ [id]: optional #39 -│ │ │ └─ item: integer #26 -│ │ └─ [title]: string #27 -│ └─ variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 -│ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ ├─ [id]: optional #39 -│ │ └─ item: integer #26 -│ └─ [title]: string #27 -└─ [where]: struct 'QueryUniqueUserWhereInput' #118 - └─ [id]: optional #117 - └─ item: integer #21 +├── [data]: struct '_User_UpdateInput' #116 +│ ├── [id]: optional #35 +│ │ └── item: union #34 +│ │ ├── variant_0: integer #21 +│ │ ├── variant_1: struct #30 +│ │ │ └── [set]: integer #21 +│ │ ├── variant_2: struct #31 +│ │ │ └── [multiply]: integer #21 +│ │ ├── variant_3: struct #32 +│ │ │ └── [decrement]: integer #21 +│ │ └── variant_4: struct #33 +│ │ └── [increment]: integer #21 +│ ├── [name]: optional #38 +│ │ └── item: union #37 +│ │ ├── variant_0: string #22 +│ │ └── variant_1: struct #36 +│ │ └── [set]: string #22 +│ └── [posts]: optional #115 +│ └── item: union #114 +│ ├── variant_0: struct #90 +│ │ └── [create]: union #42 +│ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ │ │ ├── [id]: optional #39 +│ │ │ │ └── item: integer #26 +│ │ │ └── [title]: string #27 +│ │ └── variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 +│ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ │ ├── [id]: optional #39 +│ │ │ └── item: integer #26 +│ │ └── [title]: string #27 +│ ├── variant_1: struct #91 +│ │ └── [connect]: union #88 +│ │ ├── variant_0: struct 'PostWhere' #86 +│ │ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ │ └── item: union #53 +│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_1: struct #52 +│ │ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ │ └── item: union #70 +│ │ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── variant_1: struct #69 +│ │ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [posts]: optional #83 +│ │ │ │ └── item: union #82 +│ │ │ │ ├── variant_0: struct #77 +│ │ │ │ │ └── [every]: optional '_76_PostWhere?' #76 +│ │ │ │ │ └── item: &PostWhere #75 +│ │ │ │ ├── variant_1: struct #79 +│ │ │ │ │ └── [some]: optional '_78_PostWhere?' #78 +│ │ │ │ │ └── item: &PostWhere #75 +│ │ │ │ └── variant_2: struct #81 +│ │ │ │ └── [none]: optional '_80_PostWhere?' #80 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ ├── [id]: optional '_55__integer_filter_c?' #55 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── [title]: optional '_72__string_filter_c?' #72 +│ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ └── item: union #70 +│ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── variant_1: struct #69 +│ │ │ └── [not]: union '_string_filter' #68 +│ │ │ ├── variant_0: string #56 +│ │ │ ├── variant_1: struct #59 +│ │ │ │ └── [equals]: string #56 +│ │ │ ├── variant_2: struct #60 +│ │ │ │ └── [not]: string #56 +│ │ │ ├── variant_3: struct #61 +│ │ │ │ └── [in]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_4: struct #62 +│ │ │ │ └── [notIn]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_5: struct #65 +│ │ │ │ ├── [contains]: string #56 +│ │ │ │ └── [mode]: optional #64 +│ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #66 +│ │ │ │ └── [search]: string #56 +│ │ │ └── variant_7: struct #67 +│ │ │ ├── [endsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [startsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── variant_1: list '_87_PostWhere[]' #87 +│ │ └── item: struct 'PostWhere' #86 +│ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ ├── [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ └── item: union #70 +│ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── variant_1: struct #69 +│ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [posts]: optional #83 +│ │ │ └── item: union #82 +│ │ │ ├── variant_0: struct #77 +│ │ │ │ └── [every]: optional '_76_PostWhere?' #76 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ ├── variant_1: struct #79 +│ │ │ │ └── [some]: optional '_78_PostWhere?' #78 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ └── variant_2: struct #81 +│ │ │ └── [none]: optional '_80_PostWhere?' #80 +│ │ │ └── item: &PostWhere #75 +│ │ ├── [id]: optional '_55__integer_filter_c?' #55 +│ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ └── item: union #53 +│ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── variant_1: struct #52 +│ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ ├── variant_0: integer #43 +│ │ │ ├── variant_1: struct #46 +│ │ │ │ └── [equals]: integer #43 +│ │ │ ├── variant_2: struct #47 +│ │ │ │ └── [not]: integer #43 +│ │ │ ├── variant_3: struct #48 +│ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── [lte]: optional #44 +│ │ │ │ └── item: integer #43 +│ │ │ ├── variant_4: struct #49 +│ │ │ │ └── [in]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── variant_5: struct #50 +│ │ │ └── [notIn]: list #45 +│ │ │ └── item: integer #43 +│ │ └── [title]: optional '_72__string_filter_c?' #72 +│ │ └── item: optional '_string_filter_c' #71 +│ │ └── item: union #70 +│ │ ├── variant_0: union '_string_filter' #68 +│ │ │ ├── variant_0: string #56 +│ │ │ ├── variant_1: struct #59 +│ │ │ │ └── [equals]: string #56 +│ │ │ ├── variant_2: struct #60 +│ │ │ │ └── [not]: string #56 +│ │ │ ├── variant_3: struct #61 +│ │ │ │ └── [in]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_4: struct #62 +│ │ │ │ └── [notIn]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_5: struct #65 +│ │ │ │ ├── [contains]: string #56 +│ │ │ │ └── [mode]: optional #64 +│ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #66 +│ │ │ │ └── [search]: string #56 +│ │ │ └── variant_7: struct #67 +│ │ │ ├── [endsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [startsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── variant_1: struct #69 +│ │ └── [not]: union '_string_filter' #68 +│ │ ├── variant_0: string #56 +│ │ ├── variant_1: struct #59 +│ │ │ └── [equals]: string #56 +│ │ ├── variant_2: struct #60 +│ │ │ └── [not]: string #56 +│ │ ├── variant_3: struct #61 +│ │ │ └── [in]: list #58 +│ │ │ └── item: string #56 +│ │ ├── variant_4: struct #62 +│ │ │ └── [notIn]: list #58 +│ │ │ └── item: string #56 +│ │ ├── variant_5: struct #65 +│ │ │ ├── [contains]: string #56 +│ │ │ └── [mode]: optional #64 +│ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ ├── variant_6: struct #66 +│ │ │ └── [search]: string #56 +│ │ └── variant_7: struct #67 +│ │ ├── [endsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── [startsWith]: optional #57 +│ │ └── item: string #56 +│ ├── variant_2: struct #92 +│ │ └── [connectOrCreate]: struct #89 +│ │ ├── [create]: union #42 +│ │ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ │ │ │ ├── [id]: optional #39 +│ │ │ │ │ └── item: integer #26 +│ │ │ │ └── [title]: string #27 +│ │ │ └── variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 +│ │ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ │ │ ├── [id]: optional #39 +│ │ │ │ └── item: integer #26 +│ │ │ └── [title]: string #27 +│ │ └── [where]: union #88 +│ │ ├── variant_0: struct 'PostWhere' #86 +│ │ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ │ └── item: union #53 +│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_1: struct #52 +│ │ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ │ └── item: union #70 +│ │ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── variant_1: struct #69 +│ │ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [posts]: optional #83 +│ │ │ │ └── item: union #82 +│ │ │ │ ├── variant_0: struct #77 +│ │ │ │ │ └── [every]: optional '_76_PostWhere?' #76 +│ │ │ │ │ └── item: &PostWhere #75 +│ │ │ │ ├── variant_1: struct #79 +│ │ │ │ │ └── [some]: optional '_78_PostWhere?' #78 +│ │ │ │ │ └── item: &PostWhere #75 +│ │ │ │ └── variant_2: struct #81 +│ │ │ │ └── [none]: optional '_80_PostWhere?' #80 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ ├── [id]: optional '_55__integer_filter_c?' #55 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── [title]: optional '_72__string_filter_c?' #72 +│ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ └── item: union #70 +│ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── variant_1: struct #69 +│ │ │ └── [not]: union '_string_filter' #68 +│ │ │ ├── variant_0: string #56 +│ │ │ ├── variant_1: struct #59 +│ │ │ │ └── [equals]: string #56 +│ │ │ ├── variant_2: struct #60 +│ │ │ │ └── [not]: string #56 +│ │ │ ├── variant_3: struct #61 +│ │ │ │ └── [in]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_4: struct #62 +│ │ │ │ └── [notIn]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_5: struct #65 +│ │ │ │ ├── [contains]: string #56 +│ │ │ │ └── [mode]: optional #64 +│ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #66 +│ │ │ │ └── [search]: string #56 +│ │ │ └── variant_7: struct #67 +│ │ │ ├── [endsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [startsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── variant_1: list '_87_PostWhere[]' #87 +│ │ └── item: struct 'PostWhere' #86 +│ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ ├── [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ └── item: union #70 +│ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── variant_1: struct #69 +│ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [posts]: optional #83 +│ │ │ └── item: union #82 +│ │ │ ├── variant_0: struct #77 +│ │ │ │ └── [every]: optional '_76_PostWhere?' #76 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ ├── variant_1: struct #79 +│ │ │ │ └── [some]: optional '_78_PostWhere?' #78 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ └── variant_2: struct #81 +│ │ │ └── [none]: optional '_80_PostWhere?' #80 +│ │ │ └── item: &PostWhere #75 +│ │ ├── [id]: optional '_55__integer_filter_c?' #55 +│ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ └── item: union #53 +│ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── variant_1: struct #52 +│ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ ├── variant_0: integer #43 +│ │ │ ├── variant_1: struct #46 +│ │ │ │ └── [equals]: integer #43 +│ │ │ ├── variant_2: struct #47 +│ │ │ │ └── [not]: integer #43 +│ │ │ ├── variant_3: struct #48 +│ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── [lte]: optional #44 +│ │ │ │ └── item: integer #43 +│ │ │ ├── variant_4: struct #49 +│ │ │ │ └── [in]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── variant_5: struct #50 +│ │ │ └── [notIn]: list #45 +│ │ │ └── item: integer #43 +│ │ └── [title]: optional '_72__string_filter_c?' #72 +│ │ └── item: optional '_string_filter_c' #71 +│ │ └── item: union #70 +│ │ ├── variant_0: union '_string_filter' #68 +│ │ │ ├── variant_0: string #56 +│ │ │ ├── variant_1: struct #59 +│ │ │ │ └── [equals]: string #56 +│ │ │ ├── variant_2: struct #60 +│ │ │ │ └── [not]: string #56 +│ │ │ ├── variant_3: struct #61 +│ │ │ │ └── [in]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_4: struct #62 +│ │ │ │ └── [notIn]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_5: struct #65 +│ │ │ │ ├── [contains]: string #56 +│ │ │ │ └── [mode]: optional #64 +│ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #66 +│ │ │ │ └── [search]: string #56 +│ │ │ └── variant_7: struct #67 +│ │ │ ├── [endsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [startsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── variant_1: struct #69 +│ │ └── [not]: union '_string_filter' #68 +│ │ ├── variant_0: string #56 +│ │ ├── variant_1: struct #59 +│ │ │ └── [equals]: string #56 +│ │ ├── variant_2: struct #60 +│ │ │ └── [not]: string #56 +│ │ ├── variant_3: struct #61 +│ │ │ └── [in]: list #58 +│ │ │ └── item: string #56 +│ │ ├── variant_4: struct #62 +│ │ │ └── [notIn]: list #58 +│ │ │ └── item: string #56 +│ │ ├── variant_5: struct #65 +│ │ │ ├── [contains]: string #56 +│ │ │ └── [mode]: optional #64 +│ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ ├── variant_6: struct #66 +│ │ │ └── [search]: string #56 +│ │ └── variant_7: struct #67 +│ │ ├── [endsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── [startsWith]: optional #57 +│ │ └── item: string #56 +│ ├── variant_3: struct #103 +│ │ └── [update]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #102 +│ │ ├── [id]: optional #98 +│ │ │ └── item: union #97 +│ │ │ ├── variant_0: integer #26 +│ │ │ ├── variant_1: struct #93 +│ │ │ │ └── [set]: integer #26 +│ │ │ ├── variant_2: struct #94 +│ │ │ │ └── [multiply]: integer #26 +│ │ │ ├── variant_3: struct #95 +│ │ │ │ └── [decrement]: integer #26 +│ │ │ └── variant_4: struct #96 +│ │ │ └── [increment]: integer #26 +│ │ └── [title]: optional #101 +│ │ └── item: union #100 +│ │ ├── variant_0: string #27 +│ │ └── variant_1: struct #99 +│ │ └── [set]: string #27 +│ ├── variant_4: struct #106 +│ │ └── [updateMany]: struct #105 +│ │ ├── [data]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #102 +│ │ │ ├── [id]: optional #98 +│ │ │ │ └── item: union #97 +│ │ │ │ ├── variant_0: integer #26 +│ │ │ │ ├── variant_1: struct #93 +│ │ │ │ │ └── [set]: integer #26 +│ │ │ │ ├── variant_2: struct #94 +│ │ │ │ │ └── [multiply]: integer #26 +│ │ │ │ ├── variant_3: struct #95 +│ │ │ │ │ └── [decrement]: integer #26 +│ │ │ │ └── variant_4: struct #96 +│ │ │ │ └── [increment]: integer #26 +│ │ │ └── [title]: optional #101 +│ │ │ └── item: union #100 +│ │ │ ├── variant_0: string #27 +│ │ │ └── variant_1: struct #99 +│ │ │ └── [set]: string #27 +│ │ └── [where]: optional #104 +│ │ └── item: union #88 +│ │ ├── variant_0: struct 'PostWhere' #86 +│ │ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ │ └── item: union #53 +│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_1: struct #52 +│ │ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ │ └── item: union #70 +│ │ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── variant_1: struct #69 +│ │ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [posts]: optional #83 +│ │ │ │ └── item: union #82 +│ │ │ │ ├── variant_0: struct #77 +│ │ │ │ │ └── [every]: optional '_76_PostWhere?' #76 +│ │ │ │ │ └── item: &PostWhere #75 +│ │ │ │ ├── variant_1: struct #79 +│ │ │ │ │ └── [some]: optional '_78_PostWhere?' #78 +│ │ │ │ │ └── item: &PostWhere #75 +│ │ │ │ └── variant_2: struct #81 +│ │ │ │ └── [none]: optional '_80_PostWhere?' #80 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ ├── [id]: optional '_55__integer_filter_c?' #55 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── [title]: optional '_72__string_filter_c?' #72 +│ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ └── item: union #70 +│ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── variant_1: struct #69 +│ │ │ └── [not]: union '_string_filter' #68 +│ │ │ ├── variant_0: string #56 +│ │ │ ├── variant_1: struct #59 +│ │ │ │ └── [equals]: string #56 +│ │ │ ├── variant_2: struct #60 +│ │ │ │ └── [not]: string #56 +│ │ │ ├── variant_3: struct #61 +│ │ │ │ └── [in]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_4: struct #62 +│ │ │ │ └── [notIn]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_5: struct #65 +│ │ │ │ ├── [contains]: string #56 +│ │ │ │ └── [mode]: optional #64 +│ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #66 +│ │ │ │ └── [search]: string #56 +│ │ │ └── variant_7: struct #67 +│ │ │ ├── [endsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [startsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── variant_1: list '_87_PostWhere[]' #87 +│ │ └── item: struct 'PostWhere' #86 +│ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ ├── [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ └── item: union #70 +│ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── variant_1: struct #69 +│ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [posts]: optional #83 +│ │ │ └── item: union #82 +│ │ │ ├── variant_0: struct #77 +│ │ │ │ └── [every]: optional '_76_PostWhere?' #76 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ ├── variant_1: struct #79 +│ │ │ │ └── [some]: optional '_78_PostWhere?' #78 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ └── variant_2: struct #81 +│ │ │ └── [none]: optional '_80_PostWhere?' #80 +│ │ │ └── item: &PostWhere #75 +│ │ ├── [id]: optional '_55__integer_filter_c?' #55 +│ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ └── item: union #53 +│ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── variant_1: struct #52 +│ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ ├── variant_0: integer #43 +│ │ │ ├── variant_1: struct #46 +│ │ │ │ └── [equals]: integer #43 +│ │ │ ├── variant_2: struct #47 +│ │ │ │ └── [not]: integer #43 +│ │ │ ├── variant_3: struct #48 +│ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── [lte]: optional #44 +│ │ │ │ └── item: integer #43 +│ │ │ ├── variant_4: struct #49 +│ │ │ │ └── [in]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── variant_5: struct #50 +│ │ │ └── [notIn]: list #45 +│ │ │ └── item: integer #43 +│ │ └── [title]: optional '_72__string_filter_c?' #72 +│ │ └── item: optional '_string_filter_c' #71 +│ │ └── item: union #70 +│ │ ├── variant_0: union '_string_filter' #68 +│ │ │ ├── variant_0: string #56 +│ │ │ ├── variant_1: struct #59 +│ │ │ │ └── [equals]: string #56 +│ │ │ ├── variant_2: struct #60 +│ │ │ │ └── [not]: string #56 +│ │ │ ├── variant_3: struct #61 +│ │ │ │ └── [in]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_4: struct #62 +│ │ │ │ └── [notIn]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_5: struct #65 +│ │ │ │ ├── [contains]: string #56 +│ │ │ │ └── [mode]: optional #64 +│ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #66 +│ │ │ │ └── [search]: string #56 +│ │ │ └── variant_7: struct #67 +│ │ │ ├── [endsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [startsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── variant_1: struct #69 +│ │ └── [not]: union '_string_filter' #68 +│ │ ├── variant_0: string #56 +│ │ ├── variant_1: struct #59 +│ │ │ └── [equals]: string #56 +│ │ ├── variant_2: struct #60 +│ │ │ └── [not]: string #56 +│ │ ├── variant_3: struct #61 +│ │ │ └── [in]: list #58 +│ │ │ └── item: string #56 +│ │ ├── variant_4: struct #62 +│ │ │ └── [notIn]: list #58 +│ │ │ └── item: string #56 +│ │ ├── variant_5: struct #65 +│ │ │ ├── [contains]: string #56 +│ │ │ └── [mode]: optional #64 +│ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ ├── variant_6: struct #66 +│ │ │ └── [search]: string #56 +│ │ └── variant_7: struct #67 +│ │ ├── [endsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── [startsWith]: optional #57 +│ │ └── item: string #56 +│ ├── variant_5: struct #109 +│ │ └── [deleteMany]: struct #108 +│ │ └── [where]: optional #107 +│ │ └── item: union #88 +│ │ ├── variant_0: struct 'PostWhere' #86 +│ │ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ │ └── item: union #53 +│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_1: struct #52 +│ │ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ │ └── item: union #70 +│ │ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── variant_1: struct #69 +│ │ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [posts]: optional #83 +│ │ │ │ └── item: union #82 +│ │ │ │ ├── variant_0: struct #77 +│ │ │ │ │ └── [every]: optional '_76_PostWhere?' #76 +│ │ │ │ │ └── item: &PostWhere #75 +│ │ │ │ ├── variant_1: struct #79 +│ │ │ │ │ └── [some]: optional '_78_PostWhere?' #78 +│ │ │ │ │ └── item: &PostWhere #75 +│ │ │ │ └── variant_2: struct #81 +│ │ │ │ └── [none]: optional '_80_PostWhere?' #80 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ ├── [id]: optional '_55__integer_filter_c?' #55 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── [title]: optional '_72__string_filter_c?' #72 +│ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ └── item: union #70 +│ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── variant_1: struct #69 +│ │ │ └── [not]: union '_string_filter' #68 +│ │ │ ├── variant_0: string #56 +│ │ │ ├── variant_1: struct #59 +│ │ │ │ └── [equals]: string #56 +│ │ │ ├── variant_2: struct #60 +│ │ │ │ └── [not]: string #56 +│ │ │ ├── variant_3: struct #61 +│ │ │ │ └── [in]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_4: struct #62 +│ │ │ │ └── [notIn]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_5: struct #65 +│ │ │ │ ├── [contains]: string #56 +│ │ │ │ └── [mode]: optional #64 +│ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #66 +│ │ │ │ └── [search]: string #56 +│ │ │ └── variant_7: struct #67 +│ │ │ ├── [endsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [startsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── variant_1: list '_87_PostWhere[]' #87 +│ │ └── item: struct 'PostWhere' #86 +│ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ │ └── item: union #53 +│ │ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├── variant_0: integer #43 +│ │ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ │ └── [not]: integer #43 +│ │ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── variant_5: struct #50 +│ │ │ │ │ └── [notIn]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_1: struct #52 +│ │ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ ├── [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ └── item: optional '_string_filter_c' #71 +│ │ │ │ └── item: union #70 +│ │ │ │ ├── variant_0: union '_string_filter' #68 +│ │ │ │ │ ├── variant_0: string #56 +│ │ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ │ └── [equals]: string #56 +│ │ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ │ └── [not]: string #56 +│ │ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ │ └── [search]: string #56 +│ │ │ │ │ └── variant_7: struct #67 +│ │ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ │ └── item: string #56 +│ │ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── variant_1: struct #69 +│ │ │ │ └── [not]: union '_string_filter' #68 +│ │ │ │ ├── variant_0: string #56 +│ │ │ │ ├── variant_1: struct #59 +│ │ │ │ │ └── [equals]: string #56 +│ │ │ │ ├── variant_2: struct #60 +│ │ │ │ │ └── [not]: string #56 +│ │ │ │ ├── variant_3: struct #61 +│ │ │ │ │ └── [in]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_4: struct #62 +│ │ │ │ │ └── [notIn]: list #58 +│ │ │ │ │ └── item: string #56 +│ │ │ │ ├── variant_5: struct #65 +│ │ │ │ │ ├── [contains]: string #56 +│ │ │ │ │ └── [mode]: optional #64 +│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├── variant_6: struct #66 +│ │ │ │ │ └── [search]: string #56 +│ │ │ │ └── variant_7: struct #67 +│ │ │ │ ├── [endsWith]: optional #57 +│ │ │ │ │ └── item: string #56 +│ │ │ │ └── [startsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [posts]: optional #83 +│ │ │ └── item: union #82 +│ │ │ ├── variant_0: struct #77 +│ │ │ │ └── [every]: optional '_76_PostWhere?' #76 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ ├── variant_1: struct #79 +│ │ │ │ └── [some]: optional '_78_PostWhere?' #78 +│ │ │ │ └── item: &PostWhere #75 +│ │ │ └── variant_2: struct #81 +│ │ │ └── [none]: optional '_80_PostWhere?' #80 +│ │ │ └── item: &PostWhere #75 +│ │ ├── [id]: optional '_55__integer_filter_c?' #55 +│ │ │ └── item: optional '_integer_filter_c' #54 +│ │ │ └── item: union #53 +│ │ │ ├── variant_0: either '_integer_filter' #51 +│ │ │ │ ├── variant_0: integer #43 +│ │ │ │ ├── variant_1: struct #46 +│ │ │ │ │ └── [equals]: integer #43 +│ │ │ │ ├── variant_2: struct #47 +│ │ │ │ │ └── [not]: integer #43 +│ │ │ │ ├── variant_3: struct #48 +│ │ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ │ └── item: integer #43 +│ │ │ │ │ └── [lte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── variant_4: struct #49 +│ │ │ │ │ └── [in]: list #45 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── variant_5: struct #50 +│ │ │ │ └── [notIn]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── variant_1: struct #52 +│ │ │ └── [not]: either '_integer_filter' #51 +│ │ │ ├── variant_0: integer #43 +│ │ │ ├── variant_1: struct #46 +│ │ │ │ └── [equals]: integer #43 +│ │ │ ├── variant_2: struct #47 +│ │ │ │ └── [not]: integer #43 +│ │ │ ├── variant_3: struct #48 +│ │ │ │ ├── [gt]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [gte]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ ├── [lt]: optional #44 +│ │ │ │ │ └── item: integer #43 +│ │ │ │ └── [lte]: optional #44 +│ │ │ │ └── item: integer #43 +│ │ │ ├── variant_4: struct #49 +│ │ │ │ └── [in]: list #45 +│ │ │ │ └── item: integer #43 +│ │ │ └── variant_5: struct #50 +│ │ │ └── [notIn]: list #45 +│ │ │ └── item: integer #43 +│ │ └── [title]: optional '_72__string_filter_c?' #72 +│ │ └── item: optional '_string_filter_c' #71 +│ │ └── item: union #70 +│ │ ├── variant_0: union '_string_filter' #68 +│ │ │ ├── variant_0: string #56 +│ │ │ ├── variant_1: struct #59 +│ │ │ │ └── [equals]: string #56 +│ │ │ ├── variant_2: struct #60 +│ │ │ │ └── [not]: string #56 +│ │ │ ├── variant_3: struct #61 +│ │ │ │ └── [in]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_4: struct #62 +│ │ │ │ └── [notIn]: list #58 +│ │ │ │ └── item: string #56 +│ │ │ ├── variant_5: struct #65 +│ │ │ │ ├── [contains]: string #56 +│ │ │ │ └── [mode]: optional #64 +│ │ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ │ ├── variant_6: struct #66 +│ │ │ │ └── [search]: string #56 +│ │ │ └── variant_7: struct #67 +│ │ │ ├── [endsWith]: optional #57 +│ │ │ │ └── item: string #56 +│ │ │ └── [startsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── variant_1: struct #69 +│ │ └── [not]: union '_string_filter' #68 +│ │ ├── variant_0: string #56 +│ │ ├── variant_1: struct #59 +│ │ │ └── [equals]: string #56 +│ │ ├── variant_2: struct #60 +│ │ │ └── [not]: string #56 +│ │ ├── variant_3: struct #61 +│ │ │ └── [in]: list #58 +│ │ │ └── item: string #56 +│ │ ├── variant_4: struct #62 +│ │ │ └── [notIn]: list #58 +│ │ │ └── item: string #56 +│ │ ├── variant_5: struct #65 +│ │ │ ├── [contains]: string #56 +│ │ │ └── [mode]: optional #64 +│ │ │ └── item: string #63 enum{ '"insensitive"' } +│ │ ├── variant_6: struct #66 +│ │ │ └── [search]: string #56 +│ │ └── variant_7: struct #67 +│ │ ├── [endsWith]: optional #57 +│ │ │ └── item: string #56 +│ │ └── [startsWith]: optional #57 +│ │ └── item: string #56 +│ └── variant_6: struct #113 +│ └── [createMany]: optional #112 +│ └── item: struct #111 +│ └── [data]: list #110 +│ └── item: union #42 +│ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ │ ├── [id]: optional #39 +│ │ │ └── item: integer #26 +│ │ └── [title]: string #27 +│ └── variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 +│ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ ├── [id]: optional #39 +│ │ └── item: integer #26 +│ └── [title]: string #27 +└── [where]: struct 'QueryUniqueUserWhereInput' #118 + └── [id]: optional #117 + └── item: integer #21 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 From 50b1d2a5691c9cc50f6c8b92c4e08ea44f09243f Mon Sep 17 00:00:00 2001 From: Natoandro Date: Thu, 15 Feb 2024 04:37:02 +0300 Subject: [PATCH 20/32] more tests --- typegate/tests/params/apply.py | 28 ++++++++++++++++++++++++++++ typegate/tests/params/apply_test.ts | 28 ++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+) diff --git a/typegate/tests/params/apply.py b/typegate/tests/params/apply.py index 42bddc43f..fefb732bc 100644 --- a/typegate/tests/params/apply.py +++ b/typegate/tests/params/apply.py @@ -95,4 +95,32 @@ def test_apply(g: Graph): ] } ), + 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 index c64253282..0bccbc3a7 100644 --- a/typegate/tests/params/apply_test.ts +++ b/typegate/tests/params/apply_test.ts @@ -101,4 +101,32 @@ Meta.test("(python (sdk): apply)", async (t) => { }) .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); + }); }); From 85f68d883287dfb4582e654d84f8655749abb717 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Thu, 15 Feb 2024 15:27:29 +0300 Subject: [PATCH 21/32] fix tests --- examples/typegraphs/authentication.py | 8 +++++-- examples/typegraphs/authentication.ts | 6 +++-- examples/typegraphs/basic.py | 8 +++++-- examples/typegraphs/basic.ts | 6 +++-- examples/typegraphs/execute.py | 6 +++-- examples/typegraphs/execute.ts | 6 +++-- examples/typegraphs/jwt.py | 10 ++++---- examples/typegraphs/jwt.ts | 12 +++++----- examples/typegraphs/oauth2.py | 8 +++++-- examples/typegraphs/oauth2.ts | 6 +++-- libs/common/src/typegraph/validator/input.rs | 23 ++++--------------- .../prisma/type_generation/out_type.rs | 3 ++- .../type_generation/with_nested_count.rs | 3 ++- .../core/src/runtimes/prisma/type_utils.rs | 20 +++++++++++++++- 14 files changed, 77 insertions(+), 48 deletions(-) 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/libs/common/src/typegraph/validator/input.rs b/libs/common/src/typegraph/validator/input.rs index a084c42d2..e7e03894a 100644 --- a/libs/common/src/typegraph/validator/input.rs +++ b/libs/common/src/typegraph/validator/input.rs @@ -19,27 +19,12 @@ impl Validator { current_node: CurrentNode<'_>, context: &::Context, ) -> VisitResult<::Return> { - let typegraph = context.get_typegraph(); let type_node = current_node.type_node; - match type_node { - TypeNode::Function { .. } => { - // TODO suggest to use composition-- when available - self.push_error(current_node.path, "Function is not allowed in input types."); - return VisitResult::Continue(false); - } - 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); - } - } - } - _ => (), + 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 { 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..4f050297a 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/out_type.rs +++ b/typegraph/core/src/runtimes/prisma/type_generation/out_type.rs @@ -5,6 +5,7 @@ use crate::errors::Result; use crate::runtimes::prisma::context::PrismaContext; use crate::runtimes::prisma::errors; use crate::runtimes::prisma::model::Property; +use crate::runtimes::prisma::type_utils::remove_injection; use crate::t::{self, ConcreteTypeBuilder, TypeBuilder}; use crate::types::TypeId; @@ -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/with_nested_count.rs b/typegraph/core/src/runtimes/prisma/type_generation/with_nested_count.rs index 871375086..ce5c1b45f 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 @@ -6,6 +6,7 @@ use crate::runtimes::prisma::context::PrismaContext; use crate::runtimes::prisma::model::Property; use crate::runtimes::prisma::relationship::Cardinality; use crate::runtimes::prisma::type_generation::count::Count; +use crate::runtimes::prisma::type_utils::remove_injection; use crate::t::{self, ConcreteTypeBuilder, TypeBuilder}; use crate::types::{TypeDefExt, TypeId}; @@ -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/runtimes/prisma/type_utils.rs b/typegraph/core/src/runtimes/prisma/type_utils.rs index 48b3bb8f5..77d42c160 100644 --- a/typegraph/core/src/runtimes/prisma/type_utils.rs +++ b/typegraph/core/src/runtimes/prisma/type_utils.rs @@ -4,7 +4,8 @@ use std::borrow::Cow; use crate::errors::Result; -use crate::types::{TypeDef, TypeDefExt}; +use crate::global_store::{NameRegistration, Store}; +use crate::types::{TypeDef, TypeDefExt, TypeId}; pub struct RuntimeConfig<'a>(Cow<'a, [(String, String)]>); @@ -37,3 +38,20 @@ impl<'a> TryFrom<&'a TypeDef> for RuntimeConfig<'a> { Ok(Self::new(type_def.base().runtime_config.as_ref())) } } + +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), + ) +} From 8211dc237faf115fc91271bc19d2436c290fd073 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Thu, 15 Feb 2024 15:28:05 +0300 Subject: [PATCH 22/32] docs: update docs --- website/docs/reference/types/index.mdx | 8 ++++++++ ...r-transformation.mdx => parameter-transformations.mdx} | 0 website/docs/tutorials/metatype-basics/index.mdx | 2 ++ 3 files changed, 10 insertions(+) rename website/docs/reference/types/{parameter-transformation.mdx => parameter-transformations.mdx} (100%) 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-transformation.mdx b/website/docs/reference/types/parameter-transformations.mdx similarity index 100% rename from website/docs/reference/types/parameter-transformation.mdx rename to website/docs/reference/types/parameter-transformations.mdx 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. From 6f91dbe751fc1d06d0e335c2a2d721f0df65b645 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Thu, 15 Feb 2024 15:29:43 +0300 Subject: [PATCH 23/32] disable docker test on arm64 --- .github/workflows/tests.yml | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index faaa4457b..6615f33f6 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 @@ -183,8 +184,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 From 20703665af1d6bbd4fc3496fe5ed5f61014d0d1b Mon Sep 17 00:00:00 2001 From: Natoandro Date: Thu, 15 Feb 2024 22:20:07 +0300 Subject: [PATCH 24/32] fix tests --- libs/common/src/typegraph/validator/types.rs | 9 +- typegate/tests/injection/injection.py | 13 +- typegate/tests/injection/injection.ts | 21 +-- typegate/tests/injection/injection_test.ts | 8 +- .../__snapshots__/introspection_test.ts.snap | 6 +- .../__snapshots__/union_either_test.ts.snap | 18 +-- .../tests/introspection/introspection_test.ts | 2 +- typegraph/core/src/lib.rs | 29 ++++ .../prisma/type_generation/out_type.rs | 2 +- .../type_generation/with_nested_count.rs | 2 +- .../core/src/runtimes/prisma/type_utils.rs | 20 +-- typegraph/core/src/types/map_children.rs | 136 ++++++++++++++++++ typegraph/core/src/types/mod.rs | 1 + typegraph/core/src/utils/mod.rs | 38 ++++- typegraph/core/wit/typegraph.wit | 3 + typegraph/node/sdk/src/runtimes/deno.ts | 7 +- typegraph/node/sdk/src/types.ts | 16 ++- typegraph/python/typegraph/runtimes/deno.py | 9 +- typegraph/python/typegraph/t.py | 10 +- 19 files changed, 273 insertions(+), 77 deletions(-) create mode 100644 typegraph/core/src/types/map_children.rs diff --git a/libs/common/src/typegraph/validator/types.rs b/libs/common/src/typegraph/validator/types.rs index af2ad189a..80b35dbcb 100644 --- a/libs/common/src/typegraph/validator/types.rs +++ b/libs/common/src/typegraph/validator/types.rs @@ -283,6 +283,9 @@ impl<'a> EnsureSubtypeOf for ExtendedTypeNode<'a> { 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) @@ -337,7 +340,11 @@ impl<'a> EnsureSubtypeOf for ExtendedTypeNode<'a> { (TypeNode::Function { .. }, _) | (_, TypeNode::Function { .. }) => { errors.push("Function types are not supported"); } - _ => errors.push("Type mismatch"), + (x, y) => errors.push(format!( + "Type mismatch: {} to {}", + x.type_name(), + y.type_name() + )), } } } 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/introspection/__snapshots__/introspection_test.ts.snap b/typegate/tests/introspection/__snapshots__/introspection_test.ts.snap index c6a093da1..b3cdfced8 100644 --- a/typegate/tests/introspection/__snapshots__/introspection_test.ts.snap +++ b/typegate/tests/introspection/__snapshots__/introspection_test.ts.snap @@ -53,7 +53,7 @@ Policies: name: null, ofType: { kind: "OBJECT", - name: "inp", + name: "object_8", ofType: null, }, }, @@ -100,7 +100,7 @@ Policies: possibleTypes: null, }, { - description: "inp type", + description: "object_8 type", enumValues: null, fields: [ { @@ -126,7 +126,7 @@ Policies: inputFields: null, interfaces: [], kind: "OBJECT", - name: "inp", + name: "object_8", possibleTypes: null, }, { diff --git a/typegate/tests/introspection/__snapshots__/union_either_test.ts.snap b/typegate/tests/introspection/__snapshots__/union_either_test.ts.snap index 00bb8a91a..d3fb3d52c 100644 --- a/typegate/tests/introspection/__snapshots__/union_either_test.ts.snap +++ b/typegate/tests/introspection/__snapshots__/union_either_test.ts.snap @@ -56,25 +56,25 @@ snapshot[`Basic introspection 1`] = ` }, ], kind: "OBJECT", - name: "User", + name: "object_19", possibleTypes: null, }, { fields: null, kind: "UNION", - name: "FavoriteToyOut", + name: "either_18Out", possibleTypes: [ { kind: "OBJECT", - name: "Rubix", + name: "object_14", }, { kind: "OBJECT", - name: "Toygun", + name: "object_15", }, { kind: "OBJECT", - name: "Gunpla", + name: "object_17", }, ], }, @@ -88,7 +88,7 @@ snapshot[`Basic introspection 1`] = ` }, ], kind: "OBJECT", - name: "Rubix", + name: "object_14", possibleTypes: null, }, { @@ -98,7 +98,7 @@ snapshot[`Basic introspection 1`] = ` }, ], kind: "OBJECT", - name: "Toygun", + name: "object_15", possibleTypes: null, }, { @@ -111,13 +111,13 @@ snapshot[`Basic introspection 1`] = ` }, ], kind: "OBJECT", - name: "Gunpla", + name: "object_17", possibleTypes: null, }, { fields: null, kind: "UNION", - name: "union_8Out", + name: "union_16Out", possibleTypes: [ { kind: "OBJECT", diff --git a/typegate/tests/introspection/introspection_test.ts b/typegate/tests/introspection/introspection_test.ts index c039c5955..627900e71 100644 --- a/typegate/tests/introspection/introspection_test.ts +++ b/typegate/tests/introspection/introspection_test.ts @@ -28,7 +28,7 @@ Meta.test("Basic introspection", async (t) => { "name": "Query", }, { - name: "inp", + name: "object_8", }, { "name": "NestedInp", diff --git a/typegraph/core/src/lib.rs b/typegraph/core/src/lib.rs index abfd2bb24..e596070e0 100644 --- a/typegraph/core/src/lib.rs +++ b/typegraph/core/src/lib.rs @@ -29,6 +29,7 @@ use types::{ TypeDef, TypeDefExt, TypeId, Union, }; +use utils::clear_name; use wit::core::{ ContextCheck, Policy, PolicyId, PolicySpec, TransformData, TypeBase, TypeEither, TypeFile, TypeFloat, TypeFunc, TypeId as CoreTypeId, TypeInteger, TypeList, TypeOptional, TypeString, @@ -317,6 +318,34 @@ 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(_)) { 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 4f050297a..9b340dd7c 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/out_type.rs +++ b/typegraph/core/src/runtimes/prisma/type_generation/out_type.rs @@ -5,9 +5,9 @@ use crate::errors::Result; use crate::runtimes::prisma::context::PrismaContext; use crate::runtimes::prisma::errors; use crate::runtimes::prisma::model::Property; -use crate::runtimes::prisma::type_utils::remove_injection; use crate::t::{self, ConcreteTypeBuilder, TypeBuilder}; use crate::types::TypeId; +use crate::utils::remove_injection; use super::{Cardinality, TypeGen}; 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 ce5c1b45f..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 @@ -6,9 +6,9 @@ use crate::runtimes::prisma::context::PrismaContext; use crate::runtimes::prisma::model::Property; use crate::runtimes::prisma::relationship::Cardinality; use crate::runtimes::prisma::type_generation::count::Count; -use crate::runtimes::prisma::type_utils::remove_injection; use crate::t::{self, ConcreteTypeBuilder, TypeBuilder}; use crate::types::{TypeDefExt, TypeId}; +use crate::utils::remove_injection; use super::TypeGen; diff --git a/typegraph/core/src/runtimes/prisma/type_utils.rs b/typegraph/core/src/runtimes/prisma/type_utils.rs index 77d42c160..48b3bb8f5 100644 --- a/typegraph/core/src/runtimes/prisma/type_utils.rs +++ b/typegraph/core/src/runtimes/prisma/type_utils.rs @@ -4,8 +4,7 @@ use std::borrow::Cow; use crate::errors::Result; -use crate::global_store::{NameRegistration, Store}; -use crate::types::{TypeDef, TypeDefExt, TypeId}; +use crate::types::{TypeDef, TypeDefExt}; pub struct RuntimeConfig<'a>(Cow<'a, [(String, String)]>); @@ -38,20 +37,3 @@ impl<'a> TryFrom<&'a TypeDef> for RuntimeConfig<'a> { Ok(Self::new(type_def.base().runtime_config.as_ref())) } } - -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), - ) -} diff --git a/typegraph/core/src/types/map_children.rs b/typegraph/core/src/types/map_children.rs new file mode 100644 index 000000000..5292a3e6c --- /dev/null +++ b/typegraph/core/src/types/map_children.rs @@ -0,0 +1,136 @@ +// Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. +// SPDX-License-Identifier: MPL-2.0 + +use std::rc::Rc; + +use crate::errors::Result; +use crate::global_store::{NameRegistration, Store}; +use crate::utils::clear_name; +use crate::wit::core::{TypeEither, TypeList, TypeOptional, TypeStruct, TypeUnion}; + +use super::{Either, List, Optional, Struct, TypeDef, TypeId, Union}; + +pub fn map_children(type_id: TypeId, f: &F) -> Result +where + F: Fn(TypeId) -> Result, +{ + let (_, type_def) = type_id.resolve_ref()?; + match type_def { + TypeDef::Struct(s) => { + let type_data = map_props(s.data.clone(), f)?; + Store::register_type_def( + |id| { + TypeDef::Struct(Rc::new(Struct { + id, + base: clear_name(&s.base), + extended_base: s.extended_base.clone(), + data: type_data, + })) + }, + NameRegistration(false), + ) + } + + TypeDef::List(l) => { + let type_data = TypeList { + of: f(l.data.of.into())?.0, + ..l.data + }; + Store::register_type_def( + |id| { + TypeDef::List(Rc::new(List { + id, + base: clear_name(&l.base), + extended_base: l.extended_base.clone(), + data: type_data, + })) + }, + NameRegistration(false), + ) + } + + TypeDef::Optional(o) => { + let type_data = TypeOptional { + of: f(o.data.of.into())?.0, + ..o.data.clone() + }; + Store::register_type_def( + |id| { + TypeDef::Optional(Rc::new(Optional { + id, + base: clear_name(&o.base), + extended_base: o.extended_base.clone(), + data: type_data, + })) + }, + NameRegistration(false), + ) + } + + TypeDef::Union(u) => { + let variants = u + .data + .variants + .iter() + .map(|id| -> Result<_> { Ok(f(id.into())?.0) }) + .collect::>>()?; // map => collect + let type_data = TypeUnion { variants }; + Store::register_type_def( + |id| { + TypeDef::Union(Rc::new(Union { + id, + base: clear_name(&u.base), + extended_base: u.extended_base.clone(), + data: type_data, + })) + }, + NameRegistration(false), + ) + } + + TypeDef::Either(e) => { + let variants = e + .data + .variants + .iter() + .map(|id| -> Result<_> { Ok(f(id.into())?.0) }) + .collect::>>()?; + let type_data = TypeEither { variants }; + + Store::register_type_def( + |id| { + TypeDef::Either(Rc::new(Either { + id, + base: clear_name(&e.base), + extended_base: e.extended_base.clone(), + data: type_data, + })) + }, + NameRegistration(false), + ) + } + + TypeDef::Boolean(_) + | TypeDef::Integer(_) + | TypeDef::Float(_) + | TypeDef::String(_) + | TypeDef::File(_) => Ok(type_id), + + TypeDef::Func(_) => Ok(type_id), + } +} + +pub fn map_props(struct_data: TypeStruct, f: &F) -> Result +where + F: Fn(TypeId) -> Result, +{ + let props = struct_data + .props + .iter() + .map(|(k, v)| -> Result<_> { Ok((k.clone(), f(v.into())?.0)) }) + .collect::>>()?; + Ok(TypeStruct { + props, + ..struct_data + }) +} diff --git a/typegraph/core/src/types/mod.rs b/typegraph/core/src/types/mod.rs index 79622363a..4b16e4bf3 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 map_children; pub mod type_def; pub mod type_id; pub mod type_ref; diff --git a/typegraph/core/src/utils/mod.rs b/typegraph/core/src/utils/mod.rs index 4e9861329..b02f5a98b 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::map_children::map_children; +use crate::types::{TypeDefExt, TypeId}; use crate::wit::core::{Guest, TypeBase, TypeId as CoreTypeId, TypeStruct}; use crate::wit::utils::{Auth as WitAuth, QueryBodyParams}; use crate::Lib; @@ -236,4 +237,37 @@ impl crate::wit::utils::Guest for crate::Lib { Ok(req_body.to_string()) } + + fn remove_injections(id: CoreTypeId) -> Result { + remove_injections_recursively(id.into()).map(|id| id.into()) + } +} + +fn remove_injections_recursively(id: TypeId) -> Result { + let id = remove_injection(id)?; + map_children(id, &remove_injections_recursively) +} + +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 035fe434e..effa894b5 100644 --- a/typegraph/core/wit/typegraph.wit +++ b/typegraph/core/wit/typegraph.wit @@ -128,6 +128,7 @@ 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 @@ -526,6 +527,8 @@ interface utils { } gen-gqlquery: func(params: query-body-params) -> result + + remove-injections: func(type-id: type-id) -> result } interface host { diff --git a/typegraph/node/sdk/src/runtimes/deno.ts b/typegraph/node/sdk/src/runtimes/deno.ts index 273ec2aee..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"; @@ -86,14 +86,15 @@ export class DenoRuntime extends Runtime { identity< I extends t.Typedef = t.Typedef, - >(inp: I): t.Func { + >(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/types.ts b/typegraph/node/sdk/src/types.ts index 2eafc31b8..6517fe77f 100644 --- a/typegraph/node/sdk/src/types.ts +++ b/typegraph/node/sdk/src/types.ts @@ -14,7 +14,6 @@ import { TypeOptional, TypeString, TypeUnion, - TypeId, ParameterTransform, } from "./gen/interfaces/metatype-typegraph-core.js"; import { Reduce } from "./gen/interfaces/metatype-typegraph-utils.js"; @@ -565,6 +564,21 @@ export class Func< 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) { const data: Reduce = { paths: buildReduceData(value), 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 3f57651a8..c8ed9e29a 100644 --- a/typegraph/python/typegraph/t.py +++ b/typegraph/python/typegraph/t.py @@ -688,10 +688,14 @@ def rate(self, calls: bool = False, weight: Optional[int] = None) -> "func": ) 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 = typedef(res.value) - out = self.out.extend(props) return func( self.inp, out, From ff1c92f14009fca5347ee664064a44f50fa66113 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Fri, 16 Feb 2024 11:01:59 +0300 Subject: [PATCH 25/32] fix visitor --- libs/common/src/typegraph/validator/mod.rs | 11 ++++++++++- libs/common/src/typegraph/visitor.rs | 18 ++---------------- .../__snapshots__/validator_test.ts.snap | 9 +-------- 3 files changed, 13 insertions(+), 25 deletions(-) diff --git a/libs/common/src/typegraph/validator/mod.rs b/libs/common/src/typegraph/validator/mod.rs index 6d18759c1..04ae18ad4 100644 --- a/libs/common/src/typegraph/validator/mod.rs +++ b/libs/common/src/typegraph/validator/mod.rs @@ -9,7 +9,8 @@ mod value; use crate::typegraph::{TypeNode, Typegraph}; use super::visitor::{ - CurrentNode, Path, PathSegment, TypeVisitor, TypeVisitorContext, VisitResult, VisitorResult, + CurrentNode, Edge, Path, PathSegment, TypeVisitor, TypeVisitorContext, VisitResult, + VisitorResult, }; pub fn validate_typegraph(tg: &Typegraph) -> Vec { @@ -67,6 +68,14 @@ impl<'a> TypeVisitor<'a> for Validator { 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_impl(current_node, context); + return VisitResult::Continue(false); + } + } + match type_node { TypeNode::Union { .. } | TypeNode::Either { .. } => { let mut variants = vec![]; diff --git a/libs/common/src/typegraph/visitor.rs b/libs/common/src/typegraph/visitor.rs index b75a995b9..54f84edec 100644 --- a/libs/common/src/typegraph/visitor.rs +++ b/libs/common/src/typegraph/visitor.rs @@ -211,12 +211,6 @@ where output: u32, context: &'a V::Context, ) -> Option { - if self.input_parent_function.as_ref().is_some() { - return Some(V::Return::from_error( - Path(&self.path).to_string(), - "Function is not allowed in input types.".to_string(), - )); - } let last_path_seg = self.path.last().unwrap(); match last_path_seg.edge { Edge::ObjectProp(_) => {} @@ -228,13 +222,6 @@ where } } - let parent_struct_idx = last_path_seg.from; - self.input_parent_function = Some(FunctionMetadata { - idx: type_idx, - path: Path(&self.path).to_string(), - parent_struct_idx, - }); - let res = self.visit_child( PathSegment { from: type_idx, @@ -243,7 +230,6 @@ where input, context, ); - self.input_parent_function = None; if let Some(ret) = res { return Some(ret); @@ -277,8 +263,8 @@ where #[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> { diff --git a/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap b/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap index c8721825d..74d987ff8 100644 --- a/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap +++ b/typegate/tests/e2e/typegraph/__snapshots__/validator_test.ts.snap @@ -8,20 +8,13 @@ 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: Injection is not allowed in output types -[ERROR] at validator:/test/[out]/b: Injection is not allowed in output types -[ERROR] at validator:/test/[out]/c: Injection is not allowed in output types -[ERROR] at validator:/test/[out]/d: Injection is not allowed in output types -[ERROR] at validator:/test/[out]/e: Injection is not allowed in output types -[ERROR] at validator:/test/[out]/f: Injection is not allowed in output types -[ERROR] at validator:/test/[out]/g: Injection is not allowed in output types [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 +[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 From 8ed22efff17e201f783b9309c814d78c9be7b657 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Fri, 16 Feb 2024 22:08:08 +0300 Subject: [PATCH 26/32] fix tests --- libs/common/src/typegraph/validator/mod.rs | 2 +- libs/common/src/typegraph/visitor.rs | 13 +- typegate/tests/e2e/typegraph/validator.py | 2 +- .../typegate_runtime_test.ts.snap | 16 +- .../__snapshots__/class_syntax_test.ts.snap | 16 +- typegate/tests/simple/class_syntax.py | 4 +- typegraph/core/src/global_store.rs | 20 ++ typegraph/core/src/types/map_children.rs | 265 +++++++++++------- 8 files changed, 208 insertions(+), 130 deletions(-) diff --git a/libs/common/src/typegraph/validator/mod.rs b/libs/common/src/typegraph/validator/mod.rs index 04ae18ad4..82d2ae72e 100644 --- a/libs/common/src/typegraph/validator/mod.rs +++ b/libs/common/src/typegraph/validator/mod.rs @@ -71,7 +71,7 @@ impl<'a> TypeVisitor<'a> for Validator { 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_impl(current_node, context); + self.visit_input_type(current_node, context); return VisitResult::Continue(false); } } diff --git a/libs/common/src/typegraph/visitor.rs b/libs/common/src/typegraph/visitor.rs index 54f84edec..a51240dc4 100644 --- a/libs/common/src/typegraph/visitor.rs +++ b/libs/common/src/typegraph/visitor.rs @@ -18,7 +18,7 @@ impl Typegraph { visited_types: HashSet::new(), visited_input_types: HashSet::new(), visitor, - input_parent_function: None, + as_input: false, }; traversal .visit_type(0, context) @@ -39,7 +39,7 @@ where { tg: &'a Typegraph, path: Vec>, - input_parent_function: Option, + as_input: bool, visited_types: HashSet, // non input types visited_input_types: HashSet, visitor: V, @@ -50,7 +50,7 @@ where V: TypeVisitor<'a> + Sized, { fn visit_type(&mut self, type_idx: u32, context: &'a V::Context) -> Option { - let res = if self.input_parent_function.as_ref().is_some() { + let res = if self.as_input { if self.visited_input_types.contains(&type_idx) { return None; } @@ -211,6 +211,11 @@ where 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(_) => {} @@ -222,6 +227,7 @@ where } } + self.as_input = true; let res = self.visit_child( PathSegment { from: type_idx, @@ -230,6 +236,7 @@ where input, context, ); + self.as_input = false; if let Some(ret) = res { return Some(ret); diff --git a/typegate/tests/e2e/typegraph/validator.py b/typegate/tests/e2e/typegraph/validator.py index 3b664e5fa..ba0ff058a 100644 --- a/typegate/tests/e2e/typegraph/validator.py +++ b/typegate/tests/e2e/typegraph/validator.py @@ -55,7 +55,7 @@ def validator(g: Graph): } ), t.struct(), - code="...", + code="() => ({})", ), } ), 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 cde9d8c8c..dc0c3e2a2 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_33", type: "string", }, }, @@ -198,7 +198,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: false, runtime: "prisma", - title: "_100_recordWithNestedCount[]", + title: "_101_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_33", type: "string", }, }, @@ -331,7 +331,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: false, runtime: "prisma", - title: "_241_user_identityWithNestedCount_excluding___rel_user_identity_users_1[]", + title: "_244_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: "_243_messagesWithNestedCount_excluding_messageSender[]", + title: "_246_messagesWithNestedCount_excluding_messageSender[]", type: "list", }, }, @@ -396,7 +396,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: true, runtime: "prisma", - title: "integer_244", + title: "integer_247", type: "integer", }, }, @@ -413,7 +413,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: true, runtime: "prisma", - title: "integer_244", + title: "integer_247", type: "integer", }, }, @@ -523,7 +523,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: false, runtime: "prisma", - title: "_276_messagesWithNestedCount[]", + title: "_279_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/typegraph/core/src/global_store.rs b/typegraph/core/src/global_store.rs index 8e3373b1a..bc13a818b 100644 --- a/typegraph/core/src/global_store.rs +++ b/typegraph/core/src/global_store.rs @@ -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); diff --git a/typegraph/core/src/types/map_children.rs b/typegraph/core/src/types/map_children.rs index 5292a3e6c..264de10da 100644 --- a/typegraph/core/src/types/map_children.rs +++ b/typegraph/core/src/types/map_children.rs @@ -1,136 +1,187 @@ // Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. // SPDX-License-Identifier: MPL-2.0 +use std::collections::HashMap; use std::rc::Rc; use crate::errors::Result; use crate::global_store::{NameRegistration, Store}; +use crate::t::{self, TypeBuilder}; use crate::utils::clear_name; use crate::wit::core::{TypeEither, TypeList, TypeOptional, TypeStruct, TypeUnion}; use super::{Either, List, Optional, Struct, TypeDef, TypeId, Union}; -pub fn map_children(type_id: TypeId, f: &F) -> Result +struct MapChildren where - F: Fn(TypeId) -> Result, + M: Fn(TypeId) -> Result, { - let (_, type_def) = type_id.resolve_ref()?; - match type_def { - TypeDef::Struct(s) => { - let type_data = map_props(s.data.clone(), f)?; - Store::register_type_def( - |id| { - TypeDef::Struct(Rc::new(Struct { - id, - base: clear_name(&s.base), - extended_base: s.extended_base.clone(), - data: type_data, - })) - }, - NameRegistration(false), - ) - } + result_aliases: HashMap, + mapper: M, +} - TypeDef::List(l) => { - let type_data = TypeList { - of: f(l.data.of.into())?.0, - ..l.data - }; - Store::register_type_def( - |id| { - TypeDef::List(Rc::new(List { - id, - base: clear_name(&l.base), - extended_base: l.extended_base.clone(), - data: type_data, - })) - }, - NameRegistration(false), - ) +impl MapChildren +where + M: Fn(TypeId) -> Result, +{ + fn new(mapper: M) -> Self { + Self { + result_aliases: HashMap::new(), + mapper, } + } - TypeDef::Optional(o) => { - let type_data = TypeOptional { - of: f(o.data.of.into())?.0, - ..o.data.clone() - }; - Store::register_type_def( - |id| { - TypeDef::Optional(Rc::new(Optional { - id, - base: clear_name(&o.base), - extended_base: o.extended_base.clone(), - data: type_data, - })) - }, - NameRegistration(false), - ) + fn map_children(&mut self, type_id: TypeId) -> Result { + let (_, type_def) = type_id.resolve_ref()?; + if let Some(alias) = self.result_aliases.get(&type_id) { + return t::ref_(alias).build(); } + self.result_aliases.insert(type_id, Store::generate_alias()); - TypeDef::Union(u) => { - let variants = u - .data - .variants - .iter() - .map(|id| -> Result<_> { Ok(f(id.into())?.0) }) - .collect::>>()?; // map => collect - let type_data = TypeUnion { variants }; - Store::register_type_def( - |id| { - TypeDef::Union(Rc::new(Union { - id, - base: clear_name(&u.base), - extended_base: u.extended_base.clone(), - data: type_data, - })) - }, - NameRegistration(false), - ) - } + let res = match type_def { + TypeDef::Struct(s) => { + let type_data = self.map_props(s.data.clone())?; + if type_data.props == s.data.props { + return Ok(type_id); + } - TypeDef::Either(e) => { - let variants = e - .data - .variants - .iter() - .map(|id| -> Result<_> { Ok(f(id.into())?.0) }) - .collect::>>()?; - let type_data = TypeEither { variants }; - - Store::register_type_def( - |id| { - TypeDef::Either(Rc::new(Either { - id, - base: clear_name(&e.base), - extended_base: e.extended_base.clone(), - data: type_data, - })) - }, - NameRegistration(false), - ) - } + Store::register_type_def( + |id| { + TypeDef::Struct(Rc::new(Struct { + id, + base: clear_name(&s.base), + extended_base: s.extended_base.clone(), + data: type_data, + })) + }, + NameRegistration(false), + ) + } + + TypeDef::List(l) => { + let type_data = TypeList { + of: (self.mapper)(l.data.of.into())?.0, + ..l.data + }; + if type_data.of == l.data.of { + return Ok(type_id); + } + + Store::register_type_def( + |id| { + TypeDef::List(Rc::new(List { + id, + base: clear_name(&l.base), + extended_base: l.extended_base.clone(), + data: type_data, + })) + }, + NameRegistration(false), + ) + } - TypeDef::Boolean(_) - | TypeDef::Integer(_) - | TypeDef::Float(_) - | TypeDef::String(_) - | TypeDef::File(_) => Ok(type_id), + TypeDef::Optional(o) => { + let type_data = TypeOptional { + of: (self.mapper)(o.data.of.into())?.0, + ..o.data.clone() + }; + if type_data.of == o.data.of { + return Ok(type_id); + } - TypeDef::Func(_) => Ok(type_id), + Store::register_type_def( + |id| { + TypeDef::Optional(Rc::new(Optional { + id, + base: clear_name(&o.base), + extended_base: o.extended_base.clone(), + data: type_data, + })) + }, + NameRegistration(false), + ) + } + + TypeDef::Union(u) => { + let variants = u + .data + .variants + .iter() + .map(|id| -> Result<_> { Ok((self.mapper)(id.into())?.0) }) + .collect::>>()?; + if variants == u.data.variants { + return Ok(type_id); + } + let type_data = TypeUnion { variants }; + + Store::register_type_def( + |id| { + TypeDef::Union(Rc::new(Union { + id, + base: clear_name(&u.base), + extended_base: u.extended_base.clone(), + data: type_data, + })) + }, + NameRegistration(false), + ) + } + + TypeDef::Either(e) => { + let variants = e + .data + .variants + .iter() + .map(|id| -> Result<_> { Ok((self.mapper)(id.into())?.0) }) + .collect::>>()?; + if variants == e.data.variants { + return Ok(type_id); + } + let type_data = TypeEither { variants }; + + Store::register_type_def( + |id| { + TypeDef::Either(Rc::new(Either { + id, + base: clear_name(&e.base), + extended_base: e.extended_base.clone(), + data: type_data, + })) + }, + NameRegistration(false), + ) + } + + TypeDef::Boolean(_) + | TypeDef::Integer(_) + | TypeDef::Float(_) + | TypeDef::String(_) + | TypeDef::File(_) => Ok(type_id), + + TypeDef::Func(_) => Ok(type_id), + }?; + + Store::register_alias(self.result_aliases.get(&type_id).unwrap(), type_id)?; + + Ok(res) + } + + fn map_props(&mut self, struct_data: TypeStruct) -> Result { + let props = struct_data + .props + .iter() + .map(|(k, v)| -> Result<_> { Ok((k.clone(), (self.mapper)(v.into())?.0)) }) + .collect::>>()?; + Ok(TypeStruct { + props, + ..struct_data + }) } } -pub fn map_props(struct_data: TypeStruct, f: &F) -> Result +pub fn map_children(type_id: TypeId, f: &F) -> Result where F: Fn(TypeId) -> Result, { - let props = struct_data - .props - .iter() - .map(|(k, v)| -> Result<_> { Ok((k.clone(), f(v.into())?.0)) }) - .collect::>>()?; - Ok(TypeStruct { - props, - ..struct_data - }) + MapChildren::new(f).map_children(type_id) } From e282c41b9878ce30475e730dead3915cc8c4aa78 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Sat, 17 Feb 2024 00:46:56 +0300 Subject: [PATCH 27/32] fix input validator test --- typegraph/core/src/types/map_children.rs | 187 ----------------------- typegraph/core/src/types/mod.rs | 2 +- typegraph/core/src/types/subgraph/map.rs | 141 +++++++++++++++++ typegraph/core/src/types/subgraph/mod.rs | 24 +++ typegraph/core/src/types/type_def.rs | 25 +++ typegraph/core/src/utils/mod.rs | 5 +- 6 files changed, 193 insertions(+), 191 deletions(-) delete mode 100644 typegraph/core/src/types/map_children.rs create mode 100644 typegraph/core/src/types/subgraph/map.rs create mode 100644 typegraph/core/src/types/subgraph/mod.rs diff --git a/typegraph/core/src/types/map_children.rs b/typegraph/core/src/types/map_children.rs deleted file mode 100644 index 264de10da..000000000 --- a/typegraph/core/src/types/map_children.rs +++ /dev/null @@ -1,187 +0,0 @@ -// Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. -// SPDX-License-Identifier: MPL-2.0 - -use std::collections::HashMap; -use std::rc::Rc; - -use crate::errors::Result; -use crate::global_store::{NameRegistration, Store}; -use crate::t::{self, TypeBuilder}; -use crate::utils::clear_name; -use crate::wit::core::{TypeEither, TypeList, TypeOptional, TypeStruct, TypeUnion}; - -use super::{Either, List, Optional, Struct, TypeDef, TypeId, Union}; - -struct MapChildren -where - M: Fn(TypeId) -> Result, -{ - result_aliases: HashMap, - mapper: M, -} - -impl MapChildren -where - M: Fn(TypeId) -> Result, -{ - fn new(mapper: M) -> Self { - Self { - result_aliases: HashMap::new(), - mapper, - } - } - - fn map_children(&mut self, type_id: TypeId) -> Result { - let (_, type_def) = type_id.resolve_ref()?; - if let Some(alias) = self.result_aliases.get(&type_id) { - return t::ref_(alias).build(); - } - self.result_aliases.insert(type_id, Store::generate_alias()); - - let res = match type_def { - TypeDef::Struct(s) => { - let type_data = self.map_props(s.data.clone())?; - if type_data.props == s.data.props { - return Ok(type_id); - } - - Store::register_type_def( - |id| { - TypeDef::Struct(Rc::new(Struct { - id, - base: clear_name(&s.base), - extended_base: s.extended_base.clone(), - data: type_data, - })) - }, - NameRegistration(false), - ) - } - - TypeDef::List(l) => { - let type_data = TypeList { - of: (self.mapper)(l.data.of.into())?.0, - ..l.data - }; - if type_data.of == l.data.of { - return Ok(type_id); - } - - Store::register_type_def( - |id| { - TypeDef::List(Rc::new(List { - id, - base: clear_name(&l.base), - extended_base: l.extended_base.clone(), - data: type_data, - })) - }, - NameRegistration(false), - ) - } - - TypeDef::Optional(o) => { - let type_data = TypeOptional { - of: (self.mapper)(o.data.of.into())?.0, - ..o.data.clone() - }; - if type_data.of == o.data.of { - return Ok(type_id); - } - - Store::register_type_def( - |id| { - TypeDef::Optional(Rc::new(Optional { - id, - base: clear_name(&o.base), - extended_base: o.extended_base.clone(), - data: type_data, - })) - }, - NameRegistration(false), - ) - } - - TypeDef::Union(u) => { - let variants = u - .data - .variants - .iter() - .map(|id| -> Result<_> { Ok((self.mapper)(id.into())?.0) }) - .collect::>>()?; - if variants == u.data.variants { - return Ok(type_id); - } - let type_data = TypeUnion { variants }; - - Store::register_type_def( - |id| { - TypeDef::Union(Rc::new(Union { - id, - base: clear_name(&u.base), - extended_base: u.extended_base.clone(), - data: type_data, - })) - }, - NameRegistration(false), - ) - } - - TypeDef::Either(e) => { - let variants = e - .data - .variants - .iter() - .map(|id| -> Result<_> { Ok((self.mapper)(id.into())?.0) }) - .collect::>>()?; - if variants == e.data.variants { - return Ok(type_id); - } - let type_data = TypeEither { variants }; - - Store::register_type_def( - |id| { - TypeDef::Either(Rc::new(Either { - id, - base: clear_name(&e.base), - extended_base: e.extended_base.clone(), - data: type_data, - })) - }, - NameRegistration(false), - ) - } - - TypeDef::Boolean(_) - | TypeDef::Integer(_) - | TypeDef::Float(_) - | TypeDef::String(_) - | TypeDef::File(_) => Ok(type_id), - - TypeDef::Func(_) => Ok(type_id), - }?; - - Store::register_alias(self.result_aliases.get(&type_id).unwrap(), type_id)?; - - Ok(res) - } - - fn map_props(&mut self, struct_data: TypeStruct) -> Result { - let props = struct_data - .props - .iter() - .map(|(k, v)| -> Result<_> { Ok((k.clone(), (self.mapper)(v.into())?.0)) }) - .collect::>>()?; - Ok(TypeStruct { - props, - ..struct_data - }) - } -} - -pub fn map_children(type_id: TypeId, f: &F) -> Result -where - F: Fn(TypeId) -> Result, -{ - MapChildren::new(f).map_children(type_id) -} diff --git a/typegraph/core/src/types/mod.rs b/typegraph/core/src/types/mod.rs index 4b16e4bf3..0c837855a 100644 --- a/typegraph/core/src/types/mod.rs +++ b/typegraph/core/src/types/mod.rs @@ -1,7 +1,7 @@ // Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0. // SPDX-License-Identifier: MPL-2.0 -pub mod map_children; +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..e9727d733 --- /dev/null +++ b/typegraph/core/src/types/subgraph/map.rs @@ -0,0 +1,141 @@ +// 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 type_id = (self.mapper)(type_id)?; + + let res = self.map_children(type_id, ctx)?; + Store::register_alias(alias, res)?; + + 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 e1776d35e..2a2acf8aa 100644 --- a/typegraph/core/src/utils/mod.rs +++ b/typegraph/core/src/utils/mod.rs @@ -9,7 +9,7 @@ use serde_json::json; use crate::errors::Result; use crate::global_store::{NameRegistration, Store}; -use crate::types::map_children::map_children; +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}; @@ -263,8 +263,7 @@ impl crate::wit::utils::Guest for crate::Lib { } fn remove_injections_recursively(id: TypeId) -> Result { - let id = remove_injection(id)?; - map_children(id, &remove_injections_recursively) + Subgraph::new(id).map(remove_injection) } pub fn remove_injection(type_id: TypeId) -> Result { From ddca6e80264e885ba32b2ef4c6e8b3ebc0824536 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Sat, 17 Feb 2024 01:01:42 +0300 Subject: [PATCH 28/32] update snapshots --- .../__snapshots__/typecheck_test.ts.snap | 4 +- .../runtimes/prisma/type_generation/mod.rs | 13 +- ..._generation__test__aggregate Post out.snap | 44 +- ...eneration__test__aggregate Record out.snap | 44 +- ..._generation__test__aggregate User out.snap | 44 +- ...eneration__test__create_many Post inp.snap | 1642 +++---- ...eneration__test__create_many Post out.snap | 4 +- ...eration__test__create_many Record inp.snap | 16 +- ...eration__test__create_many Record out.snap | 4 +- ...eneration__test__create_many User inp.snap | 1746 +++---- ...eneration__test__create_many User out.snap | 4 +- ...generation__test__create_one Post inp.snap | 1640 +++---- ...neration__test__create_one Record inp.snap | 14 +- ...generation__test__create_one User inp.snap | 1744 +++---- ...generation__test__find_first Post out.snap | 14 +- ...neration__test__find_first Record out.snap | 12 +- ...generation__test__find_first User out.snap | 16 +- ..._generation__test__find_many Post inp.snap | 510 +- ..._generation__test__find_many Post out.snap | 18 +- ...eneration__test__find_many Record inp.snap | 382 +- ...eneration__test__find_many Record out.snap | 12 +- ..._generation__test__find_many User inp.snap | 930 ++-- ..._generation__test__find_many User out.snap | 22 +- ...eneration__test__find_unique Post inp.snap | 10 +- ...eneration__test__find_unique Post out.snap | 18 +- ...eration__test__find_unique Record inp.snap | 10 +- ...eration__test__find_unique Record out.snap | 12 +- ...eneration__test__find_unique User inp.snap | 10 +- ...eneration__test__find_unique User out.snap | 22 +- ...e_generation__test__group_by Post inp.snap | 1918 ++++---- ...e_generation__test__group_by Post out.snap | 52 +- ...generation__test__group_by Record inp.snap | 1238 ++--- ...generation__test__group_by Record out.snap | 54 +- ...e_generation__test__group_by User inp.snap | 3618 +++++++------- ...e_generation__test__group_by User out.snap | 54 +- ...eneration__test__update_many Post inp.snap | 2134 ++++---- ...eration__test__update_many Record inp.snap | 362 +- ...eneration__test__update_many User inp.snap | 4332 ++++++++--------- ...generation__test__update_one Post inp.snap | 1710 +++---- ...neration__test__update_one Record inp.snap | 56 +- ...generation__test__update_one User inp.snap | 3516 ++++++------- 41 files changed, 14003 insertions(+), 14002 deletions(-) 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/src/runtimes/prisma/type_generation/mod.rs b/typegraph/core/src/runtimes/prisma/type_generation/mod.rs index 56ad1f978..5c026b3f1 100644 --- a/typegraph/core/src/runtimes/prisma/type_generation/mod.rs +++ b/typegraph/core/src/runtimes/prisma/type_generation/mod.rs @@ -411,18 +411,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) ); } @@ -433,7 +434,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) ); } @@ -441,7 +442,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) ); } @@ -449,14 +450,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/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 d393d5d75..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 -│ ├── [author]: optional #39 -│ │ └── item: integer #38 -│ ├── [id]: optional #39 -│ │ └── item: integer #38 -│ └── [title]: optional #39 -│ └── item: integer #38 -├── [_max]: struct '_Post_NumberAgg' #48 -│ └── [id]: optional #47 -│ └── item: integer #46 -├── [_min]: struct '_Post_NumberAgg' #48 -│ └── [id]: optional #47 -│ └── item: integer #46 -└── [_sum]: struct '_Post_NumberAgg' #48 - └── [id]: optional #47 - └── item: integer #46 +├─ [_avg]: struct '_Post_NumberAgg_avg' #43 +│ └─ [id]: optional #42 +│ └─ item: float #41 +├─ [_count]: struct '_Post_AggrCount' #40 +│ ├─ [_all]: optional #39 +│ │ └─ item: integer #38 +│ ├─ [author]: optional #39 +│ │ └─ item: integer #38 +│ ├─ [id]: optional #39 +│ │ └─ item: integer #38 +│ └─ [title]: optional #39 +│ └─ item: integer #38 +├─ [_max]: struct '_Post_NumberAgg' #48 +│ └─ [id]: optional #47 +│ └─ item: integer #46 +├─ [_min]: struct '_Post_NumberAgg' #48 +│ └─ [id]: optional #47 +│ └─ item: integer #46 +└─ [_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 6158bf2fa..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 -│ ├── [age]: optional #6 -│ │ └── item: integer #5 -│ ├── [id]: optional #6 -│ │ └── item: integer #5 -│ └── [name]: optional #6 -│ └── item: integer #5 -├── [_max]: struct '_Record_NumberAgg' #15 -│ └── [age]: optional #14 -│ └── item: integer #13 -├── [_min]: struct '_Record_NumberAgg' #15 -│ └── [age]: optional #14 -│ └── item: integer #13 -└── [_sum]: struct '_Record_NumberAgg' #15 - └── [age]: optional #14 - └── item: integer #13 +├─ [_avg]: struct '_Record_NumberAgg_avg' #10 +│ └─ [age]: optional #9 +│ └─ item: float #8 +├─ [_count]: struct '_Record_AggrCount' #7 +│ ├─ [_all]: optional #6 +│ │ └─ item: integer #5 +│ ├─ [age]: optional #6 +│ │ └─ item: integer #5 +│ ├─ [id]: optional #6 +│ │ └─ item: integer #5 +│ └─ [name]: optional #6 +│ └─ item: integer #5 +├─ [_max]: struct '_Record_NumberAgg' #15 +│ └─ [age]: optional #14 +│ └─ item: integer #13 +├─ [_min]: struct '_Record_NumberAgg' #15 +│ └─ [age]: optional #14 +│ └─ item: integer #13 +└─ [_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 f125180d8..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,27 +1,27 @@ --- 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 -│ ├── [id]: optional #27 -│ │ └── item: integer #26 -│ ├── [name]: optional #27 -│ │ └── item: integer #26 -│ └── [posts]: optional #27 -│ └── item: integer #26 -├── [_max]: struct '_User_NumberAgg' #36 -│ └── [id]: optional #35 -│ └── item: integer #34 -├── [_min]: struct '_User_NumberAgg' #36 -│ └── [id]: optional #35 -│ └── item: integer #34 -└── [_sum]: struct '_User_NumberAgg' #36 - └── [id]: optional #35 - └── item: integer #34 +├─ [_avg]: struct '_User_NumberAgg_avg' #31 +│ └─ [id]: optional #30 +│ └─ item: float #29 +├─ [_count]: struct '_User_AggrCount' #28 +│ ├─ [_all]: optional #27 +│ │ └─ item: integer #26 +│ ├─ [id]: optional #27 +│ │ └─ item: integer #26 +│ ├─ [name]: optional #27 +│ │ └─ item: integer #26 +│ └─ [posts]: optional #27 +│ └─ item: integer #26 +├─ [_max]: struct '_User_NumberAgg' #36 +│ └─ [id]: optional #35 +│ └─ item: integer #34 +├─ [_min]: struct '_User_NumberAgg' #36 +│ └─ [id]: optional #35 +│ └─ item: integer #34 +└─ [_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 6bdb1cae4..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 +└─ [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 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 314f9b44c..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,7 +1,7 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: struct #112 -└── [count]: integer #111 +└─ [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 2b856061b..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 +└─ [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 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 298d13e54..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,7 +1,7 @@ --- 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 +└─ [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 f86d49c86..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,878 +1,878 @@ --- 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 - └── item: struct '_User_CreateInput' #80 - ├── [id]: integer #11 - ├── [name]: string #12 - └── [posts]: optional #79 - └── item: union #78 - ├── variant_0: struct #71 - │ └── [create]: union #23 - │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - │ │ ├── [id]: optional #20 - │ │ │ └── item: integer #16 - │ │ └── [title]: string #17 - │ └── variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 - │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - │ ├── [id]: optional #20 - │ │ └── item: integer #16 - │ └── [title]: string #17 - ├── 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 - │ │ │ ├── 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 '_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 - │ │ ├── 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 '_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 - │ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - │ │ │ ├── [id]: optional #20 - │ │ │ │ └── item: integer #16 - │ │ │ └── [title]: string #17 - │ │ └── variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 - │ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - │ │ ├── [id]: optional #20 - │ │ │ └── item: integer #16 - │ │ └── [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 - │ │ │ ├── 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 '_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 - │ │ ├── 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 '_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 - └── [data]: list #74 - └── item: union #23 - ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - │ ├── [id]: optional #20 - │ │ └── item: integer #16 - │ └── [title]: string #17 - └── variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 - └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 - ├── [id]: optional #20 - │ └── item: integer #16 - └── [title]: string #17 +└─ [data]: list '_81__User_CreateInput[]' #81 + └─ item: struct '_User_CreateInput' #80 + ├─ [id]: integer #11 + ├─ [name]: string #12 + └─ [posts]: optional #79 + └─ item: union #78 + ├─ variant_0: struct #71 + │ └─ [create]: union #23 + │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + │ │ ├─ [id]: optional #20 + │ │ │ └─ item: integer #16 + │ │ └─ [title]: string #17 + │ └─ variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 + │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + │ ├─ [id]: optional #20 + │ │ └─ item: integer #16 + │ └─ [title]: string #17 + ├─ 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 + │ │ │ ├─ 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 '_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 + │ │ ├─ 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 '_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 + │ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + │ │ │ ├─ [id]: optional #20 + │ │ │ │ └─ item: integer #16 + │ │ │ └─ [title]: string #17 + │ │ └─ variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 + │ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + │ │ ├─ [id]: optional #20 + │ │ │ └─ item: integer #16 + │ │ └─ [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 + │ │ │ ├─ 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 '_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 + │ │ ├─ 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 '_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 + └─ [data]: list #74 + └─ item: union #23 + ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + │ ├─ [id]: optional #20 + │ │ └─ item: integer #16 + │ └─ [title]: string #17 + └─ variant_1: list '_22__Post_CreateInput_excluding___rel_Post_User_1[]' #22 + └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #21 + ├─ [id]: optional #20 + │ └─ item: integer #16 + └─ [title]: string #17 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 a1548102b..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,7 +1,7 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(out)" +expression: tp.print(out) --- root: struct #84 -└── [count]: integer #83 +└─ [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 e1947f5f0..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 +└─ [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 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 f2221579f..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 +└─ [data]: struct '_Record_CreateInput' #6 + ├─ [age]: optional #3 + │ └─ item: integer #2 + ├─ [id]: optional #5 + │ └─ item: string #0 + └─ [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 39994fc21..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,877 +1,877 @@ --- 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 - ├── [id]: integer #8 - ├── [name]: string #9 - └── [posts]: optional #76 - └── item: union #75 - ├── variant_0: struct #68 - │ └── [create]: union #20 - │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - │ │ ├── [id]: optional #17 - │ │ │ └── item: integer #13 - │ │ └── [title]: string #14 - │ └── variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 - │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - │ ├── [id]: optional #17 - │ │ └── item: integer #13 - │ └── [title]: string #14 - ├── 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 - │ │ │ ├── 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 '_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 - │ │ ├── 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 '_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 - │ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - │ │ │ ├── [id]: optional #17 - │ │ │ │ └── item: integer #13 - │ │ │ └── [title]: string #14 - │ │ └── variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 - │ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - │ │ ├── [id]: optional #17 - │ │ │ └── item: integer #13 - │ │ └── [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 - │ │ │ ├── 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 '_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 - │ │ ├── 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 '_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 - └── [data]: list #71 - └── item: union #20 - ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - │ ├── [id]: optional #17 - │ │ └── item: integer #13 - │ └── [title]: string #14 - └── variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 - └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 - ├── [id]: optional #17 - │ └── item: integer #13 - └── [title]: string #14 +└─ [data]: struct '_User_CreateInput' #77 + ├─ [id]: integer #8 + ├─ [name]: string #9 + └─ [posts]: optional #76 + └─ item: union #75 + ├─ variant_0: struct #68 + │ └─ [create]: union #20 + │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + │ │ ├─ [id]: optional #17 + │ │ │ └─ item: integer #13 + │ │ └─ [title]: string #14 + │ └─ variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 + │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + │ ├─ [id]: optional #17 + │ │ └─ item: integer #13 + │ └─ [title]: string #14 + ├─ 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 + │ │ │ ├─ 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 '_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 + │ │ ├─ 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 '_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 + │ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + │ │ │ ├─ [id]: optional #17 + │ │ │ │ └─ item: integer #13 + │ │ │ └─ [title]: string #14 + │ │ └─ variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 + │ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + │ │ ├─ [id]: optional #17 + │ │ │ └─ item: integer #13 + │ │ └─ [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 + │ │ │ ├─ 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 '_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 + │ │ ├─ 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 '_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 + └─ [data]: list #71 + └─ item: union #20 + ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + │ ├─ [id]: optional #17 + │ │ └─ item: integer #13 + │ └─ [title]: string #14 + └─ variant_1: list '_19__Post_CreateInput_excluding___rel_Post_User_1[]' #19 + └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #18 + ├─ [id]: optional #17 + │ └─ item: integer #13 + └─ [title]: string #14 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 315f49d18..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 +└─ 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 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 7cda9466d..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 +└─ item: struct '_RecordOutputType' #5 + ├─ [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__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 e5f6ef357..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,13 +1,13 @@ --- 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 - ├── [id]: integer #7 - ├── [name]: string #8 - └── [posts]: list '_17__PostOutputType_excluding___rel_Post_User_1[]' #17 - └── item: struct '_PostOutputType_excluding___rel_Post_User_1' #16 - ├── [id]: integer #12 - └── [title]: string #13 +└─ item: struct '_UserOutputType' #18 + ├─ [id]: integer #7 + ├─ [name]: string #8 + └─ [posts]: list '_17__PostOutputType_excluding___rel_Post_User_1[]' #17 + └─ item: struct '_PostOutputType_excluding___rel_Post_User_1' #16 + ├─ [id]: integer #12 + └─ [title]: string #13 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 484d9c4b6..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 -├── [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"' } -├── [skip]: optional '_151__Skip?' #151 -│ └── item: integer '_Skip' #56 -├── [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 +├─ [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"' } +├─ [skip]: optional '_151__Skip?' #151 +│ └─ item: integer '_Skip' #56 +├─ [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 eab527b04..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 +└─ 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 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 443be946a..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 -├── [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 -│ ├── [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"' } -│ ├── [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"' } -├── [skip]: optional '_57__Skip?' #57 -│ └── item: integer '_Skip' #56 -├── [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 +├─ [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 +│ ├─ [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"' } +│ ├─ [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"' } +├─ [skip]: optional '_57__Skip?' #57 +│ └─ item: integer '_Skip' #56 +├─ [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 d7ce65c58..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 +└─ item: struct 'RecordWithNestedCount' #67 + ├─ [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__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 033bf0a9b..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,470 +1,470 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct '_User_QueryInput' #114 -├── [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 -│ ├── [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"' } -│ └── [posts]: optional '_SortByAggregates' #101 -│ └── item: struct #100 -│ ├── [_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"' } -│ ├── [_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"' } -│ ├── [_max]: 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"' } -│ ├── [_min]: 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 -│ └── item: union #46 -│ ├── variant_0: struct #45 -│ │ └── [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └── variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -├── [skip]: optional '_106__Skip?' #106 -│ └── item: integer '_Skip' #56 -├── [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 +├─ [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 +│ ├─ [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"' } +│ └─ [posts]: optional '_SortByAggregates' #101 +│ └─ item: struct #100 +│ ├─ [_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"' } +│ ├─ [_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"' } +│ ├─ [_max]: 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"' } +│ ├─ [_min]: 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 +│ └─ item: union #46 +│ ├─ variant_0: struct #45 +│ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +├─ [skip]: optional '_106__Skip?' #106 +│ └─ item: integer '_Skip' #56 +├─ [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 52bdf7195..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 +└─ 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 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 b2fc927a9..a1fe1ad1a 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,10 +1,10 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #34 -└── [where]: optional '_33_QueryUniquePostWhereInput?' #33 - └── item: struct 'QueryUniquePostWhereInput' #32 - └── [id]: optional #31 - └── item: integer #16 +└─ [where]: optional '_33_QueryUniquePostWhereInput?' #33 + └─ item: struct 'QueryUniquePostWhereInput' #32 + └─ [id]: optional #31 + └─ item: integer #16 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 ff54d838a..16bcf651e 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 '_36_PostWithNestedCount?' #36 -└── item: struct 'PostWithNestedCount' #35 - ├── [author]: struct 'User' #15 - │ ├── [id]: integer #11 - │ ├── [name]: string #12 - │ └── [posts]: list '_14_Post[]' #14 - │ └── item: &Post #13 - ├── [id]: integer #16 - └── [title]: string #17 +└─ item: struct 'PostWithNestedCount' #35 + ├─ [author]: struct 'User' #15 + │ ├─ [id]: integer #11 + │ ├─ [name]: string #12 + │ └─ [posts]: list '_14_Post[]' #14 + │ └─ item: &Post #13 + ├─ [id]: integer #16 + └─ [title]: string #17 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 6f38f5f5f..a86eddc3f 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,10 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #8 -└── [where]: optional '_7_QueryUniqueRecordWhereInput?' #7 - └── item: struct 'QueryUniqueRecordWhereInput' #6 - └── [id]: optional #5 - └── item: string #0 +└─ [where]: optional '_7_QueryUniqueRecordWhereInput?' #7 + └─ item: struct 'QueryUniqueRecordWhereInput' #6 + └─ [id]: optional #5 + └─ item: string #0 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 5959f6a00..becf17ce0 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: "tree::PrintOptions::new().indent_size(3).print(out)" --- root: optional '_10_RecordWithNestedCount?' #10 -└── item: struct 'RecordWithNestedCount' #9 - ├── [age]: optional #3 - │ └── item: integer #2 - ├── [id]: string #0 - └── [name]: string #1 +└─ item: struct 'RecordWithNestedCount' #9 + ├─ [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__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 517ff9883..97f8eb9ce 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,10 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #23 -└── [where]: optional '_22_QueryUniqueUserWhereInput?' #22 - └── item: struct 'QueryUniqueUserWhereInput' #21 - └── [id]: optional #20 - └── item: integer #11 +└─ [where]: optional '_22_QueryUniqueUserWhereInput?' #22 + └─ item: struct 'QueryUniqueUserWhereInput' #21 + └─ [id]: optional #20 + └─ item: integer #11 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 6dd6d61a8..ac5602acc 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 '_30_UserWithNestedCount?' #30 -└── item: struct 'UserWithNestedCount' #29 - ├── [_count]: struct #28 - │ └── [posts]: optional '_Count' #27 - │ └── item: integer #26 - ├── [id]: integer #11 - ├── [name]: string #12 - └── [posts]: list '_25_PostWithNestedCount_excluding___rel_Post_User_1[]' #25 - └── item: struct 'PostWithNestedCount_excluding___rel_Post_User_1' #24 - ├── [id]: integer #16 - └── [title]: string #17 +└─ item: struct 'UserWithNestedCount' #29 + ├─ [_count]: struct #28 + │ └─ [posts]: optional '_Count' #27 + │ └─ item: integer #26 + ├─ [id]: integer #11 + ├─ [name]: string #12 + └─ [posts]: list '_25_PostWithNestedCount_excluding___rel_Post_User_1[]' #25 + └─ item: struct 'PostWithNestedCount_excluding___rel_Post_User_1' #24 + ├─ [id]: integer #16 + └─ [title]: string #17 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 454777c93..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,964 +1,964 @@ --- 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 -├── [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 -│ │ ├── [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"' } -│ │ ├── [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"' } -│ ├── [_max]: 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"' } -│ ├── [_min]: 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"' } -│ ├── [_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"' } -├── [skip]: optional '_235__Skip?' #235 -│ └── item: integer '_Skip' #61 -├── [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 +├─ [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 +│ │ ├─ [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"' } +│ │ ├─ [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"' } +│ ├─ [_max]: 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"' } +│ ├─ [_min]: 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"' } +│ ├─ [_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"' } +├─ [skip]: optional '_235__Skip?' #235 +│ └─ item: integer '_Skip' #61 +├─ [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 47e28d357..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 - ├── [_avg]: struct '_Post_SelectNumbers__1' #272 - │ └── [id]: optional #271 - │ └── item: float #270 - ├── [_count]: struct '_Post_AggrCount' #269 - │ ├── [_all]: optional #268 - │ │ └── item: integer #267 - │ ├── [author]: optional #268 - │ │ └── item: integer #267 - │ ├── [id]: optional #268 - │ │ └── item: integer #267 - │ └── [title]: optional #268 - │ └── item: integer #267 - ├── [_max]: struct '_Post_SelectNumbers_' #277 - │ └── [id]: optional #276 - │ └── item: integer #275 - ├── [_min]: 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 +└─ item: struct #278 + ├─ [_avg]: struct '_Post_SelectNumbers__1' #272 + │ └─ [id]: optional #271 + │ └─ item: float #270 + ├─ [_count]: struct '_Post_AggrCount' #269 + │ ├─ [_all]: optional #268 + │ │ └─ item: integer #267 + │ ├─ [author]: optional #268 + │ │ └─ item: integer #267 + │ ├─ [id]: optional #268 + │ │ └─ item: integer #267 + │ └─ [title]: optional #268 + │ └─ item: integer #267 + ├─ [_max]: struct '_Post_SelectNumbers_' #277 + │ └─ [id]: optional #276 + │ └─ item: integer #275 + ├─ [_min]: 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 fd9f8dc59..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 -├── [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 -│ │ ├── [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"' } -│ │ ├── [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"' } -│ ├── [_max]: 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"' } -│ ├── [_min]: 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"' } -│ ├── [_sum]: 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"' } -│ ├── [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"' } -│ ├── [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"' } -├── [skip]: optional '_62__Skip?' #62 -│ └── item: integer '_Skip' #61 -├── [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 +├─ [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 +│ │ ├─ [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"' } +│ │ ├─ [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"' } +│ ├─ [_max]: 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"' } +│ ├─ [_min]: 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"' } +│ ├─ [_sum]: 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"' } +│ ├─ [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"' } +│ ├─ [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"' } +├─ [skip]: optional '_62__Skip?' #62 +│ └─ item: integer '_Skip' #61 +├─ [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 36a42bfdf..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 - ├── [_avg]: struct '_Record_SelectNumbers__1' #106 - │ └── [age]: optional #105 - │ └── item: float #104 - ├── [_count]: struct '_Record_AggrCount' #103 - │ ├── [_all]: optional #102 - │ │ └── item: integer #101 - │ ├── [age]: optional #102 - │ │ └── item: integer #101 - │ ├── [id]: optional #102 - │ │ └── item: integer #101 - │ └── [name]: optional #102 - │ └── item: integer #101 - ├── [_max]: struct '_Record_SelectNumbers_' #111 - │ └── [age]: optional #110 - │ └── item: integer #109 - ├── [_min]: 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 +└─ item: struct #112 + ├─ [_avg]: struct '_Record_SelectNumbers__1' #106 + │ └─ [age]: optional #105 + │ └─ item: float #104 + ├─ [_count]: struct '_Record_AggrCount' #103 + │ ├─ [_all]: optional #102 + │ │ └─ item: integer #101 + │ ├─ [age]: optional #102 + │ │ └─ item: integer #101 + │ ├─ [id]: optional #102 + │ │ └─ item: integer #101 + │ └─ [name]: optional #102 + │ └─ item: integer #101 + ├─ [_max]: struct '_Record_SelectNumbers_' #111 + │ └─ [age]: optional #110 + │ └─ item: integer #109 + ├─ [_min]: 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 440225263..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,1814 +1,1814 @@ --- 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 -├── [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 -│ │ │ └── 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"' } -│ │ └── [posts]: 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"' } -│ ├── [_max]: 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"' } -│ ├── [_min]: 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 -│ │ └── 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"' } -│ ├── [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"' } -│ └── [posts]: optional '_SortByAggregates' #151 -│ └── item: struct #150 -│ ├── [_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"' } -│ ├── [_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"' } -│ ├── [_max]: 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"' } -│ ├── [_min]: 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 -│ └── item: union #46 -│ ├── variant_0: struct #45 -│ │ └── [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -│ └── variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } -├── [skip]: optional '_156__Skip?' #156 -│ └── item: integer '_Skip' #61 -├── [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 +├─ [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 +│ │ │ └─ 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"' } +│ │ └─ [posts]: 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"' } +│ ├─ [_max]: 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"' } +│ ├─ [_min]: 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 +│ │ └─ 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"' } +│ ├─ [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"' } +│ └─ [posts]: optional '_SortByAggregates' #151 +│ └─ item: struct #150 +│ ├─ [_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"' } +│ ├─ [_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"' } +│ ├─ [_max]: 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"' } +│ ├─ [_min]: 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 +│ └─ item: union #46 +│ ├─ variant_0: struct #45 +│ │ └─ [sort]: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +│ └─ variant_1: string '_SortOrder' #43 enum{ '"asc"', '"desc"' } +├─ [skip]: optional '_156__Skip?' #156 +│ └─ item: integer '_Skip' #61 +├─ [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 d45bd36e2..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,32 +1,32 @@ --- 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 - ├── [_avg]: struct '_User_SelectNumbers__1' #193 - │ └── [id]: optional #192 - │ └── item: float #191 - ├── [_count]: struct '_User_AggrCount' #190 - │ ├── [_all]: optional #189 - │ │ └── item: integer #188 - │ ├── [id]: optional #189 - │ │ └── item: integer #188 - │ ├── [name]: optional #189 - │ │ └── item: integer #188 - │ └── [posts]: optional #189 - │ └── item: integer #188 - ├── [_max]: struct '_User_SelectNumbers_' #198 - │ └── [id]: optional #197 - │ └── item: integer #196 - ├── [_min]: 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 +└─ item: struct #199 + ├─ [_avg]: struct '_User_SelectNumbers__1' #193 + │ └─ [id]: optional #192 + │ └─ item: float #191 + ├─ [_count]: struct '_User_AggrCount' #190 + │ ├─ [_all]: optional #189 + │ │ └─ item: integer #188 + │ ├─ [id]: optional #189 + │ │ └─ item: integer #188 + │ ├─ [name]: optional #189 + │ │ └─ item: integer #188 + │ └─ [posts]: optional #189 + │ └─ item: integer #188 + ├─ [_max]: struct '_User_SelectNumbers_' #198 + │ └─ [id]: optional #197 + │ └─ item: integer #196 + ├─ [_min]: 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 02da9b58f..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,1072 +1,1072 @@ --- 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 -│ │ ├── variant_1: struct #148 -│ │ │ └── [set]: integer #62 -│ │ ├── variant_2: struct #149 -│ │ │ └── [multiply]: integer #62 -│ │ ├── variant_3: struct #150 -│ │ │ └── [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 -└── [where]: optional '_181_QueryPostWhereInput?' #181 - └── item: struct 'QueryPostWhereInput' #180 - ├── [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 - │ │ └── 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 +├─ [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 +│ │ ├─ variant_1: struct #148 +│ │ │ └─ [set]: integer #62 +│ │ ├─ variant_2: struct #149 +│ │ │ └─ [multiply]: integer #62 +│ │ ├─ variant_3: struct #150 +│ │ │ └─ [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 +└─ [where]: optional '_181_QueryPostWhereInput?' #181 + └─ item: struct 'QueryPostWhereInput' #180 + ├─ [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 + │ │ └─ 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 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 922a7f937..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,186 +1,186 @@ --- 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 -└── [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 - │ ├── 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 - └── [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 +├─ [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 +└─ [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 + │ ├─ 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 + └─ [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 688d4144f..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,2171 +1,2171 @@ --- 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 -│ ├── [id]: optional #71 -│ │ └── item: union #70 -│ │ ├── variant_0: integer #57 -│ │ ├── variant_1: struct #66 -│ │ │ └── [set]: integer #57 -│ │ ├── variant_2: struct #67 -│ │ │ └── [multiply]: integer #57 -│ │ ├── variant_3: struct #68 -│ │ │ └── [decrement]: integer #57 -│ │ └── variant_4: struct #69 -│ │ └── [increment]: integer #57 -│ ├── [name]: optional #74 -│ │ └── item: union #73 -│ │ ├── variant_0: string #58 -│ │ └── variant_1: struct #72 -│ │ └── [set]: string #58 -│ └── [posts]: optional #123 -│ └── item: union #122 -│ ├── variant_0: struct #98 -│ │ └── [create]: union #78 -│ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ │ │ ├── [id]: optional #75 -│ │ │ │ └── item: integer #62 -│ │ │ └── [title]: string #63 -│ │ └── variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 -│ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ │ ├── [id]: optional #75 -│ │ │ └── item: integer #62 -│ │ └── [title]: string #63 -│ ├── 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 -│ │ │ │ ├── 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_2: struct #100 -│ │ └── [connectOrCreate]: struct #97 -│ │ ├── [create]: union #78 -│ │ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ │ │ │ ├── [id]: optional #75 -│ │ │ │ │ └── item: integer #62 -│ │ │ │ └── [title]: string #63 -│ │ │ └── variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 -│ │ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ │ │ ├── [id]: optional #75 -│ │ │ │ └── item: integer #62 -│ │ │ └── [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 -│ │ │ │ ├── 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_3: struct #111 -│ │ └── [update]: 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 -│ ├── variant_4: struct #114 -│ │ └── [updateMany]: struct #113 -│ │ ├── [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 -│ │ │ │ ├── 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_6: struct #121 -│ └── [createMany]: optional #120 -│ └── item: struct #119 -│ └── [data]: list #118 -│ └── item: union #78 -│ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ │ ├── [id]: optional #75 -│ │ │ └── item: integer #62 -│ │ └── [title]: string #63 -│ └── variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 -│ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 -│ ├── [id]: optional #75 -│ │ └── item: integer #62 -│ └── [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 - │ ├── 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 +├─ [data]: struct '_User_UpdateInput' #124 +│ ├─ [id]: optional #71 +│ │ └─ item: union #70 +│ │ ├─ variant_0: integer #57 +│ │ ├─ variant_1: struct #66 +│ │ │ └─ [set]: integer #57 +│ │ ├─ variant_2: struct #67 +│ │ │ └─ [multiply]: integer #57 +│ │ ├─ variant_3: struct #68 +│ │ │ └─ [decrement]: integer #57 +│ │ └─ variant_4: struct #69 +│ │ └─ [increment]: integer #57 +│ ├─ [name]: optional #74 +│ │ └─ item: union #73 +│ │ ├─ variant_0: string #58 +│ │ └─ variant_1: struct #72 +│ │ └─ [set]: string #58 +│ └─ [posts]: optional #123 +│ └─ item: union #122 +│ ├─ variant_0: struct #98 +│ │ └─ [create]: union #78 +│ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ │ │ ├─ [id]: optional #75 +│ │ │ │ └─ item: integer #62 +│ │ │ └─ [title]: string #63 +│ │ └─ variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 +│ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ │ ├─ [id]: optional #75 +│ │ │ └─ item: integer #62 +│ │ └─ [title]: string #63 +│ ├─ 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 +│ │ │ │ ├─ 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_2: struct #100 +│ │ └─ [connectOrCreate]: struct #97 +│ │ ├─ [create]: union #78 +│ │ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ │ │ │ ├─ [id]: optional #75 +│ │ │ │ │ └─ item: integer #62 +│ │ │ │ └─ [title]: string #63 +│ │ │ └─ variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 +│ │ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ │ │ ├─ [id]: optional #75 +│ │ │ │ └─ item: integer #62 +│ │ │ └─ [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 +│ │ │ │ ├─ 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_3: struct #111 +│ │ └─ [update]: 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 +│ ├─ variant_4: struct #114 +│ │ └─ [updateMany]: struct #113 +│ │ ├─ [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 +│ │ │ │ ├─ 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_6: struct #121 +│ └─ [createMany]: optional #120 +│ └─ item: struct #119 +│ └─ [data]: list #118 +│ └─ item: union #78 +│ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ │ ├─ [id]: optional #75 +│ │ │ └─ item: integer #62 +│ │ └─ [title]: string #63 +│ └─ variant_1: list '_77__Post_CreateInput_excluding___rel_Post_User_1[]' #77 +│ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #76 +│ ├─ [id]: optional #75 +│ │ └─ item: integer #62 +│ └─ [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 + │ ├─ 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 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 50d485010..8d0f0099e 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,860 +1,860 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #166 -├── [data]: struct '_Post_UpdateInput' #163 -│ ├── [author]: optional #162 -│ │ └── item: union #161 -│ │ ├── variant_0: struct #147 -│ │ │ └── [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #129 -│ │ │ ├── [id]: integer #21 -│ │ │ └── [name]: string #22 -│ │ ├── variant_1: struct #148 -│ │ │ └── [connect]: struct 'UserWhere' #145 -│ │ │ ├── [id]: optional '_130__integer_filter_c?' #130 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ ├── [name]: optional '_131__string_filter_c?' #131 -│ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ └── item: union #70 -│ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── variant_1: struct #69 -│ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [posts]: optional #144 -│ │ │ └── item: union #143 -│ │ │ ├── variant_0: struct #138 -│ │ │ │ └── [every]: optional '_137_PostWhere__skip_25_UserWhere?' #137 -│ │ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ │ ├── [author]: optional '_135_UserWhere?' #135 -│ │ │ │ │ └── item: &UserWhere #134 -│ │ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ │ └── item: union #53 -│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_1: struct #52 -│ │ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ └── item: union #70 -│ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── variant_1: struct #69 -│ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_1: struct #140 -│ │ │ │ └── [some]: optional '_139_PostWhere__skip_25_UserWhere?' #139 -│ │ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ │ ├── [author]: optional '_135_UserWhere?' #135 -│ │ │ │ │ └── item: &UserWhere #134 -│ │ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ │ └── item: union #53 -│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_1: struct #52 -│ │ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ └── item: union #70 -│ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── variant_1: struct #69 -│ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── variant_2: struct #142 -│ │ │ └── [none]: optional '_141_PostWhere__skip_25_UserWhere?' #141 -│ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ ├── [author]: optional '_135_UserWhere?' #135 -│ │ │ │ └── item: &UserWhere #134 -│ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── [title]: optional '_133__string_filter_c?' #133 -│ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ └── item: union #70 -│ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── variant_1: struct #69 -│ │ │ └── [not]: union '_string_filter' #68 -│ │ │ ├── variant_0: string #56 -│ │ │ ├── variant_1: struct #59 -│ │ │ │ └── [equals]: string #56 -│ │ │ ├── variant_2: struct #60 -│ │ │ │ └── [not]: string #56 -│ │ │ ├── variant_3: struct #61 -│ │ │ │ └── [in]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_4: struct #62 -│ │ │ │ └── [notIn]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_5: struct #65 -│ │ │ │ ├── [contains]: string #56 -│ │ │ │ └── [mode]: optional #64 -│ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ ├── variant_6: struct #66 -│ │ │ │ └── [search]: string #56 -│ │ │ └── variant_7: struct #67 -│ │ │ ├── [endsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [startsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ ├── variant_2: struct #149 -│ │ │ └── [connectOrCreate]: struct #146 -│ │ │ ├── [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #129 -│ │ │ │ ├── [id]: integer #21 -│ │ │ │ └── [name]: string #22 -│ │ │ └── [where]: struct 'UserWhere' #145 -│ │ │ ├── [id]: optional '_130__integer_filter_c?' #130 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ ├── [name]: optional '_131__string_filter_c?' #131 -│ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ └── item: union #70 -│ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── variant_1: struct #69 -│ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [posts]: optional #144 -│ │ │ └── item: union #143 -│ │ │ ├── variant_0: struct #138 -│ │ │ │ └── [every]: optional '_137_PostWhere__skip_25_UserWhere?' #137 -│ │ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ │ ├── [author]: optional '_135_UserWhere?' #135 -│ │ │ │ │ └── item: &UserWhere #134 -│ │ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ │ └── item: union #53 -│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_1: struct #52 -│ │ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ └── item: union #70 -│ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── variant_1: struct #69 -│ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_1: struct #140 -│ │ │ │ └── [some]: optional '_139_PostWhere__skip_25_UserWhere?' #139 -│ │ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ │ ├── [author]: optional '_135_UserWhere?' #135 -│ │ │ │ │ └── item: &UserWhere #134 -│ │ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ │ └── item: union #53 -│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_1: struct #52 -│ │ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ └── item: union #70 -│ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── variant_1: struct #69 -│ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── variant_2: struct #142 -│ │ │ └── [none]: optional '_141_PostWhere__skip_25_UserWhere?' #141 -│ │ │ └── item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ ├── [author]: optional '_135_UserWhere?' #135 -│ │ │ │ └── item: &UserWhere #134 -│ │ │ ├── [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── [title]: optional '_133__string_filter_c?' #133 -│ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ └── item: union #70 -│ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── variant_1: struct #69 -│ │ │ └── [not]: union '_string_filter' #68 -│ │ │ ├── variant_0: string #56 -│ │ │ ├── variant_1: struct #59 -│ │ │ │ └── [equals]: string #56 -│ │ │ ├── variant_2: struct #60 -│ │ │ │ └── [not]: string #56 -│ │ │ ├── variant_3: struct #61 -│ │ │ │ └── [in]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_4: struct #62 -│ │ │ │ └── [notIn]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_5: struct #65 -│ │ │ │ ├── [contains]: string #56 -│ │ │ │ └── [mode]: optional #64 -│ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ ├── variant_6: struct #66 -│ │ │ │ └── [search]: string #56 -│ │ │ └── variant_7: struct #67 -│ │ │ ├── [endsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [startsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── variant_3: struct #160 -│ │ └── [update]: struct '_User_UpdateInput_excluding___rel_Post_User_1' #159 -│ │ ├── [id]: optional #155 -│ │ │ └── item: union #154 -│ │ │ ├── variant_0: integer #21 -│ │ │ ├── variant_1: struct #150 -│ │ │ │ └── [set]: integer #21 -│ │ │ ├── variant_2: struct #151 -│ │ │ │ └── [multiply]: integer #21 -│ │ │ ├── variant_3: struct #152 -│ │ │ │ └── [decrement]: integer #21 -│ │ │ └── variant_4: struct #153 -│ │ │ └── [increment]: integer #21 -│ │ └── [name]: optional #158 -│ │ └── item: union #157 -│ │ ├── variant_0: string #22 -│ │ └── variant_1: struct #156 -│ │ └── [set]: string #22 -│ ├── [id]: optional #125 -│ │ └── item: union #124 -│ │ ├── variant_0: integer #26 -│ │ ├── variant_1: struct #120 -│ │ │ └── [set]: integer #26 -│ │ ├── variant_2: struct #121 -│ │ │ └── [multiply]: integer #26 -│ │ ├── variant_3: struct #122 -│ │ │ └── [decrement]: integer #26 -│ │ └── variant_4: struct #123 -│ │ └── [increment]: integer #26 -│ └── [title]: optional #128 -│ └── item: union #127 -│ ├── variant_0: string #27 -│ └── variant_1: struct #126 -│ └── [set]: string #27 -└── [where]: struct 'QueryUniquePostWhereInput' #165 - └── [id]: optional #164 - └── item: integer #26 +├─ [data]: struct '_Post_UpdateInput' #163 +│ ├─ [author]: optional #162 +│ │ └─ item: union #161 +│ │ ├─ variant_0: struct #147 +│ │ │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #129 +│ │ │ ├─ [id]: integer #21 +│ │ │ └─ [name]: string #22 +│ │ ├─ variant_1: struct #148 +│ │ │ └─ [connect]: struct 'UserWhere' #145 +│ │ │ ├─ [id]: optional '_130__integer_filter_c?' #130 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ ├─ [name]: optional '_131__string_filter_c?' #131 +│ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ └─ item: union #70 +│ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ variant_1: struct #69 +│ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [posts]: optional #144 +│ │ │ └─ item: union #143 +│ │ │ ├─ variant_0: struct #138 +│ │ │ │ └─ [every]: optional '_137_PostWhere__skip_25_UserWhere?' #137 +│ │ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ │ ├─ [author]: optional '_135_UserWhere?' #135 +│ │ │ │ │ └─ item: &UserWhere #134 +│ │ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ │ └─ item: union #53 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_1: struct #52 +│ │ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ [title]: optional '_133__string_filter_c?' #133 +│ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ └─ item: union #70 +│ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ variant_1: struct #69 +│ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_1: struct #140 +│ │ │ │ └─ [some]: optional '_139_PostWhere__skip_25_UserWhere?' #139 +│ │ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ │ ├─ [author]: optional '_135_UserWhere?' #135 +│ │ │ │ │ └─ item: &UserWhere #134 +│ │ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ │ └─ item: union #53 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_1: struct #52 +│ │ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ [title]: optional '_133__string_filter_c?' #133 +│ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ └─ item: union #70 +│ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ variant_1: struct #69 +│ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ variant_2: struct #142 +│ │ │ └─ [none]: optional '_141_PostWhere__skip_25_UserWhere?' #141 +│ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ ├─ [author]: optional '_135_UserWhere?' #135 +│ │ │ │ └─ item: &UserWhere #134 +│ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ [title]: optional '_133__string_filter_c?' #133 +│ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ └─ item: union #70 +│ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ variant_1: struct #69 +│ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ ├─ variant_0: string #56 +│ │ │ ├─ variant_1: struct #59 +│ │ │ │ └─ [equals]: string #56 +│ │ │ ├─ variant_2: struct #60 +│ │ │ │ └─ [not]: string #56 +│ │ │ ├─ variant_3: struct #61 +│ │ │ │ └─ [in]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_4: struct #62 +│ │ │ │ └─ [notIn]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_5: struct #65 +│ │ │ │ ├─ [contains]: string #56 +│ │ │ │ └─ [mode]: optional #64 +│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #66 +│ │ │ │ └─ [search]: string #56 +│ │ │ └─ variant_7: struct #67 +│ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [startsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ ├─ variant_2: struct #149 +│ │ │ └─ [connectOrCreate]: struct #146 +│ │ │ ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #129 +│ │ │ │ ├─ [id]: integer #21 +│ │ │ │ └─ [name]: string #22 +│ │ │ └─ [where]: struct 'UserWhere' #145 +│ │ │ ├─ [id]: optional '_130__integer_filter_c?' #130 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ ├─ [name]: optional '_131__string_filter_c?' #131 +│ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ └─ item: union #70 +│ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ variant_1: struct #69 +│ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [posts]: optional #144 +│ │ │ └─ item: union #143 +│ │ │ ├─ variant_0: struct #138 +│ │ │ │ └─ [every]: optional '_137_PostWhere__skip_25_UserWhere?' #137 +│ │ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ │ ├─ [author]: optional '_135_UserWhere?' #135 +│ │ │ │ │ └─ item: &UserWhere #134 +│ │ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ │ └─ item: union #53 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_1: struct #52 +│ │ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ [title]: optional '_133__string_filter_c?' #133 +│ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ └─ item: union #70 +│ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ variant_1: struct #69 +│ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_1: struct #140 +│ │ │ │ └─ [some]: optional '_139_PostWhere__skip_25_UserWhere?' #139 +│ │ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ │ ├─ [author]: optional '_135_UserWhere?' #135 +│ │ │ │ │ └─ item: &UserWhere #134 +│ │ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ │ └─ item: union #53 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_1: struct #52 +│ │ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ [title]: optional '_133__string_filter_c?' #133 +│ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ └─ item: union #70 +│ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ variant_1: struct #69 +│ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ variant_2: struct #142 +│ │ │ └─ [none]: optional '_141_PostWhere__skip_25_UserWhere?' #141 +│ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 +│ │ │ ├─ [author]: optional '_135_UserWhere?' #135 +│ │ │ │ └─ item: &UserWhere #134 +│ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ [title]: optional '_133__string_filter_c?' #133 +│ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ └─ item: union #70 +│ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ variant_1: struct #69 +│ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ ├─ variant_0: string #56 +│ │ │ ├─ variant_1: struct #59 +│ │ │ │ └─ [equals]: string #56 +│ │ │ ├─ variant_2: struct #60 +│ │ │ │ └─ [not]: string #56 +│ │ │ ├─ variant_3: struct #61 +│ │ │ │ └─ [in]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_4: struct #62 +│ │ │ │ └─ [notIn]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_5: struct #65 +│ │ │ │ ├─ [contains]: string #56 +│ │ │ │ └─ [mode]: optional #64 +│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #66 +│ │ │ │ └─ [search]: string #56 +│ │ │ └─ variant_7: struct #67 +│ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [startsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ variant_3: struct #160 +│ │ └─ [update]: struct '_User_UpdateInput_excluding___rel_Post_User_1' #159 +│ │ ├─ [id]: optional #155 +│ │ │ └─ item: union #154 +│ │ │ ├─ variant_0: integer #21 +│ │ │ ├─ variant_1: struct #150 +│ │ │ │ └─ [set]: integer #21 +│ │ │ ├─ variant_2: struct #151 +│ │ │ │ └─ [multiply]: integer #21 +│ │ │ ├─ variant_3: struct #152 +│ │ │ │ └─ [decrement]: integer #21 +│ │ │ └─ variant_4: struct #153 +│ │ │ └─ [increment]: integer #21 +│ │ └─ [name]: optional #158 +│ │ └─ item: union #157 +│ │ ├─ variant_0: string #22 +│ │ └─ variant_1: struct #156 +│ │ └─ [set]: string #22 +│ ├─ [id]: optional #125 +│ │ └─ item: union #124 +│ │ ├─ variant_0: integer #26 +│ │ ├─ variant_1: struct #120 +│ │ │ └─ [set]: integer #26 +│ │ ├─ variant_2: struct #121 +│ │ │ └─ [multiply]: integer #26 +│ │ ├─ variant_3: struct #122 +│ │ │ └─ [decrement]: integer #26 +│ │ └─ variant_4: struct #123 +│ │ └─ [increment]: integer #26 +│ └─ [title]: optional #128 +│ └─ item: union #127 +│ ├─ variant_0: string #27 +│ └─ variant_1: struct #126 +│ └─ [set]: string #27 +└─ [where]: struct 'QueryUniquePostWhereInput' #165 + └─ [id]: optional #164 + └─ item: integer #26 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 3a55f13ad..074ce3ce6 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,33 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #20 -├── [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 -└── [where]: struct 'QueryUniqueRecordWhereInput' #19 - └── [id]: optional #18 - └── item: string #0 +├─ [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 +└─ [where]: struct 'QueryUniqueRecordWhereInput' #19 + └─ [id]: optional #18 + └─ item: string #0 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 f892b46f7..8526fc099 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,1763 +1,1763 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::print(inp)" +expression: tp.print(inp) --- root: struct #119 -├── [data]: struct '_User_UpdateInput' #116 -│ ├── [id]: optional #35 -│ │ └── item: union #34 -│ │ ├── variant_0: integer #21 -│ │ ├── variant_1: struct #30 -│ │ │ └── [set]: integer #21 -│ │ ├── variant_2: struct #31 -│ │ │ └── [multiply]: integer #21 -│ │ ├── variant_3: struct #32 -│ │ │ └── [decrement]: integer #21 -│ │ └── variant_4: struct #33 -│ │ └── [increment]: integer #21 -│ ├── [name]: optional #38 -│ │ └── item: union #37 -│ │ ├── variant_0: string #22 -│ │ └── variant_1: struct #36 -│ │ └── [set]: string #22 -│ └── [posts]: optional #115 -│ └── item: union #114 -│ ├── variant_0: struct #90 -│ │ └── [create]: union #42 -│ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ │ ├── [id]: optional #39 -│ │ │ │ └── item: integer #26 -│ │ │ └── [title]: string #27 -│ │ └── variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 -│ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ ├── [id]: optional #39 -│ │ │ └── item: integer #26 -│ │ └── [title]: string #27 -│ ├── variant_1: struct #91 -│ │ └── [connect]: union #88 -│ │ ├── variant_0: struct 'PostWhere' #86 -│ │ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ │ └── item: union #53 -│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_1: struct #52 -│ │ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ │ └── item: union #70 -│ │ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── variant_1: struct #69 -│ │ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [posts]: optional #83 -│ │ │ │ └── item: union #82 -│ │ │ │ ├── variant_0: struct #77 -│ │ │ │ │ └── [every]: optional '_76_PostWhere?' #76 -│ │ │ │ │ └── item: &PostWhere #75 -│ │ │ │ ├── variant_1: struct #79 -│ │ │ │ │ └── [some]: optional '_78_PostWhere?' #78 -│ │ │ │ │ └── item: &PostWhere #75 -│ │ │ │ └── variant_2: struct #81 -│ │ │ │ └── [none]: optional '_80_PostWhere?' #80 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ ├── [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── [title]: optional '_72__string_filter_c?' #72 -│ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ └── item: union #70 -│ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── variant_1: struct #69 -│ │ │ └── [not]: union '_string_filter' #68 -│ │ │ ├── variant_0: string #56 -│ │ │ ├── variant_1: struct #59 -│ │ │ │ └── [equals]: string #56 -│ │ │ ├── variant_2: struct #60 -│ │ │ │ └── [not]: string #56 -│ │ │ ├── variant_3: struct #61 -│ │ │ │ └── [in]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_4: struct #62 -│ │ │ │ └── [notIn]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_5: struct #65 -│ │ │ │ ├── [contains]: string #56 -│ │ │ │ └── [mode]: optional #64 -│ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ ├── variant_6: struct #66 -│ │ │ │ └── [search]: string #56 -│ │ │ └── variant_7: struct #67 -│ │ │ ├── [endsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [startsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── variant_1: list '_87_PostWhere[]' #87 -│ │ └── item: struct 'PostWhere' #86 -│ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ ├── [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ └── item: union #70 -│ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── variant_1: struct #69 -│ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [posts]: optional #83 -│ │ │ └── item: union #82 -│ │ │ ├── variant_0: struct #77 -│ │ │ │ └── [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ ├── variant_1: struct #79 -│ │ │ │ └── [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ └── variant_2: struct #81 -│ │ │ └── [none]: optional '_80_PostWhere?' #80 -│ │ │ └── item: &PostWhere #75 -│ │ ├── [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ └── item: union #53 -│ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── variant_1: struct #52 -│ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ ├── variant_0: integer #43 -│ │ │ ├── variant_1: struct #46 -│ │ │ │ └── [equals]: integer #43 -│ │ │ ├── variant_2: struct #47 -│ │ │ │ └── [not]: integer #43 -│ │ │ ├── variant_3: struct #48 -│ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── [lte]: optional #44 -│ │ │ │ └── item: integer #43 -│ │ │ ├── variant_4: struct #49 -│ │ │ │ └── [in]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── variant_5: struct #50 -│ │ │ └── [notIn]: list #45 -│ │ │ └── item: integer #43 -│ │ └── [title]: optional '_72__string_filter_c?' #72 -│ │ └── item: optional '_string_filter_c' #71 -│ │ └── item: union #70 -│ │ ├── variant_0: union '_string_filter' #68 -│ │ │ ├── variant_0: string #56 -│ │ │ ├── variant_1: struct #59 -│ │ │ │ └── [equals]: string #56 -│ │ │ ├── variant_2: struct #60 -│ │ │ │ └── [not]: string #56 -│ │ │ ├── variant_3: struct #61 -│ │ │ │ └── [in]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_4: struct #62 -│ │ │ │ └── [notIn]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_5: struct #65 -│ │ │ │ ├── [contains]: string #56 -│ │ │ │ └── [mode]: optional #64 -│ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ ├── variant_6: struct #66 -│ │ │ │ └── [search]: string #56 -│ │ │ └── variant_7: struct #67 -│ │ │ ├── [endsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [startsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── variant_1: struct #69 -│ │ └── [not]: union '_string_filter' #68 -│ │ ├── variant_0: string #56 -│ │ ├── variant_1: struct #59 -│ │ │ └── [equals]: string #56 -│ │ ├── variant_2: struct #60 -│ │ │ └── [not]: string #56 -│ │ ├── variant_3: struct #61 -│ │ │ └── [in]: list #58 -│ │ │ └── item: string #56 -│ │ ├── variant_4: struct #62 -│ │ │ └── [notIn]: list #58 -│ │ │ └── item: string #56 -│ │ ├── variant_5: struct #65 -│ │ │ ├── [contains]: string #56 -│ │ │ └── [mode]: optional #64 -│ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ ├── variant_6: struct #66 -│ │ │ └── [search]: string #56 -│ │ └── variant_7: struct #67 -│ │ ├── [endsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── [startsWith]: optional #57 -│ │ └── item: string #56 -│ ├── variant_2: struct #92 -│ │ └── [connectOrCreate]: struct #89 -│ │ ├── [create]: union #42 -│ │ │ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ │ │ ├── [id]: optional #39 -│ │ │ │ │ └── item: integer #26 -│ │ │ │ └── [title]: string #27 -│ │ │ └── variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 -│ │ │ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ │ ├── [id]: optional #39 -│ │ │ │ └── item: integer #26 -│ │ │ └── [title]: string #27 -│ │ └── [where]: union #88 -│ │ ├── variant_0: struct 'PostWhere' #86 -│ │ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ │ └── item: union #53 -│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_1: struct #52 -│ │ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ │ └── item: union #70 -│ │ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── variant_1: struct #69 -│ │ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [posts]: optional #83 -│ │ │ │ └── item: union #82 -│ │ │ │ ├── variant_0: struct #77 -│ │ │ │ │ └── [every]: optional '_76_PostWhere?' #76 -│ │ │ │ │ └── item: &PostWhere #75 -│ │ │ │ ├── variant_1: struct #79 -│ │ │ │ │ └── [some]: optional '_78_PostWhere?' #78 -│ │ │ │ │ └── item: &PostWhere #75 -│ │ │ │ └── variant_2: struct #81 -│ │ │ │ └── [none]: optional '_80_PostWhere?' #80 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ ├── [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── [title]: optional '_72__string_filter_c?' #72 -│ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ └── item: union #70 -│ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── variant_1: struct #69 -│ │ │ └── [not]: union '_string_filter' #68 -│ │ │ ├── variant_0: string #56 -│ │ │ ├── variant_1: struct #59 -│ │ │ │ └── [equals]: string #56 -│ │ │ ├── variant_2: struct #60 -│ │ │ │ └── [not]: string #56 -│ │ │ ├── variant_3: struct #61 -│ │ │ │ └── [in]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_4: struct #62 -│ │ │ │ └── [notIn]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_5: struct #65 -│ │ │ │ ├── [contains]: string #56 -│ │ │ │ └── [mode]: optional #64 -│ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ ├── variant_6: struct #66 -│ │ │ │ └── [search]: string #56 -│ │ │ └── variant_7: struct #67 -│ │ │ ├── [endsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [startsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── variant_1: list '_87_PostWhere[]' #87 -│ │ └── item: struct 'PostWhere' #86 -│ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ ├── [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ └── item: union #70 -│ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── variant_1: struct #69 -│ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [posts]: optional #83 -│ │ │ └── item: union #82 -│ │ │ ├── variant_0: struct #77 -│ │ │ │ └── [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ ├── variant_1: struct #79 -│ │ │ │ └── [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ └── variant_2: struct #81 -│ │ │ └── [none]: optional '_80_PostWhere?' #80 -│ │ │ └── item: &PostWhere #75 -│ │ ├── [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ └── item: union #53 -│ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── variant_1: struct #52 -│ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ ├── variant_0: integer #43 -│ │ │ ├── variant_1: struct #46 -│ │ │ │ └── [equals]: integer #43 -│ │ │ ├── variant_2: struct #47 -│ │ │ │ └── [not]: integer #43 -│ │ │ ├── variant_3: struct #48 -│ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── [lte]: optional #44 -│ │ │ │ └── item: integer #43 -│ │ │ ├── variant_4: struct #49 -│ │ │ │ └── [in]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── variant_5: struct #50 -│ │ │ └── [notIn]: list #45 -│ │ │ └── item: integer #43 -│ │ └── [title]: optional '_72__string_filter_c?' #72 -│ │ └── item: optional '_string_filter_c' #71 -│ │ └── item: union #70 -│ │ ├── variant_0: union '_string_filter' #68 -│ │ │ ├── variant_0: string #56 -│ │ │ ├── variant_1: struct #59 -│ │ │ │ └── [equals]: string #56 -│ │ │ ├── variant_2: struct #60 -│ │ │ │ └── [not]: string #56 -│ │ │ ├── variant_3: struct #61 -│ │ │ │ └── [in]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_4: struct #62 -│ │ │ │ └── [notIn]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_5: struct #65 -│ │ │ │ ├── [contains]: string #56 -│ │ │ │ └── [mode]: optional #64 -│ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ ├── variant_6: struct #66 -│ │ │ │ └── [search]: string #56 -│ │ │ └── variant_7: struct #67 -│ │ │ ├── [endsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [startsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── variant_1: struct #69 -│ │ └── [not]: union '_string_filter' #68 -│ │ ├── variant_0: string #56 -│ │ ├── variant_1: struct #59 -│ │ │ └── [equals]: string #56 -│ │ ├── variant_2: struct #60 -│ │ │ └── [not]: string #56 -│ │ ├── variant_3: struct #61 -│ │ │ └── [in]: list #58 -│ │ │ └── item: string #56 -│ │ ├── variant_4: struct #62 -│ │ │ └── [notIn]: list #58 -│ │ │ └── item: string #56 -│ │ ├── variant_5: struct #65 -│ │ │ ├── [contains]: string #56 -│ │ │ └── [mode]: optional #64 -│ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ ├── variant_6: struct #66 -│ │ │ └── [search]: string #56 -│ │ └── variant_7: struct #67 -│ │ ├── [endsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── [startsWith]: optional #57 -│ │ └── item: string #56 -│ ├── variant_3: struct #103 -│ │ └── [update]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #102 -│ │ ├── [id]: optional #98 -│ │ │ └── item: union #97 -│ │ │ ├── variant_0: integer #26 -│ │ │ ├── variant_1: struct #93 -│ │ │ │ └── [set]: integer #26 -│ │ │ ├── variant_2: struct #94 -│ │ │ │ └── [multiply]: integer #26 -│ │ │ ├── variant_3: struct #95 -│ │ │ │ └── [decrement]: integer #26 -│ │ │ └── variant_4: struct #96 -│ │ │ └── [increment]: integer #26 -│ │ └── [title]: optional #101 -│ │ └── item: union #100 -│ │ ├── variant_0: string #27 -│ │ └── variant_1: struct #99 -│ │ └── [set]: string #27 -│ ├── variant_4: struct #106 -│ │ └── [updateMany]: struct #105 -│ │ ├── [data]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #102 -│ │ │ ├── [id]: optional #98 -│ │ │ │ └── item: union #97 -│ │ │ │ ├── variant_0: integer #26 -│ │ │ │ ├── variant_1: struct #93 -│ │ │ │ │ └── [set]: integer #26 -│ │ │ │ ├── variant_2: struct #94 -│ │ │ │ │ └── [multiply]: integer #26 -│ │ │ │ ├── variant_3: struct #95 -│ │ │ │ │ └── [decrement]: integer #26 -│ │ │ │ └── variant_4: struct #96 -│ │ │ │ └── [increment]: integer #26 -│ │ │ └── [title]: optional #101 -│ │ │ └── item: union #100 -│ │ │ ├── variant_0: string #27 -│ │ │ └── variant_1: struct #99 -│ │ │ └── [set]: string #27 -│ │ └── [where]: optional #104 -│ │ └── item: union #88 -│ │ ├── variant_0: struct 'PostWhere' #86 -│ │ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ │ └── item: union #53 -│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_1: struct #52 -│ │ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ │ └── item: union #70 -│ │ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── variant_1: struct #69 -│ │ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [posts]: optional #83 -│ │ │ │ └── item: union #82 -│ │ │ │ ├── variant_0: struct #77 -│ │ │ │ │ └── [every]: optional '_76_PostWhere?' #76 -│ │ │ │ │ └── item: &PostWhere #75 -│ │ │ │ ├── variant_1: struct #79 -│ │ │ │ │ └── [some]: optional '_78_PostWhere?' #78 -│ │ │ │ │ └── item: &PostWhere #75 -│ │ │ │ └── variant_2: struct #81 -│ │ │ │ └── [none]: optional '_80_PostWhere?' #80 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ ├── [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── [title]: optional '_72__string_filter_c?' #72 -│ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ └── item: union #70 -│ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── variant_1: struct #69 -│ │ │ └── [not]: union '_string_filter' #68 -│ │ │ ├── variant_0: string #56 -│ │ │ ├── variant_1: struct #59 -│ │ │ │ └── [equals]: string #56 -│ │ │ ├── variant_2: struct #60 -│ │ │ │ └── [not]: string #56 -│ │ │ ├── variant_3: struct #61 -│ │ │ │ └── [in]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_4: struct #62 -│ │ │ │ └── [notIn]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_5: struct #65 -│ │ │ │ ├── [contains]: string #56 -│ │ │ │ └── [mode]: optional #64 -│ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ ├── variant_6: struct #66 -│ │ │ │ └── [search]: string #56 -│ │ │ └── variant_7: struct #67 -│ │ │ ├── [endsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [startsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── variant_1: list '_87_PostWhere[]' #87 -│ │ └── item: struct 'PostWhere' #86 -│ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ ├── [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ └── item: union #70 -│ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── variant_1: struct #69 -│ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [posts]: optional #83 -│ │ │ └── item: union #82 -│ │ │ ├── variant_0: struct #77 -│ │ │ │ └── [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ ├── variant_1: struct #79 -│ │ │ │ └── [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ └── variant_2: struct #81 -│ │ │ └── [none]: optional '_80_PostWhere?' #80 -│ │ │ └── item: &PostWhere #75 -│ │ ├── [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ └── item: union #53 -│ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── variant_1: struct #52 -│ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ ├── variant_0: integer #43 -│ │ │ ├── variant_1: struct #46 -│ │ │ │ └── [equals]: integer #43 -│ │ │ ├── variant_2: struct #47 -│ │ │ │ └── [not]: integer #43 -│ │ │ ├── variant_3: struct #48 -│ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── [lte]: optional #44 -│ │ │ │ └── item: integer #43 -│ │ │ ├── variant_4: struct #49 -│ │ │ │ └── [in]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── variant_5: struct #50 -│ │ │ └── [notIn]: list #45 -│ │ │ └── item: integer #43 -│ │ └── [title]: optional '_72__string_filter_c?' #72 -│ │ └── item: optional '_string_filter_c' #71 -│ │ └── item: union #70 -│ │ ├── variant_0: union '_string_filter' #68 -│ │ │ ├── variant_0: string #56 -│ │ │ ├── variant_1: struct #59 -│ │ │ │ └── [equals]: string #56 -│ │ │ ├── variant_2: struct #60 -│ │ │ │ └── [not]: string #56 -│ │ │ ├── variant_3: struct #61 -│ │ │ │ └── [in]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_4: struct #62 -│ │ │ │ └── [notIn]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_5: struct #65 -│ │ │ │ ├── [contains]: string #56 -│ │ │ │ └── [mode]: optional #64 -│ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ ├── variant_6: struct #66 -│ │ │ │ └── [search]: string #56 -│ │ │ └── variant_7: struct #67 -│ │ │ ├── [endsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [startsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── variant_1: struct #69 -│ │ └── [not]: union '_string_filter' #68 -│ │ ├── variant_0: string #56 -│ │ ├── variant_1: struct #59 -│ │ │ └── [equals]: string #56 -│ │ ├── variant_2: struct #60 -│ │ │ └── [not]: string #56 -│ │ ├── variant_3: struct #61 -│ │ │ └── [in]: list #58 -│ │ │ └── item: string #56 -│ │ ├── variant_4: struct #62 -│ │ │ └── [notIn]: list #58 -│ │ │ └── item: string #56 -│ │ ├── variant_5: struct #65 -│ │ │ ├── [contains]: string #56 -│ │ │ └── [mode]: optional #64 -│ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ ├── variant_6: struct #66 -│ │ │ └── [search]: string #56 -│ │ └── variant_7: struct #67 -│ │ ├── [endsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── [startsWith]: optional #57 -│ │ └── item: string #56 -│ ├── variant_5: struct #109 -│ │ └── [deleteMany]: struct #108 -│ │ └── [where]: optional #107 -│ │ └── item: union #88 -│ │ ├── variant_0: struct 'PostWhere' #86 -│ │ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ │ └── item: union #53 -│ │ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_1: struct #52 -│ │ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ │ └── item: union #70 -│ │ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── variant_1: struct #69 -│ │ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [posts]: optional #83 -│ │ │ │ └── item: union #82 -│ │ │ │ ├── variant_0: struct #77 -│ │ │ │ │ └── [every]: optional '_76_PostWhere?' #76 -│ │ │ │ │ └── item: &PostWhere #75 -│ │ │ │ ├── variant_1: struct #79 -│ │ │ │ │ └── [some]: optional '_78_PostWhere?' #78 -│ │ │ │ │ └── item: &PostWhere #75 -│ │ │ │ └── variant_2: struct #81 -│ │ │ │ └── [none]: optional '_80_PostWhere?' #80 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ ├── [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── [title]: optional '_72__string_filter_c?' #72 -│ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ └── item: union #70 -│ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── variant_1: struct #69 -│ │ │ └── [not]: union '_string_filter' #68 -│ │ │ ├── variant_0: string #56 -│ │ │ ├── variant_1: struct #59 -│ │ │ │ └── [equals]: string #56 -│ │ │ ├── variant_2: struct #60 -│ │ │ │ └── [not]: string #56 -│ │ │ ├── variant_3: struct #61 -│ │ │ │ └── [in]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_4: struct #62 -│ │ │ │ └── [notIn]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_5: struct #65 -│ │ │ │ ├── [contains]: string #56 -│ │ │ │ └── [mode]: optional #64 -│ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ ├── variant_6: struct #66 -│ │ │ │ └── [search]: string #56 -│ │ │ └── variant_7: struct #67 -│ │ │ ├── [endsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [startsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── variant_1: list '_87_PostWhere[]' #87 -│ │ └── item: struct 'PostWhere' #86 -│ │ ├── [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └── item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├── [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ │ └── item: union #53 -│ │ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├── variant_0: integer #43 -│ │ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ │ └── [not]: integer #43 -│ │ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── variant_5: struct #50 -│ │ │ │ │ └── [notIn]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_1: struct #52 -│ │ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ ├── [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └── item: optional '_string_filter_c' #71 -│ │ │ │ └── item: union #70 -│ │ │ │ ├── variant_0: union '_string_filter' #68 -│ │ │ │ │ ├── variant_0: string #56 -│ │ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ │ └── [equals]: string #56 -│ │ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ │ └── [not]: string #56 -│ │ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ │ └── [search]: string #56 -│ │ │ │ │ └── variant_7: struct #67 -│ │ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ │ └── item: string #56 -│ │ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── variant_1: struct #69 -│ │ │ │ └── [not]: union '_string_filter' #68 -│ │ │ │ ├── variant_0: string #56 -│ │ │ │ ├── variant_1: struct #59 -│ │ │ │ │ └── [equals]: string #56 -│ │ │ │ ├── variant_2: struct #60 -│ │ │ │ │ └── [not]: string #56 -│ │ │ │ ├── variant_3: struct #61 -│ │ │ │ │ └── [in]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_4: struct #62 -│ │ │ │ │ └── [notIn]: list #58 -│ │ │ │ │ └── item: string #56 -│ │ │ │ ├── variant_5: struct #65 -│ │ │ │ │ ├── [contains]: string #56 -│ │ │ │ │ └── [mode]: optional #64 -│ │ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├── variant_6: struct #66 -│ │ │ │ │ └── [search]: string #56 -│ │ │ │ └── variant_7: struct #67 -│ │ │ │ ├── [endsWith]: optional #57 -│ │ │ │ │ └── item: string #56 -│ │ │ │ └── [startsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [posts]: optional #83 -│ │ │ └── item: union #82 -│ │ │ ├── variant_0: struct #77 -│ │ │ │ └── [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ ├── variant_1: struct #79 -│ │ │ │ └── [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └── item: &PostWhere #75 -│ │ │ └── variant_2: struct #81 -│ │ │ └── [none]: optional '_80_PostWhere?' #80 -│ │ │ └── item: &PostWhere #75 -│ │ ├── [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └── item: optional '_integer_filter_c' #54 -│ │ │ └── item: union #53 -│ │ │ ├── variant_0: either '_integer_filter' #51 -│ │ │ │ ├── variant_0: integer #43 -│ │ │ │ ├── variant_1: struct #46 -│ │ │ │ │ └── [equals]: integer #43 -│ │ │ │ ├── variant_2: struct #47 -│ │ │ │ │ └── [not]: integer #43 -│ │ │ │ ├── variant_3: struct #48 -│ │ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ │ └── item: integer #43 -│ │ │ │ │ └── [lte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── variant_4: struct #49 -│ │ │ │ │ └── [in]: list #45 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── variant_5: struct #50 -│ │ │ │ └── [notIn]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── variant_1: struct #52 -│ │ │ └── [not]: either '_integer_filter' #51 -│ │ │ ├── variant_0: integer #43 -│ │ │ ├── variant_1: struct #46 -│ │ │ │ └── [equals]: integer #43 -│ │ │ ├── variant_2: struct #47 -│ │ │ │ └── [not]: integer #43 -│ │ │ ├── variant_3: struct #48 -│ │ │ │ ├── [gt]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [gte]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ ├── [lt]: optional #44 -│ │ │ │ │ └── item: integer #43 -│ │ │ │ └── [lte]: optional #44 -│ │ │ │ └── item: integer #43 -│ │ │ ├── variant_4: struct #49 -│ │ │ │ └── [in]: list #45 -│ │ │ │ └── item: integer #43 -│ │ │ └── variant_5: struct #50 -│ │ │ └── [notIn]: list #45 -│ │ │ └── item: integer #43 -│ │ └── [title]: optional '_72__string_filter_c?' #72 -│ │ └── item: optional '_string_filter_c' #71 -│ │ └── item: union #70 -│ │ ├── variant_0: union '_string_filter' #68 -│ │ │ ├── variant_0: string #56 -│ │ │ ├── variant_1: struct #59 -│ │ │ │ └── [equals]: string #56 -│ │ │ ├── variant_2: struct #60 -│ │ │ │ └── [not]: string #56 -│ │ │ ├── variant_3: struct #61 -│ │ │ │ └── [in]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_4: struct #62 -│ │ │ │ └── [notIn]: list #58 -│ │ │ │ └── item: string #56 -│ │ │ ├── variant_5: struct #65 -│ │ │ │ ├── [contains]: string #56 -│ │ │ │ └── [mode]: optional #64 -│ │ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ │ ├── variant_6: struct #66 -│ │ │ │ └── [search]: string #56 -│ │ │ └── variant_7: struct #67 -│ │ │ ├── [endsWith]: optional #57 -│ │ │ │ └── item: string #56 -│ │ │ └── [startsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── variant_1: struct #69 -│ │ └── [not]: union '_string_filter' #68 -│ │ ├── variant_0: string #56 -│ │ ├── variant_1: struct #59 -│ │ │ └── [equals]: string #56 -│ │ ├── variant_2: struct #60 -│ │ │ └── [not]: string #56 -│ │ ├── variant_3: struct #61 -│ │ │ └── [in]: list #58 -│ │ │ └── item: string #56 -│ │ ├── variant_4: struct #62 -│ │ │ └── [notIn]: list #58 -│ │ │ └── item: string #56 -│ │ ├── variant_5: struct #65 -│ │ │ ├── [contains]: string #56 -│ │ │ └── [mode]: optional #64 -│ │ │ └── item: string #63 enum{ '"insensitive"' } -│ │ ├── variant_6: struct #66 -│ │ │ └── [search]: string #56 -│ │ └── variant_7: struct #67 -│ │ ├── [endsWith]: optional #57 -│ │ │ └── item: string #56 -│ │ └── [startsWith]: optional #57 -│ │ └── item: string #56 -│ └── variant_6: struct #113 -│ └── [createMany]: optional #112 -│ └── item: struct #111 -│ └── [data]: list #110 -│ └── item: union #42 -│ ├── variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ ├── [id]: optional #39 -│ │ │ └── item: integer #26 -│ │ └── [title]: string #27 -│ └── variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 -│ └── item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ ├── [id]: optional #39 -│ │ └── item: integer #26 -│ └── [title]: string #27 -└── [where]: struct 'QueryUniqueUserWhereInput' #118 - └── [id]: optional #117 - └── item: integer #21 +├─ [data]: struct '_User_UpdateInput' #116 +│ ├─ [id]: optional #35 +│ │ └─ item: union #34 +│ │ ├─ variant_0: integer #21 +│ │ ├─ variant_1: struct #30 +│ │ │ └─ [set]: integer #21 +│ │ ├─ variant_2: struct #31 +│ │ │ └─ [multiply]: integer #21 +│ │ ├─ variant_3: struct #32 +│ │ │ └─ [decrement]: integer #21 +│ │ └─ variant_4: struct #33 +│ │ └─ [increment]: integer #21 +│ ├─ [name]: optional #38 +│ │ └─ item: union #37 +│ │ ├─ variant_0: string #22 +│ │ └─ variant_1: struct #36 +│ │ └─ [set]: string #22 +│ └─ [posts]: optional #115 +│ └─ item: union #114 +│ ├─ variant_0: struct #90 +│ │ └─ [create]: union #42 +│ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ │ │ ├─ [id]: optional #39 +│ │ │ │ └─ item: integer #26 +│ │ │ └─ [title]: string #27 +│ │ └─ variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 +│ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ │ ├─ [id]: optional #39 +│ │ │ └─ item: integer #26 +│ │ └─ [title]: string #27 +│ ├─ variant_1: struct #91 +│ │ └─ [connect]: union #88 +│ │ ├─ variant_0: struct 'PostWhere' #86 +│ │ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ │ └─ item: union #53 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_1: struct #52 +│ │ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ │ └─ item: union #70 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ variant_1: struct #69 +│ │ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [posts]: optional #83 +│ │ │ │ └─ item: union #82 +│ │ │ │ ├─ variant_0: struct #77 +│ │ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 +│ │ │ │ │ └─ item: &PostWhere #75 +│ │ │ │ ├─ variant_1: struct #79 +│ │ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 +│ │ │ │ │ └─ item: &PostWhere #75 +│ │ │ │ └─ variant_2: struct #81 +│ │ │ │ └─ [none]: optional '_80_PostWhere?' #80 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ [title]: optional '_72__string_filter_c?' #72 +│ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ └─ item: union #70 +│ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ variant_1: struct #69 +│ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ ├─ variant_0: string #56 +│ │ │ ├─ variant_1: struct #59 +│ │ │ │ └─ [equals]: string #56 +│ │ │ ├─ variant_2: struct #60 +│ │ │ │ └─ [not]: string #56 +│ │ │ ├─ variant_3: struct #61 +│ │ │ │ └─ [in]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_4: struct #62 +│ │ │ │ └─ [notIn]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_5: struct #65 +│ │ │ │ ├─ [contains]: string #56 +│ │ │ │ └─ [mode]: optional #64 +│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #66 +│ │ │ │ └─ [search]: string #56 +│ │ │ └─ variant_7: struct #67 +│ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [startsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ variant_1: list '_87_PostWhere[]' #87 +│ │ └─ item: struct 'PostWhere' #86 +│ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ └─ item: union #70 +│ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ variant_1: struct #69 +│ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [posts]: optional #83 +│ │ │ └─ item: union #82 +│ │ │ ├─ variant_0: struct #77 +│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ ├─ variant_1: struct #79 +│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ └─ variant_2: struct #81 +│ │ │ └─ [none]: optional '_80_PostWhere?' #80 +│ │ │ └─ item: &PostWhere #75 +│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 +│ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ └─ item: union #53 +│ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ variant_1: struct #52 +│ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ ├─ variant_0: integer #43 +│ │ │ ├─ variant_1: struct #46 +│ │ │ │ └─ [equals]: integer #43 +│ │ │ ├─ variant_2: struct #47 +│ │ │ │ └─ [not]: integer #43 +│ │ │ ├─ variant_3: struct #48 +│ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ [lte]: optional #44 +│ │ │ │ └─ item: integer #43 +│ │ │ ├─ variant_4: struct #49 +│ │ │ │ └─ [in]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ variant_5: struct #50 +│ │ │ └─ [notIn]: list #45 +│ │ │ └─ item: integer #43 +│ │ └─ [title]: optional '_72__string_filter_c?' #72 +│ │ └─ item: optional '_string_filter_c' #71 +│ │ └─ item: union #70 +│ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ ├─ variant_0: string #56 +│ │ │ ├─ variant_1: struct #59 +│ │ │ │ └─ [equals]: string #56 +│ │ │ ├─ variant_2: struct #60 +│ │ │ │ └─ [not]: string #56 +│ │ │ ├─ variant_3: struct #61 +│ │ │ │ └─ [in]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_4: struct #62 +│ │ │ │ └─ [notIn]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_5: struct #65 +│ │ │ │ ├─ [contains]: string #56 +│ │ │ │ └─ [mode]: optional #64 +│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #66 +│ │ │ │ └─ [search]: string #56 +│ │ │ └─ variant_7: struct #67 +│ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [startsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ variant_1: struct #69 +│ │ └─ [not]: union '_string_filter' #68 +│ │ ├─ variant_0: string #56 +│ │ ├─ variant_1: struct #59 +│ │ │ └─ [equals]: string #56 +│ │ ├─ variant_2: struct #60 +│ │ │ └─ [not]: string #56 +│ │ ├─ variant_3: struct #61 +│ │ │ └─ [in]: list #58 +│ │ │ └─ item: string #56 +│ │ ├─ variant_4: struct #62 +│ │ │ └─ [notIn]: list #58 +│ │ │ └─ item: string #56 +│ │ ├─ variant_5: struct #65 +│ │ │ ├─ [contains]: string #56 +│ │ │ └─ [mode]: optional #64 +│ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #66 +│ │ │ └─ [search]: string #56 +│ │ └─ variant_7: struct #67 +│ │ ├─ [endsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ [startsWith]: optional #57 +│ │ └─ item: string #56 +│ ├─ variant_2: struct #92 +│ │ └─ [connectOrCreate]: struct #89 +│ │ ├─ [create]: union #42 +│ │ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ │ │ │ ├─ [id]: optional #39 +│ │ │ │ │ └─ item: integer #26 +│ │ │ │ └─ [title]: string #27 +│ │ │ └─ variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 +│ │ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ │ │ ├─ [id]: optional #39 +│ │ │ │ └─ item: integer #26 +│ │ │ └─ [title]: string #27 +│ │ └─ [where]: union #88 +│ │ ├─ variant_0: struct 'PostWhere' #86 +│ │ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ │ └─ item: union #53 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_1: struct #52 +│ │ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ │ └─ item: union #70 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ variant_1: struct #69 +│ │ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [posts]: optional #83 +│ │ │ │ └─ item: union #82 +│ │ │ │ ├─ variant_0: struct #77 +│ │ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 +│ │ │ │ │ └─ item: &PostWhere #75 +│ │ │ │ ├─ variant_1: struct #79 +│ │ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 +│ │ │ │ │ └─ item: &PostWhere #75 +│ │ │ │ └─ variant_2: struct #81 +│ │ │ │ └─ [none]: optional '_80_PostWhere?' #80 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ [title]: optional '_72__string_filter_c?' #72 +│ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ └─ item: union #70 +│ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ variant_1: struct #69 +│ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ ├─ variant_0: string #56 +│ │ │ ├─ variant_1: struct #59 +│ │ │ │ └─ [equals]: string #56 +│ │ │ ├─ variant_2: struct #60 +│ │ │ │ └─ [not]: string #56 +│ │ │ ├─ variant_3: struct #61 +│ │ │ │ └─ [in]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_4: struct #62 +│ │ │ │ └─ [notIn]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_5: struct #65 +│ │ │ │ ├─ [contains]: string #56 +│ │ │ │ └─ [mode]: optional #64 +│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #66 +│ │ │ │ └─ [search]: string #56 +│ │ │ └─ variant_7: struct #67 +│ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [startsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ variant_1: list '_87_PostWhere[]' #87 +│ │ └─ item: struct 'PostWhere' #86 +│ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ └─ item: union #70 +│ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ variant_1: struct #69 +│ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [posts]: optional #83 +│ │ │ └─ item: union #82 +│ │ │ ├─ variant_0: struct #77 +│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ ├─ variant_1: struct #79 +│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ └─ variant_2: struct #81 +│ │ │ └─ [none]: optional '_80_PostWhere?' #80 +│ │ │ └─ item: &PostWhere #75 +│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 +│ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ └─ item: union #53 +│ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ variant_1: struct #52 +│ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ ├─ variant_0: integer #43 +│ │ │ ├─ variant_1: struct #46 +│ │ │ │ └─ [equals]: integer #43 +│ │ │ ├─ variant_2: struct #47 +│ │ │ │ └─ [not]: integer #43 +│ │ │ ├─ variant_3: struct #48 +│ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ [lte]: optional #44 +│ │ │ │ └─ item: integer #43 +│ │ │ ├─ variant_4: struct #49 +│ │ │ │ └─ [in]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ variant_5: struct #50 +│ │ │ └─ [notIn]: list #45 +│ │ │ └─ item: integer #43 +│ │ └─ [title]: optional '_72__string_filter_c?' #72 +│ │ └─ item: optional '_string_filter_c' #71 +│ │ └─ item: union #70 +│ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ ├─ variant_0: string #56 +│ │ │ ├─ variant_1: struct #59 +│ │ │ │ └─ [equals]: string #56 +│ │ │ ├─ variant_2: struct #60 +│ │ │ │ └─ [not]: string #56 +│ │ │ ├─ variant_3: struct #61 +│ │ │ │ └─ [in]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_4: struct #62 +│ │ │ │ └─ [notIn]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_5: struct #65 +│ │ │ │ ├─ [contains]: string #56 +│ │ │ │ └─ [mode]: optional #64 +│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #66 +│ │ │ │ └─ [search]: string #56 +│ │ │ └─ variant_7: struct #67 +│ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [startsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ variant_1: struct #69 +│ │ └─ [not]: union '_string_filter' #68 +│ │ ├─ variant_0: string #56 +│ │ ├─ variant_1: struct #59 +│ │ │ └─ [equals]: string #56 +│ │ ├─ variant_2: struct #60 +│ │ │ └─ [not]: string #56 +│ │ ├─ variant_3: struct #61 +│ │ │ └─ [in]: list #58 +│ │ │ └─ item: string #56 +│ │ ├─ variant_4: struct #62 +│ │ │ └─ [notIn]: list #58 +│ │ │ └─ item: string #56 +│ │ ├─ variant_5: struct #65 +│ │ │ ├─ [contains]: string #56 +│ │ │ └─ [mode]: optional #64 +│ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #66 +│ │ │ └─ [search]: string #56 +│ │ └─ variant_7: struct #67 +│ │ ├─ [endsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ [startsWith]: optional #57 +│ │ └─ item: string #56 +│ ├─ variant_3: struct #103 +│ │ └─ [update]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #102 +│ │ ├─ [id]: optional #98 +│ │ │ └─ item: union #97 +│ │ │ ├─ variant_0: integer #26 +│ │ │ ├─ variant_1: struct #93 +│ │ │ │ └─ [set]: integer #26 +│ │ │ ├─ variant_2: struct #94 +│ │ │ │ └─ [multiply]: integer #26 +│ │ │ ├─ variant_3: struct #95 +│ │ │ │ └─ [decrement]: integer #26 +│ │ │ └─ variant_4: struct #96 +│ │ │ └─ [increment]: integer #26 +│ │ └─ [title]: optional #101 +│ │ └─ item: union #100 +│ │ ├─ variant_0: string #27 +│ │ └─ variant_1: struct #99 +│ │ └─ [set]: string #27 +│ ├─ variant_4: struct #106 +│ │ └─ [updateMany]: struct #105 +│ │ ├─ [data]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #102 +│ │ │ ├─ [id]: optional #98 +│ │ │ │ └─ item: union #97 +│ │ │ │ ├─ variant_0: integer #26 +│ │ │ │ ├─ variant_1: struct #93 +│ │ │ │ │ └─ [set]: integer #26 +│ │ │ │ ├─ variant_2: struct #94 +│ │ │ │ │ └─ [multiply]: integer #26 +│ │ │ │ ├─ variant_3: struct #95 +│ │ │ │ │ └─ [decrement]: integer #26 +│ │ │ │ └─ variant_4: struct #96 +│ │ │ │ └─ [increment]: integer #26 +│ │ │ └─ [title]: optional #101 +│ │ │ └─ item: union #100 +│ │ │ ├─ variant_0: string #27 +│ │ │ └─ variant_1: struct #99 +│ │ │ └─ [set]: string #27 +│ │ └─ [where]: optional #104 +│ │ └─ item: union #88 +│ │ ├─ variant_0: struct 'PostWhere' #86 +│ │ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ │ └─ item: union #53 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_1: struct #52 +│ │ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ │ └─ item: union #70 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ variant_1: struct #69 +│ │ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [posts]: optional #83 +│ │ │ │ └─ item: union #82 +│ │ │ │ ├─ variant_0: struct #77 +│ │ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 +│ │ │ │ │ └─ item: &PostWhere #75 +│ │ │ │ ├─ variant_1: struct #79 +│ │ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 +│ │ │ │ │ └─ item: &PostWhere #75 +│ │ │ │ └─ variant_2: struct #81 +│ │ │ │ └─ [none]: optional '_80_PostWhere?' #80 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ [title]: optional '_72__string_filter_c?' #72 +│ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ └─ item: union #70 +│ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ variant_1: struct #69 +│ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ ├─ variant_0: string #56 +│ │ │ ├─ variant_1: struct #59 +│ │ │ │ └─ [equals]: string #56 +│ │ │ ├─ variant_2: struct #60 +│ │ │ │ └─ [not]: string #56 +│ │ │ ├─ variant_3: struct #61 +│ │ │ │ └─ [in]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_4: struct #62 +│ │ │ │ └─ [notIn]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_5: struct #65 +│ │ │ │ ├─ [contains]: string #56 +│ │ │ │ └─ [mode]: optional #64 +│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #66 +│ │ │ │ └─ [search]: string #56 +│ │ │ └─ variant_7: struct #67 +│ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [startsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ variant_1: list '_87_PostWhere[]' #87 +│ │ └─ item: struct 'PostWhere' #86 +│ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ └─ item: union #70 +│ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ variant_1: struct #69 +│ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [posts]: optional #83 +│ │ │ └─ item: union #82 +│ │ │ ├─ variant_0: struct #77 +│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ ├─ variant_1: struct #79 +│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ └─ variant_2: struct #81 +│ │ │ └─ [none]: optional '_80_PostWhere?' #80 +│ │ │ └─ item: &PostWhere #75 +│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 +│ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ └─ item: union #53 +│ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ variant_1: struct #52 +│ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ ├─ variant_0: integer #43 +│ │ │ ├─ variant_1: struct #46 +│ │ │ │ └─ [equals]: integer #43 +│ │ │ ├─ variant_2: struct #47 +│ │ │ │ └─ [not]: integer #43 +│ │ │ ├─ variant_3: struct #48 +│ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ [lte]: optional #44 +│ │ │ │ └─ item: integer #43 +│ │ │ ├─ variant_4: struct #49 +│ │ │ │ └─ [in]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ variant_5: struct #50 +│ │ │ └─ [notIn]: list #45 +│ │ │ └─ item: integer #43 +│ │ └─ [title]: optional '_72__string_filter_c?' #72 +│ │ └─ item: optional '_string_filter_c' #71 +│ │ └─ item: union #70 +│ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ ├─ variant_0: string #56 +│ │ │ ├─ variant_1: struct #59 +│ │ │ │ └─ [equals]: string #56 +│ │ │ ├─ variant_2: struct #60 +│ │ │ │ └─ [not]: string #56 +│ │ │ ├─ variant_3: struct #61 +│ │ │ │ └─ [in]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_4: struct #62 +│ │ │ │ └─ [notIn]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_5: struct #65 +│ │ │ │ ├─ [contains]: string #56 +│ │ │ │ └─ [mode]: optional #64 +│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #66 +│ │ │ │ └─ [search]: string #56 +│ │ │ └─ variant_7: struct #67 +│ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [startsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ variant_1: struct #69 +│ │ └─ [not]: union '_string_filter' #68 +│ │ ├─ variant_0: string #56 +│ │ ├─ variant_1: struct #59 +│ │ │ └─ [equals]: string #56 +│ │ ├─ variant_2: struct #60 +│ │ │ └─ [not]: string #56 +│ │ ├─ variant_3: struct #61 +│ │ │ └─ [in]: list #58 +│ │ │ └─ item: string #56 +│ │ ├─ variant_4: struct #62 +│ │ │ └─ [notIn]: list #58 +│ │ │ └─ item: string #56 +│ │ ├─ variant_5: struct #65 +│ │ │ ├─ [contains]: string #56 +│ │ │ └─ [mode]: optional #64 +│ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #66 +│ │ │ └─ [search]: string #56 +│ │ └─ variant_7: struct #67 +│ │ ├─ [endsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ [startsWith]: optional #57 +│ │ └─ item: string #56 +│ ├─ variant_5: struct #109 +│ │ └─ [deleteMany]: struct #108 +│ │ └─ [where]: optional #107 +│ │ └─ item: union #88 +│ │ ├─ variant_0: struct 'PostWhere' #86 +│ │ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ │ └─ item: union #53 +│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_1: struct #52 +│ │ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ │ └─ item: union #70 +│ │ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ variant_1: struct #69 +│ │ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [posts]: optional #83 +│ │ │ │ └─ item: union #82 +│ │ │ │ ├─ variant_0: struct #77 +│ │ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 +│ │ │ │ │ └─ item: &PostWhere #75 +│ │ │ │ ├─ variant_1: struct #79 +│ │ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 +│ │ │ │ │ └─ item: &PostWhere #75 +│ │ │ │ └─ variant_2: struct #81 +│ │ │ │ └─ [none]: optional '_80_PostWhere?' #80 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ [title]: optional '_72__string_filter_c?' #72 +│ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ └─ item: union #70 +│ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ variant_1: struct #69 +│ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ ├─ variant_0: string #56 +│ │ │ ├─ variant_1: struct #59 +│ │ │ │ └─ [equals]: string #56 +│ │ │ ├─ variant_2: struct #60 +│ │ │ │ └─ [not]: string #56 +│ │ │ ├─ variant_3: struct #61 +│ │ │ │ └─ [in]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_4: struct #62 +│ │ │ │ └─ [notIn]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_5: struct #65 +│ │ │ │ ├─ [contains]: string #56 +│ │ │ │ └─ [mode]: optional #64 +│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #66 +│ │ │ │ └─ [search]: string #56 +│ │ │ └─ variant_7: struct #67 +│ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [startsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ variant_1: list '_87_PostWhere[]' #87 +│ │ └─ item: struct 'PostWhere' #86 +│ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 +│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 +│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 +│ │ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ │ └─ item: union #53 +│ │ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ variant_5: struct #50 +│ │ │ │ │ └─ [notIn]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_1: struct #52 +│ │ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 +│ │ │ │ └─ item: optional '_string_filter_c' #71 +│ │ │ │ └─ item: union #70 +│ │ │ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ │ │ ├─ variant_0: string #56 +│ │ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ │ └─ [not]: string #56 +│ │ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ │ └─ [search]: string #56 +│ │ │ │ │ └─ variant_7: struct #67 +│ │ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ │ └─ item: string #56 +│ │ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ variant_1: struct #69 +│ │ │ │ └─ [not]: union '_string_filter' #68 +│ │ │ │ ├─ variant_0: string #56 +│ │ │ │ ├─ variant_1: struct #59 +│ │ │ │ │ └─ [equals]: string #56 +│ │ │ │ ├─ variant_2: struct #60 +│ │ │ │ │ └─ [not]: string #56 +│ │ │ │ ├─ variant_3: struct #61 +│ │ │ │ │ └─ [in]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_4: struct #62 +│ │ │ │ │ └─ [notIn]: list #58 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ ├─ variant_5: struct #65 +│ │ │ │ │ ├─ [contains]: string #56 +│ │ │ │ │ └─ [mode]: optional #64 +│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ │ ├─ variant_6: struct #66 +│ │ │ │ │ └─ [search]: string #56 +│ │ │ │ └─ variant_7: struct #67 +│ │ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ │ └─ item: string #56 +│ │ │ │ └─ [startsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [posts]: optional #83 +│ │ │ └─ item: union #82 +│ │ │ ├─ variant_0: struct #77 +│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ ├─ variant_1: struct #79 +│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 +│ │ │ │ └─ item: &PostWhere #75 +│ │ │ └─ variant_2: struct #81 +│ │ │ └─ [none]: optional '_80_PostWhere?' #80 +│ │ │ └─ item: &PostWhere #75 +│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 +│ │ │ └─ item: optional '_integer_filter_c' #54 +│ │ │ └─ item: union #53 +│ │ │ ├─ variant_0: either '_integer_filter' #51 +│ │ │ │ ├─ variant_0: integer #43 +│ │ │ │ ├─ variant_1: struct #46 +│ │ │ │ │ └─ [equals]: integer #43 +│ │ │ │ ├─ variant_2: struct #47 +│ │ │ │ │ └─ [not]: integer #43 +│ │ │ │ ├─ variant_3: struct #48 +│ │ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ │ └─ item: integer #43 +│ │ │ │ │ └─ [lte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ variant_4: struct #49 +│ │ │ │ │ └─ [in]: list #45 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ variant_5: struct #50 +│ │ │ │ └─ [notIn]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ variant_1: struct #52 +│ │ │ └─ [not]: either '_integer_filter' #51 +│ │ │ ├─ variant_0: integer #43 +│ │ │ ├─ variant_1: struct #46 +│ │ │ │ └─ [equals]: integer #43 +│ │ │ ├─ variant_2: struct #47 +│ │ │ │ └─ [not]: integer #43 +│ │ │ ├─ variant_3: struct #48 +│ │ │ │ ├─ [gt]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [gte]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ ├─ [lt]: optional #44 +│ │ │ │ │ └─ item: integer #43 +│ │ │ │ └─ [lte]: optional #44 +│ │ │ │ └─ item: integer #43 +│ │ │ ├─ variant_4: struct #49 +│ │ │ │ └─ [in]: list #45 +│ │ │ │ └─ item: integer #43 +│ │ │ └─ variant_5: struct #50 +│ │ │ └─ [notIn]: list #45 +│ │ │ └─ item: integer #43 +│ │ └─ [title]: optional '_72__string_filter_c?' #72 +│ │ └─ item: optional '_string_filter_c' #71 +│ │ └─ item: union #70 +│ │ ├─ variant_0: union '_string_filter' #68 +│ │ │ ├─ variant_0: string #56 +│ │ │ ├─ variant_1: struct #59 +│ │ │ │ └─ [equals]: string #56 +│ │ │ ├─ variant_2: struct #60 +│ │ │ │ └─ [not]: string #56 +│ │ │ ├─ variant_3: struct #61 +│ │ │ │ └─ [in]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_4: struct #62 +│ │ │ │ └─ [notIn]: list #58 +│ │ │ │ └─ item: string #56 +│ │ │ ├─ variant_5: struct #65 +│ │ │ │ ├─ [contains]: string #56 +│ │ │ │ └─ [mode]: optional #64 +│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ │ ├─ variant_6: struct #66 +│ │ │ │ └─ [search]: string #56 +│ │ │ └─ variant_7: struct #67 +│ │ │ ├─ [endsWith]: optional #57 +│ │ │ │ └─ item: string #56 +│ │ │ └─ [startsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ variant_1: struct #69 +│ │ └─ [not]: union '_string_filter' #68 +│ │ ├─ variant_0: string #56 +│ │ ├─ variant_1: struct #59 +│ │ │ └─ [equals]: string #56 +│ │ ├─ variant_2: struct #60 +│ │ │ └─ [not]: string #56 +│ │ ├─ variant_3: struct #61 +│ │ │ └─ [in]: list #58 +│ │ │ └─ item: string #56 +│ │ ├─ variant_4: struct #62 +│ │ │ └─ [notIn]: list #58 +│ │ │ └─ item: string #56 +│ │ ├─ variant_5: struct #65 +│ │ │ ├─ [contains]: string #56 +│ │ │ └─ [mode]: optional #64 +│ │ │ └─ item: string #63 enum{ '"insensitive"' } +│ │ ├─ variant_6: struct #66 +│ │ │ └─ [search]: string #56 +│ │ └─ variant_7: struct #67 +│ │ ├─ [endsWith]: optional #57 +│ │ │ └─ item: string #56 +│ │ └─ [startsWith]: optional #57 +│ │ └─ item: string #56 +│ └─ variant_6: struct #113 +│ └─ [createMany]: optional #112 +│ └─ item: struct #111 +│ └─ [data]: list #110 +│ └─ item: union #42 +│ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ │ ├─ [id]: optional #39 +│ │ │ └─ item: integer #26 +│ │ └─ [title]: string #27 +│ └─ variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 +│ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 +│ ├─ [id]: optional #39 +│ │ └─ item: integer #26 +│ └─ [title]: string #27 +└─ [where]: struct 'QueryUniqueUserWhereInput' #118 + └─ [id]: optional #117 + └─ item: integer #21 From 85df23a053fadf38e5fb10421a8a210f8e802ae0 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Sun, 18 Feb 2024 01:10:00 +0300 Subject: [PATCH 29/32] fix tests --- libs/common/src/typegraph/validator/types.rs | 9 +- .../__snapshots__/introspection_test.ts.snap | 6 +- .../__snapshots__/union_either_test.ts.snap | 18 ++-- .../tests/introspection/introspection_test.ts | 2 +- .../__snapshots__/planner_test.ts.snap | 88 +++++++++---------- typegate/tests/planner/planner.py | 26 +++--- typegraph/core/src/types/subgraph/map.rs | 5 +- typegraph/core/src/utils/mod.rs | 8 +- typegraph/core/wit/typegraph.wit | 1 + typegraph/node/sdk/src/host/host.ts | 4 + typegraph/python/typegraph/host/host.py | 4 + 11 files changed, 89 insertions(+), 82 deletions(-) diff --git a/libs/common/src/typegraph/validator/types.rs b/libs/common/src/typegraph/validator/types.rs index 80b35dbcb..a6e5b818f 100644 --- a/libs/common/src/typegraph/validator/types.rs +++ b/libs/common/src/typegraph/validator/types.rs @@ -251,11 +251,11 @@ impl<'a> EnsureSubtypeOf for GenericUnionVariants<'a> { // 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 error_collector = ErrorCollector::default(); 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; @@ -337,8 +337,11 @@ impl<'a> EnsureSubtypeOf for ExtendedTypeNode<'a> { }; sub.ensure_subtype_of(sup, tg, errors); } - (TypeNode::Function { .. }, _) | (_, TypeNode::Function { .. }) => { - errors.push("Function types are not supported"); + (_, 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 {}", diff --git a/typegate/tests/introspection/__snapshots__/introspection_test.ts.snap b/typegate/tests/introspection/__snapshots__/introspection_test.ts.snap index b3cdfced8..c6a093da1 100644 --- a/typegate/tests/introspection/__snapshots__/introspection_test.ts.snap +++ b/typegate/tests/introspection/__snapshots__/introspection_test.ts.snap @@ -53,7 +53,7 @@ Policies: name: null, ofType: { kind: "OBJECT", - name: "object_8", + name: "inp", ofType: null, }, }, @@ -100,7 +100,7 @@ Policies: possibleTypes: null, }, { - description: "object_8 type", + description: "inp type", enumValues: null, fields: [ { @@ -126,7 +126,7 @@ Policies: inputFields: null, interfaces: [], kind: "OBJECT", - name: "object_8", + name: "inp", possibleTypes: null, }, { diff --git a/typegate/tests/introspection/__snapshots__/union_either_test.ts.snap b/typegate/tests/introspection/__snapshots__/union_either_test.ts.snap index d3fb3d52c..00bb8a91a 100644 --- a/typegate/tests/introspection/__snapshots__/union_either_test.ts.snap +++ b/typegate/tests/introspection/__snapshots__/union_either_test.ts.snap @@ -56,25 +56,25 @@ snapshot[`Basic introspection 1`] = ` }, ], kind: "OBJECT", - name: "object_19", + name: "User", possibleTypes: null, }, { fields: null, kind: "UNION", - name: "either_18Out", + name: "FavoriteToyOut", possibleTypes: [ { kind: "OBJECT", - name: "object_14", + name: "Rubix", }, { kind: "OBJECT", - name: "object_15", + name: "Toygun", }, { kind: "OBJECT", - name: "object_17", + name: "Gunpla", }, ], }, @@ -88,7 +88,7 @@ snapshot[`Basic introspection 1`] = ` }, ], kind: "OBJECT", - name: "object_14", + name: "Rubix", possibleTypes: null, }, { @@ -98,7 +98,7 @@ snapshot[`Basic introspection 1`] = ` }, ], kind: "OBJECT", - name: "object_15", + name: "Toygun", possibleTypes: null, }, { @@ -111,13 +111,13 @@ snapshot[`Basic introspection 1`] = ` }, ], kind: "OBJECT", - name: "object_17", + name: "Gunpla", possibleTypes: null, }, { fields: null, kind: "UNION", - name: "union_16Out", + name: "union_8Out", possibleTypes: [ { kind: "OBJECT", diff --git a/typegate/tests/introspection/introspection_test.ts b/typegate/tests/introspection/introspection_test.ts index 627900e71..c039c5955 100644 --- a/typegate/tests/introspection/introspection_test.ts +++ b/typegate/tests/introspection/introspection_test.ts @@ -28,7 +28,7 @@ Meta.test("Basic introspection", async (t) => { "name": "Query", }, { - name: "object_8", + name: "inp", }, { "name": "NestedInp", 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/typegraph/core/src/types/subgraph/map.rs b/typegraph/core/src/types/subgraph/map.rs index e9727d733..2889aa027 100644 --- a/typegraph/core/src/types/subgraph/map.rs +++ b/typegraph/core/src/types/subgraph/map.rs @@ -42,10 +42,11 @@ where let alias = Store::generate_alias(); ctx.result_aliases.insert(type_id, alias.clone()); - let type_id = (self.mapper)(type_id)?; + let new_type_id = (self.mapper)(type_id)?; - let res = self.map_children(type_id, ctx)?; + let res = self.map_children(new_type_id, ctx)?; Store::register_alias(alias, res)?; + ctx.result_aliases.remove(&type_id); Ok(res) } diff --git a/typegraph/core/src/utils/mod.rs b/typegraph/core/src/utils/mod.rs index 2a2acf8aa..07f92038e 100644 --- a/typegraph/core/src/utils/mod.rs +++ b/typegraph/core/src/utils/mod.rs @@ -258,14 +258,12 @@ impl crate::wit::utils::Guest for crate::Lib { } fn remove_injections(id: CoreTypeId) -> Result { - remove_injections_recursively(id.into()).map(|id| id.into()) + Subgraph::new(id.into()) + .map(remove_injection) + .map(|id| id.into()) } } -fn remove_injections_recursively(id: TypeId) -> Result { - Subgraph::new(id).map(remove_injection) -} - pub fn remove_injection(type_id: TypeId) -> Result { let (_, type_def) = type_id.resolve_ref()?; diff --git a/typegraph/core/wit/typegraph.wit b/typegraph/core/wit/typegraph.wit index 049e27c02..1ffc09901 100644 --- a/typegraph/core/wit/typegraph.wit +++ b/typegraph/core/wit/typegraph.wit @@ -552,6 +552,7 @@ interface utils { 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/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 = [] From 32ccc87734c279dd38c83f15d319036c3844a226 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Mon, 19 Feb 2024 11:59:21 +0300 Subject: [PATCH 30/32] fix merge confusions --- ...eneration__test__find_unique Post inp.snap | 232 +- ...eneration__test__find_unique Post out.snap | 18 +- ...eration__test__find_unique Record inp.snap | 216 +- ...eration__test__find_unique Record out.snap | 6 +- ...eneration__test__find_unique User inp.snap | 650 +-- ...eneration__test__find_unique User out.snap | 22 +- ...generation__test__update_one Post inp.snap | 1921 ++++---- ...neration__test__update_one Record inp.snap | 158 +- ...generation__test__update_one User inp.snap | 3923 +++++++++-------- 9 files changed, 3958 insertions(+), 3188 deletions(-) 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 afb3f1819..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 @@ -5,102 +5,14 @@ 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 16bcf651e..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 @@ -2,13 +2,13 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: tp.print(out) --- -root: optional '_36_PostWithNestedCount?' #36 -└─ item: struct 'PostWithNestedCount' #35 - ├─ [author]: struct 'User' #15 - │ ├─ [id]: integer #11 - │ ├─ [name]: string #12 - │ └─ [posts]: list '_14_Post[]' #14 - │ └─ item: &Post #13 - ├─ [id]: integer #16 - └─ [title]: string #17 +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 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 40452bcd0..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 @@ -5,6 +5,60 @@ 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 becf17ce0..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,9 +1,9 @@ --- source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs -expression: "tree::PrintOptions::new().indent_size(3).print(out)" +expression: tp.print(out) --- -root: optional '_10_RecordWithNestedCount?' #10 -└─ item: struct 'RecordWithNestedCount' #9 +root: optional '_45_RecordWithNestedCount?' #45 +└─ item: struct 'RecordWithNestedCount' #44 ├─ [age]: optional #3 │ └─ item: integer #2 ├─ [id]: string #0 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 635e730b5..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 @@ -5,6 +5,14 @@ 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 ac5602acc..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 @@ -2,15 +2,15 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: tp.print(out) --- -root: optional '_30_UserWithNestedCount?' #30 -└─ item: struct 'UserWithNestedCount' #29 - ├─ [_count]: struct #28 - │ └─ [posts]: optional '_Count' #27 - │ └─ item: integer #26 - ├─ [id]: integer #11 - ├─ [name]: string #12 - └─ [posts]: list '_25_PostWithNestedCount_excluding___rel_Post_User_1[]' #25 - └─ item: struct 'PostWithNestedCount_excluding___rel_Post_User_1' #24 - ├─ [id]: integer #16 - └─ [title]: string #17 +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 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 8d0f0099e..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 @@ -2,859 +2,1070 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: tp.print(inp) --- -root: struct #166 -├─ [data]: struct '_Post_UpdateInput' #163 -│ ├─ [author]: optional #162 -│ │ └─ item: union #161 -│ │ ├─ variant_0: struct #147 -│ │ │ └─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #129 -│ │ │ ├─ [id]: integer #21 -│ │ │ └─ [name]: string #22 -│ │ ├─ variant_1: struct #148 -│ │ │ └─ [connect]: struct 'UserWhere' #145 -│ │ │ ├─ [id]: optional '_130__integer_filter_c?' #130 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [name]: optional '_131__string_filter_c?' #131 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [posts]: optional #144 -│ │ │ └─ item: union #143 -│ │ │ ├─ variant_0: struct #138 -│ │ │ │ └─ [every]: optional '_137_PostWhere__skip_25_UserWhere?' #137 -│ │ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ │ ├─ [author]: optional '_135_UserWhere?' #135 -│ │ │ │ │ └─ item: &UserWhere #134 -│ │ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ │ └─ item: union #53 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_1: struct #52 -│ │ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_1: struct #140 -│ │ │ │ └─ [some]: optional '_139_PostWhere__skip_25_UserWhere?' #139 -│ │ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ │ ├─ [author]: optional '_135_UserWhere?' #135 -│ │ │ │ │ └─ item: &UserWhere #134 -│ │ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ │ └─ item: union #53 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_1: struct #52 -│ │ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_2: struct #142 -│ │ │ └─ [none]: optional '_141_PostWhere__skip_25_UserWhere?' #141 -│ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ ├─ [author]: optional '_135_UserWhere?' #135 -│ │ │ │ └─ item: &UserWhere #134 -│ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [startsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ ├─ variant_2: struct #149 -│ │ │ └─ [connectOrCreate]: struct #146 -│ │ │ ├─ [create]: struct '_User_CreateInput_excluding___rel_Post_User_1' #129 -│ │ │ │ ├─ [id]: integer #21 -│ │ │ │ └─ [name]: string #22 -│ │ │ └─ [where]: struct 'UserWhere' #145 -│ │ │ ├─ [id]: optional '_130__integer_filter_c?' #130 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [name]: optional '_131__string_filter_c?' #131 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [posts]: optional #144 -│ │ │ └─ item: union #143 -│ │ │ ├─ variant_0: struct #138 -│ │ │ │ └─ [every]: optional '_137_PostWhere__skip_25_UserWhere?' #137 -│ │ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ │ ├─ [author]: optional '_135_UserWhere?' #135 -│ │ │ │ │ └─ item: &UserWhere #134 -│ │ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ │ └─ item: union #53 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_1: struct #52 -│ │ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_1: struct #140 -│ │ │ │ └─ [some]: optional '_139_PostWhere__skip_25_UserWhere?' #139 -│ │ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ │ ├─ [author]: optional '_135_UserWhere?' #135 -│ │ │ │ │ └─ item: &UserWhere #134 -│ │ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ │ └─ item: union #53 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_1: struct #52 -│ │ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_2: struct #142 -│ │ │ └─ [none]: optional '_141_PostWhere__skip_25_UserWhere?' #141 -│ │ │ └─ item: struct 'PostWhere__skip_25_UserWhere' #136 -│ │ │ ├─ [author]: optional '_135_UserWhere?' #135 -│ │ │ │ └─ item: &UserWhere #134 -│ │ │ ├─ [id]: optional '_132__integer_filter_c?' #132 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ [title]: optional '_133__string_filter_c?' #133 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [startsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ variant_3: struct #160 -│ │ └─ [update]: struct '_User_UpdateInput_excluding___rel_Post_User_1' #159 -│ │ ├─ [id]: optional #155 -│ │ │ └─ item: union #154 -│ │ │ ├─ variant_0: integer #21 -│ │ │ ├─ variant_1: struct #150 -│ │ │ │ └─ [set]: integer #21 -│ │ │ ├─ variant_2: struct #151 -│ │ │ │ └─ [multiply]: integer #21 -│ │ │ ├─ variant_3: struct #152 -│ │ │ │ └─ [decrement]: integer #21 -│ │ │ └─ variant_4: struct #153 -│ │ │ └─ [increment]: integer #21 -│ │ └─ [name]: optional #158 -│ │ └─ item: union #157 -│ │ ├─ variant_0: string #22 -│ │ └─ variant_1: struct #156 -│ │ └─ [set]: string #22 -│ ├─ [id]: optional #125 -│ │ └─ item: union #124 -│ │ ├─ variant_0: integer #26 -│ │ ├─ variant_1: struct #120 -│ │ │ └─ [set]: integer #26 -│ │ ├─ variant_2: struct #121 -│ │ │ └─ [multiply]: integer #26 -│ │ ├─ variant_3: struct #122 -│ │ │ └─ [decrement]: integer #26 -│ │ └─ variant_4: struct #123 -│ │ └─ [increment]: integer #26 -│ └─ [title]: optional #128 -│ └─ item: union #127 -│ ├─ variant_0: string #27 -│ └─ variant_1: struct #126 -│ └─ [set]: string #27 -└─ [where]: struct 'QueryUniquePostWhereInput' #165 - └─ [id]: optional #164 - └─ item: integer #26 +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 +│ │ ├─ variant_1: struct #146 +│ │ │ └─ [set]: integer #61 +│ │ ├─ variant_2: struct #147 +│ │ │ └─ [multiply]: integer #61 +│ │ ├─ variant_3: struct #148 +│ │ │ └─ [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 +└─ [where]: struct 'QueryPostWhereUniqueInput' #178 + ├─ [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 + │ │ └─ 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 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 e020d3709..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 @@ -27,7 +27,159 @@ root: struct #55 │ ├─ variant_0: string #1 │ └─ variant_1: struct #8 │ └─ [set]: string #1 -└─ [where]: struct 'QueryUniqueRecordWhereInput' #19 - └─ [id]: optional #18 - └─ item: string #0 +└─ [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 + │ ├─ 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 + └─ [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 8526fc099..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 @@ -2,1762 +2,2169 @@ source: typegraph/core/src/runtimes/prisma/type_generation/mod.rs expression: tp.print(inp) --- -root: struct #119 -├─ [data]: struct '_User_UpdateInput' #116 -│ ├─ [id]: optional #35 -│ │ └─ item: union #34 -│ │ ├─ variant_0: integer #21 -│ │ ├─ variant_1: struct #30 -│ │ │ └─ [set]: integer #21 -│ │ ├─ variant_2: struct #31 -│ │ │ └─ [multiply]: integer #21 -│ │ ├─ variant_3: struct #32 -│ │ │ └─ [decrement]: integer #21 -│ │ └─ variant_4: struct #33 -│ │ └─ [increment]: integer #21 -│ ├─ [name]: optional #38 -│ │ └─ item: union #37 -│ │ ├─ variant_0: string #22 -│ │ └─ variant_1: struct #36 -│ │ └─ [set]: string #22 -│ └─ [posts]: optional #115 -│ └─ item: union #114 -│ ├─ variant_0: struct #90 -│ │ └─ [create]: union #42 -│ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ │ ├─ [id]: optional #39 -│ │ │ │ └─ item: integer #26 -│ │ │ └─ [title]: string #27 -│ │ └─ variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 -│ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ ├─ [id]: optional #39 -│ │ │ └─ item: integer #26 -│ │ └─ [title]: string #27 -│ ├─ variant_1: struct #91 -│ │ └─ [connect]: union #88 -│ │ ├─ variant_0: struct 'PostWhere' #86 -│ │ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ │ └─ item: union #53 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_1: struct #52 -│ │ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ │ └─ item: union #70 -│ │ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ variant_1: struct #69 -│ │ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [posts]: optional #83 -│ │ │ │ └─ item: union #82 -│ │ │ │ ├─ variant_0: struct #77 -│ │ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ │ └─ item: &PostWhere #75 -│ │ │ │ ├─ variant_1: struct #79 -│ │ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ │ └─ item: &PostWhere #75 -│ │ │ │ └─ variant_2: struct #81 -│ │ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [startsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ variant_1: list '_87_PostWhere[]' #87 -│ │ └─ item: struct 'PostWhere' #86 -│ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [posts]: optional #83 -│ │ │ └─ item: union #82 -│ │ │ ├─ variant_0: struct #77 -│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ variant_1: struct #79 -│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ └─ variant_2: struct #81 -│ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ └─ item: &PostWhere #75 -│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [lte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ └─ [title]: optional '_72__string_filter_c?' #72 -│ │ └─ item: optional '_string_filter_c' #71 -│ │ └─ item: union #70 -│ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [startsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ variant_1: struct #69 -│ │ └─ [not]: union '_string_filter' #68 -│ │ ├─ variant_0: string #56 -│ │ ├─ variant_1: struct #59 -│ │ │ └─ [equals]: string #56 -│ │ ├─ variant_2: struct #60 -│ │ │ └─ [not]: string #56 -│ │ ├─ variant_3: struct #61 -│ │ │ └─ [in]: list #58 -│ │ │ └─ item: string #56 -│ │ ├─ variant_4: struct #62 -│ │ │ └─ [notIn]: list #58 -│ │ │ └─ item: string #56 -│ │ ├─ variant_5: struct #65 -│ │ │ ├─ [contains]: string #56 -│ │ │ └─ [mode]: optional #64 -│ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #66 -│ │ │ └─ [search]: string #56 -│ │ └─ variant_7: struct #67 -│ │ ├─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [startsWith]: optional #57 -│ │ └─ item: string #56 -│ ├─ variant_2: struct #92 -│ │ └─ [connectOrCreate]: struct #89 -│ │ ├─ [create]: union #42 -│ │ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ │ │ ├─ [id]: optional #39 -│ │ │ │ │ └─ item: integer #26 -│ │ │ │ └─ [title]: string #27 -│ │ │ └─ variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 -│ │ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ │ ├─ [id]: optional #39 -│ │ │ │ └─ item: integer #26 -│ │ │ └─ [title]: string #27 -│ │ └─ [where]: union #88 -│ │ ├─ variant_0: struct 'PostWhere' #86 -│ │ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ │ └─ item: union #53 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_1: struct #52 -│ │ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ │ └─ item: union #70 -│ │ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ variant_1: struct #69 -│ │ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [posts]: optional #83 -│ │ │ │ └─ item: union #82 -│ │ │ │ ├─ variant_0: struct #77 -│ │ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ │ └─ item: &PostWhere #75 -│ │ │ │ ├─ variant_1: struct #79 -│ │ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ │ └─ item: &PostWhere #75 -│ │ │ │ └─ variant_2: struct #81 -│ │ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [startsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ variant_1: list '_87_PostWhere[]' #87 -│ │ └─ item: struct 'PostWhere' #86 -│ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [posts]: optional #83 -│ │ │ └─ item: union #82 -│ │ │ ├─ variant_0: struct #77 -│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ variant_1: struct #79 -│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ └─ variant_2: struct #81 -│ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ └─ item: &PostWhere #75 -│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [lte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ └─ [title]: optional '_72__string_filter_c?' #72 -│ │ └─ item: optional '_string_filter_c' #71 -│ │ └─ item: union #70 -│ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [startsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ variant_1: struct #69 -│ │ └─ [not]: union '_string_filter' #68 -│ │ ├─ variant_0: string #56 -│ │ ├─ variant_1: struct #59 -│ │ │ └─ [equals]: string #56 -│ │ ├─ variant_2: struct #60 -│ │ │ └─ [not]: string #56 -│ │ ├─ variant_3: struct #61 -│ │ │ └─ [in]: list #58 -│ │ │ └─ item: string #56 -│ │ ├─ variant_4: struct #62 -│ │ │ └─ [notIn]: list #58 -│ │ │ └─ item: string #56 -│ │ ├─ variant_5: struct #65 -│ │ │ ├─ [contains]: string #56 -│ │ │ └─ [mode]: optional #64 -│ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #66 -│ │ │ └─ [search]: string #56 -│ │ └─ variant_7: struct #67 -│ │ ├─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [startsWith]: optional #57 -│ │ └─ item: string #56 -│ ├─ variant_3: struct #103 -│ │ └─ [update]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #102 -│ │ ├─ [id]: optional #98 -│ │ │ └─ item: union #97 -│ │ │ ├─ variant_0: integer #26 -│ │ │ ├─ variant_1: struct #93 -│ │ │ │ └─ [set]: integer #26 -│ │ │ ├─ variant_2: struct #94 -│ │ │ │ └─ [multiply]: integer #26 -│ │ │ ├─ variant_3: struct #95 -│ │ │ │ └─ [decrement]: integer #26 -│ │ │ └─ variant_4: struct #96 -│ │ │ └─ [increment]: integer #26 -│ │ └─ [title]: optional #101 -│ │ └─ item: union #100 -│ │ ├─ variant_0: string #27 -│ │ └─ variant_1: struct #99 -│ │ └─ [set]: string #27 -│ ├─ variant_4: struct #106 -│ │ └─ [updateMany]: struct #105 -│ │ ├─ [data]: struct '_Post_UpdateInput_excluding___rel_Post_User_1' #102 -│ │ │ ├─ [id]: optional #98 -│ │ │ │ └─ item: union #97 -│ │ │ │ ├─ variant_0: integer #26 -│ │ │ │ ├─ variant_1: struct #93 -│ │ │ │ │ └─ [set]: integer #26 -│ │ │ │ ├─ variant_2: struct #94 -│ │ │ │ │ └─ [multiply]: integer #26 -│ │ │ │ ├─ variant_3: struct #95 -│ │ │ │ │ └─ [decrement]: integer #26 -│ │ │ │ └─ variant_4: struct #96 -│ │ │ │ └─ [increment]: integer #26 -│ │ │ └─ [title]: optional #101 -│ │ │ └─ item: union #100 -│ │ │ ├─ variant_0: string #27 -│ │ │ └─ variant_1: struct #99 -│ │ │ └─ [set]: string #27 -│ │ └─ [where]: optional #104 -│ │ └─ item: union #88 -│ │ ├─ variant_0: struct 'PostWhere' #86 -│ │ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ │ └─ item: union #53 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_1: struct #52 -│ │ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ │ └─ item: union #70 -│ │ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ variant_1: struct #69 -│ │ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [posts]: optional #83 -│ │ │ │ └─ item: union #82 -│ │ │ │ ├─ variant_0: struct #77 -│ │ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ │ └─ item: &PostWhere #75 -│ │ │ │ ├─ variant_1: struct #79 -│ │ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ │ └─ item: &PostWhere #75 -│ │ │ │ └─ variant_2: struct #81 -│ │ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [startsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ variant_1: list '_87_PostWhere[]' #87 -│ │ └─ item: struct 'PostWhere' #86 -│ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [posts]: optional #83 -│ │ │ └─ item: union #82 -│ │ │ ├─ variant_0: struct #77 -│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ variant_1: struct #79 -│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ └─ variant_2: struct #81 -│ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ └─ item: &PostWhere #75 -│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [lte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ └─ [title]: optional '_72__string_filter_c?' #72 -│ │ └─ item: optional '_string_filter_c' #71 -│ │ └─ item: union #70 -│ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [startsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ variant_1: struct #69 -│ │ └─ [not]: union '_string_filter' #68 -│ │ ├─ variant_0: string #56 -│ │ ├─ variant_1: struct #59 -│ │ │ └─ [equals]: string #56 -│ │ ├─ variant_2: struct #60 -│ │ │ └─ [not]: string #56 -│ │ ├─ variant_3: struct #61 -│ │ │ └─ [in]: list #58 -│ │ │ └─ item: string #56 -│ │ ├─ variant_4: struct #62 -│ │ │ └─ [notIn]: list #58 -│ │ │ └─ item: string #56 -│ │ ├─ variant_5: struct #65 -│ │ │ ├─ [contains]: string #56 -│ │ │ └─ [mode]: optional #64 -│ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #66 -│ │ │ └─ [search]: string #56 -│ │ └─ variant_7: struct #67 -│ │ ├─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [startsWith]: optional #57 -│ │ └─ item: string #56 -│ ├─ variant_5: struct #109 -│ │ └─ [deleteMany]: struct #108 -│ │ └─ [where]: optional #107 -│ │ └─ item: union #88 -│ │ ├─ variant_0: struct 'PostWhere' #86 -│ │ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ │ └─ item: union #53 -│ │ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_1: struct #52 -│ │ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ │ └─ item: union #70 -│ │ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ variant_1: struct #69 -│ │ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [posts]: optional #83 -│ │ │ │ └─ item: union #82 -│ │ │ │ ├─ variant_0: struct #77 -│ │ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ │ └─ item: &PostWhere #75 -│ │ │ │ ├─ variant_1: struct #79 -│ │ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ │ └─ item: &PostWhere #75 -│ │ │ │ └─ variant_2: struct #81 -│ │ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ [title]: optional '_72__string_filter_c?' #72 -│ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ └─ item: union #70 -│ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ variant_1: struct #69 -│ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [startsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ variant_1: list '_87_PostWhere[]' #87 -│ │ └─ item: struct 'PostWhere' #86 -│ │ ├─ [author]: optional '_85_UserWhere__skip_29_PostWhere?' #85 -│ │ │ └─ item: struct 'UserWhere__skip_29_PostWhere' #84 -│ │ │ ├─ [id]: optional '_73__integer_filter_c?' #73 -│ │ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ │ └─ item: union #53 -│ │ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ variant_5: struct #50 -│ │ │ │ │ └─ [notIn]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_1: struct #52 -│ │ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ [name]: optional '_74__string_filter_c?' #74 -│ │ │ │ └─ item: optional '_string_filter_c' #71 -│ │ │ │ └─ item: union #70 -│ │ │ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ │ │ ├─ variant_0: string #56 -│ │ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ │ └─ [not]: string #56 -│ │ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ │ └─ [search]: string #56 -│ │ │ │ │ └─ variant_7: struct #67 -│ │ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ │ └─ item: string #56 -│ │ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ variant_1: struct #69 -│ │ │ │ └─ [not]: union '_string_filter' #68 -│ │ │ │ ├─ variant_0: string #56 -│ │ │ │ ├─ variant_1: struct #59 -│ │ │ │ │ └─ [equals]: string #56 -│ │ │ │ ├─ variant_2: struct #60 -│ │ │ │ │ └─ [not]: string #56 -│ │ │ │ ├─ variant_3: struct #61 -│ │ │ │ │ └─ [in]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_4: struct #62 -│ │ │ │ │ └─ [notIn]: list #58 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ ├─ variant_5: struct #65 -│ │ │ │ │ ├─ [contains]: string #56 -│ │ │ │ │ └─ [mode]: optional #64 -│ │ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ │ ├─ variant_6: struct #66 -│ │ │ │ │ └─ [search]: string #56 -│ │ │ │ └─ variant_7: struct #67 -│ │ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ │ └─ item: string #56 -│ │ │ │ └─ [startsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [posts]: optional #83 -│ │ │ └─ item: union #82 -│ │ │ ├─ variant_0: struct #77 -│ │ │ │ └─ [every]: optional '_76_PostWhere?' #76 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ ├─ variant_1: struct #79 -│ │ │ │ └─ [some]: optional '_78_PostWhere?' #78 -│ │ │ │ └─ item: &PostWhere #75 -│ │ │ └─ variant_2: struct #81 -│ │ │ └─ [none]: optional '_80_PostWhere?' #80 -│ │ │ └─ item: &PostWhere #75 -│ │ ├─ [id]: optional '_55__integer_filter_c?' #55 -│ │ │ └─ item: optional '_integer_filter_c' #54 -│ │ │ └─ item: union #53 -│ │ │ ├─ variant_0: either '_integer_filter' #51 -│ │ │ │ ├─ variant_0: integer #43 -│ │ │ │ ├─ variant_1: struct #46 -│ │ │ │ │ └─ [equals]: integer #43 -│ │ │ │ ├─ variant_2: struct #47 -│ │ │ │ │ └─ [not]: integer #43 -│ │ │ │ ├─ variant_3: struct #48 -│ │ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ │ └─ item: integer #43 -│ │ │ │ │ └─ [lte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ variant_4: struct #49 -│ │ │ │ │ └─ [in]: list #45 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ variant_5: struct #50 -│ │ │ │ └─ [notIn]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_1: struct #52 -│ │ │ └─ [not]: either '_integer_filter' #51 -│ │ │ ├─ variant_0: integer #43 -│ │ │ ├─ variant_1: struct #46 -│ │ │ │ └─ [equals]: integer #43 -│ │ │ ├─ variant_2: struct #47 -│ │ │ │ └─ [not]: integer #43 -│ │ │ ├─ variant_3: struct #48 -│ │ │ │ ├─ [gt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [gte]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ ├─ [lt]: optional #44 -│ │ │ │ │ └─ item: integer #43 -│ │ │ │ └─ [lte]: optional #44 -│ │ │ │ └─ item: integer #43 -│ │ │ ├─ variant_4: struct #49 -│ │ │ │ └─ [in]: list #45 -│ │ │ │ └─ item: integer #43 -│ │ │ └─ variant_5: struct #50 -│ │ │ └─ [notIn]: list #45 -│ │ │ └─ item: integer #43 -│ │ └─ [title]: optional '_72__string_filter_c?' #72 -│ │ └─ item: optional '_string_filter_c' #71 -│ │ └─ item: union #70 -│ │ ├─ variant_0: union '_string_filter' #68 -│ │ │ ├─ variant_0: string #56 -│ │ │ ├─ variant_1: struct #59 -│ │ │ │ └─ [equals]: string #56 -│ │ │ ├─ variant_2: struct #60 -│ │ │ │ └─ [not]: string #56 -│ │ │ ├─ variant_3: struct #61 -│ │ │ │ └─ [in]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_4: struct #62 -│ │ │ │ └─ [notIn]: list #58 -│ │ │ │ └─ item: string #56 -│ │ │ ├─ variant_5: struct #65 -│ │ │ │ ├─ [contains]: string #56 -│ │ │ │ └─ [mode]: optional #64 -│ │ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ │ ├─ variant_6: struct #66 -│ │ │ │ └─ [search]: string #56 -│ │ │ └─ variant_7: struct #67 -│ │ │ ├─ [endsWith]: optional #57 -│ │ │ │ └─ item: string #56 -│ │ │ └─ [startsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ variant_1: struct #69 -│ │ └─ [not]: union '_string_filter' #68 -│ │ ├─ variant_0: string #56 -│ │ ├─ variant_1: struct #59 -│ │ │ └─ [equals]: string #56 -│ │ ├─ variant_2: struct #60 -│ │ │ └─ [not]: string #56 -│ │ ├─ variant_3: struct #61 -│ │ │ └─ [in]: list #58 -│ │ │ └─ item: string #56 -│ │ ├─ variant_4: struct #62 -│ │ │ └─ [notIn]: list #58 -│ │ │ └─ item: string #56 -│ │ ├─ variant_5: struct #65 -│ │ │ ├─ [contains]: string #56 -│ │ │ └─ [mode]: optional #64 -│ │ │ └─ item: string #63 enum{ '"insensitive"' } -│ │ ├─ variant_6: struct #66 -│ │ │ └─ [search]: string #56 -│ │ └─ variant_7: struct #67 -│ │ ├─ [endsWith]: optional #57 -│ │ │ └─ item: string #56 -│ │ └─ [startsWith]: optional #57 -│ │ └─ item: string #56 -│ └─ variant_6: struct #113 -│ └─ [createMany]: optional #112 -│ └─ item: struct #111 -│ └─ [data]: list #110 -│ └─ item: union #42 -│ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ │ ├─ [id]: optional #39 -│ │ │ └─ item: integer #26 -│ │ └─ [title]: string #27 -│ └─ variant_1: list '_41__Post_CreateInput_excluding___rel_Post_User_1[]' #41 -│ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #40 -│ ├─ [id]: optional #39 -│ │ └─ item: integer #26 -│ └─ [title]: string #27 -└─ [where]: struct 'QueryUniqueUserWhereInput' #118 - └─ [id]: optional #117 - └─ item: integer #21 +root: struct #145 +├─ [data]: struct '_User_UpdateInput' #123 +│ ├─ [id]: optional #70 +│ │ └─ item: union #69 +│ │ ├─ variant_0: integer #56 +│ │ ├─ variant_1: struct #65 +│ │ │ └─ [set]: integer #56 +│ │ ├─ variant_2: struct #66 +│ │ │ └─ [multiply]: integer #56 +│ │ ├─ variant_3: struct #67 +│ │ │ └─ [decrement]: integer #56 +│ │ └─ variant_4: struct #68 +│ │ └─ [increment]: integer #56 +│ ├─ [name]: optional #73 +│ │ └─ item: union #72 +│ │ ├─ variant_0: string #57 +│ │ └─ variant_1: struct #71 +│ │ └─ [set]: string #57 +│ └─ [posts]: optional #122 +│ └─ item: union #121 +│ ├─ variant_0: struct #97 +│ │ └─ [create]: union #77 +│ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #75 +│ │ │ ├─ [id]: optional #74 +│ │ │ │ └─ item: integer #61 +│ │ │ └─ [title]: string #62 +│ │ └─ variant_1: list '_76__Post_CreateInput_excluding___rel_Post_User_1[]' #76 +│ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #75 +│ │ ├─ [id]: optional #74 +│ │ │ └─ item: integer #61 +│ │ └─ [title]: string #62 +│ ├─ 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 +│ │ │ │ ├─ 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_2: struct #99 +│ │ └─ [connectOrCreate]: struct #96 +│ │ ├─ [create]: union #77 +│ │ │ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #75 +│ │ │ │ ├─ [id]: optional #74 +│ │ │ │ │ └─ item: integer #61 +│ │ │ │ └─ [title]: string #62 +│ │ │ └─ variant_1: list '_76__Post_CreateInput_excluding___rel_Post_User_1[]' #76 +│ │ │ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #75 +│ │ │ ├─ [id]: optional #74 +│ │ │ │ └─ item: integer #61 +│ │ │ └─ [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 +│ │ │ │ ├─ 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_3: struct #110 +│ │ └─ [update]: 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 +│ ├─ variant_4: struct #113 +│ │ └─ [updateMany]: struct #112 +│ │ ├─ [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 +│ │ │ │ ├─ 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_6: struct #120 +│ └─ [createMany]: optional #119 +│ └─ item: struct #118 +│ └─ [data]: list #117 +│ └─ item: union #77 +│ ├─ variant_0: struct '_Post_CreateInput_excluding___rel_Post_User_1' #75 +│ │ ├─ [id]: optional #74 +│ │ │ └─ item: integer #61 +│ │ └─ [title]: string #62 +│ └─ variant_1: list '_76__Post_CreateInput_excluding___rel_Post_User_1[]' #76 +│ └─ item: struct '_Post_CreateInput_excluding___rel_Post_User_1' #75 +│ ├─ [id]: optional #74 +│ │ └─ 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 + │ ├─ 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 From 113b81adcaa3d2eb9f074113513758e470b2b0c2 Mon Sep 17 00:00:00 2001 From: Natoandro Date: Mon, 19 Feb 2024 15:11:58 +0300 Subject: [PATCH 31/32] fix test --- .../typegate/__snapshots__/typegate_runtime_test.ts.snap | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 4803209d7..dc0c3e2a2 100644 --- a/typegate/tests/runtimes/typegate/__snapshots__/typegate_runtime_test.ts.snap +++ b/typegate/tests/runtimes/typegate/__snapshots__/typegate_runtime_test.ts.snap @@ -16,7 +16,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: true, runtime: "prisma", - title: "QueryrecordWhereUniqueInput", + title: "QueryUniquerecordWhereInput", type: "object", }, }, @@ -291,7 +291,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: true, runtime: "prisma", - title: "QueryusersWhereUniqueInput", + title: "QueryUniqueusersWhereInput", type: "object", }, }, From a519f1fd06de9c3fb714c924aaabf01c2991e3df Mon Sep 17 00:00:00 2001 From: Natoandro Date: Tue, 20 Feb 2024 00:58:56 +0300 Subject: [PATCH 32/32] update snapshot --- .../typegate_runtime_test.ts.snap | 20 +++++++++---------- .../type_generation/query_where_expr.rs | 1 - 2 files changed, 10 insertions(+), 11 deletions(-) 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 dc0c3e2a2..dfea0d656 100644 --- a/typegate/tests/runtimes/typegate/__snapshots__/typegate_runtime_test.ts.snap +++ b/typegate/tests/runtimes/typegate/__snapshots__/typegate_runtime_test.ts.snap @@ -16,7 +16,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: true, runtime: "prisma", - title: "QueryUniquerecordWhereInput", + title: "QueryrecordWhereUniqueInput", type: "object", }, }, @@ -88,7 +88,7 @@ snapshot[`typegate: find available operations 1`] = ` format: "date-time", optional: false, runtime: "prisma", - title: "string_33", + title: "string_69", type: "string", }, }, @@ -198,7 +198,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: false, runtime: "prisma", - title: "_101_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_33", + title: "string_69", type: "string", }, }, @@ -291,7 +291,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: true, runtime: "prisma", - title: "QueryUniqueusersWhereInput", + title: "QueryusersWhereUniqueInput", type: "object", }, }, @@ -331,7 +331,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: false, runtime: "prisma", - title: "_244_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: "_246_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_247", + title: "integer_285", type: "integer", }, }, @@ -413,7 +413,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: true, runtime: "prisma", - title: "integer_247", + title: "integer_285", type: "integer", }, }, @@ -523,7 +523,7 @@ snapshot[`typegate: find available operations 1`] = ` format: null, optional: false, runtime: "prisma", - title: "_279_messagesWithNestedCount[]", + title: "_317_messagesWithNestedCount[]", type: "list", }, outputItem: { 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