---
source: cynic-codegen/tests/use-schema.rs
expression: "format_code(format!(\"{}\", tokens))"
---
impl cynic::schema::QueryRoot for Foo {}
pub struct Bar;
pub struct FlattenableEnums;
pub struct Foo;
pub struct RecursiveInputChild;
impl cynic::schema::InputObjectMarker for RecursiveInputChild {}
pub struct RecursiveInputParent;
impl cynic::schema::InputObjectMarker for RecursiveInputParent {}
pub struct SelfRecursiveInput;
impl cynic::schema::InputObjectMarker for SelfRecursiveInput {}
pub struct States {}
pub struct UUID {}
impl cynic::schema::NamedType for UUID {
    const NAME: &'static str = "UUID";
}
impl cynic::schema::NamedType for Bar {
    const NAME: &'static str = "Bar";
}
impl cynic::schema::NamedType for FlattenableEnums {
    const NAME: &'static str = "FlattenableEnums";
}
impl cynic::schema::NamedType for Foo {
    const NAME: &'static str = "Foo";
}
#[allow(non_snake_case, non_camel_case_types)]
pub mod __fields {
    pub mod Bar {
        pub struct id;
        impl cynic::schema::Field for id {
            type Type = super::super::UUID;
            const NAME: &'static str = "id";
        }
        impl cynic::schema::HasField<id> for super::super::Bar {
            type Type = super::super::UUID;
        }
        pub struct name;
        impl cynic::schema::Field for name {
            type Type = Option<super::super::String>;
            const NAME: &'static str = "name";
        }
        impl cynic::schema::HasField<name> for super::super::Bar {
            type Type = Option<super::super::String>;
        }
        pub struct __typename;
        impl cynic::schema::Field for __typename {
            type Type = super::super::String;
            const NAME: &'static str = "__typename";
        }
        impl cynic::schema::HasField<__typename> for super::super::Bar {
            type Type = super::super::String;
        }
    }
    pub mod FlattenableEnums {
        pub struct states;
        impl cynic::schema::Field for states {
            type Type = Option<Vec<Option<super::super::States>>>;
            const NAME: &'static str = "states";
        }
        impl cynic::schema::HasField<states> for super::super::FlattenableEnums {
            type Type = Option<Vec<Option<super::super::States>>>;
        }
        pub struct __typename;
        impl cynic::schema::Field for __typename {
            type Type = super::super::String;
            const NAME: &'static str = "__typename";
        }
        impl cynic::schema::HasField<__typename> for super::super::FlattenableEnums {
            type Type = super::super::String;
        }
    }
    pub mod Foo {
        pub struct _Underscore;
        impl cynic::schema::Field for _Underscore {
            type Type = Option<super::super::Boolean>;
            const NAME: &'static str = "_";
        }
        impl cynic::schema::HasField<_Underscore> for super::super::Foo {
            type Type = Option<super::super::Boolean>;
        }
        pub struct self_;
        impl cynic::schema::Field for self_ {
            type Type = Option<super::super::Boolean>;
            const NAME: &'static str = "self";
        }
        impl cynic::schema::HasField<self_> for super::super::Foo {
            type Type = Option<super::super::Boolean>;
        }
        pub struct super_;
        impl cynic::schema::Field for super_ {
            type Type = Option<super::super::Boolean>;
            const NAME: &'static str = "super";
        }
        impl cynic::schema::HasField<super_> for super::super::Foo {
            type Type = Option<super::super::Boolean>;
        }
        pub struct crate_;
        impl cynic::schema::Field for crate_ {
            type Type = Option<super::super::Boolean>;
            const NAME: &'static str = "crate";
        }
        impl cynic::schema::HasField<crate_> for super::super::Foo {
            type Type = Option<super::super::Boolean>;
        }
        pub struct r#async;
        impl cynic::schema::Field for r#async {
            type Type = Option<super::super::Boolean>;
            const NAME: &'static str = "async";
        }
        impl cynic::schema::HasField<r#async> for super::super::Foo {
            type Type = Option<super::super::Boolean>;
        }
        pub struct bar;
        impl cynic::schema::Field for bar {
            type Type = Option<super::super::Bar>;
            const NAME: &'static str = "bar";
        }
        impl cynic::schema::HasField<bar> for super::super::Foo {
            type Type = Option<super::super::Bar>;
        }
        pub mod _bar_arguments {
            pub struct id;
            impl cynic::schema::HasArgument<id> for super::bar {
                type ArgumentType = super::super::super::UUID;
                const NAME: &'static str = "id";
            }
        }
        pub struct fieldWithKeywordArg;
        impl cynic::schema::Field for fieldWithKeywordArg {
            type Type = Vec<super::super::Int>;
            const NAME: &'static str = "fieldWithKeywordArg";
        }
        impl cynic::schema::HasField<fieldWithKeywordArg> for super::super::Foo {
            type Type = Vec<super::super::Int>;
        }
        pub mod _field_with_keyword_arg_arguments {
            pub struct r#where;
            impl cynic::schema::HasArgument<r#where> for super::fieldWithKeywordArg {
                type ArgumentType = Option<super::super::super::Int>;
                const NAME: &'static str = "where";
            }
        }
        pub struct recursiveInputField;
        impl cynic::schema::Field for recursiveInputField {
            type Type = Option<super::super::Boolean>;
            const NAME: &'static str = "recursiveInputField";
        }
        impl cynic::schema::HasField<recursiveInputField> for super::super::Foo {
            type Type = Option<super::super::Boolean>;
        }
        pub mod _recursive_input_field_arguments {
            pub struct recursive;
            impl cynic::schema::HasArgument<recursive> for super::recursiveInputField {
                type ArgumentType = Option<super::super::super::SelfRecursiveInput>;
                const NAME: &'static str = "recursive";
            }
            pub struct recursive2;
            impl cynic::schema::HasArgument<recursive2> for super::recursiveInputField {
                type ArgumentType = Option<super::super::super::RecursiveInputParent>;
                const NAME: &'static str = "recursive2";
            }
        }
        pub struct fieldWithStringArg;
        impl cynic::schema::Field for fieldWithStringArg {
            type Type = Option<super::super::Int>;
            const NAME: &'static str = "fieldWithStringArg";
        }
        impl cynic::schema::HasField<fieldWithStringArg> for super::super::Foo {
            type Type = Option<super::super::Int>;
        }
        pub mod _field_with_string_arg_arguments {
            pub struct input;
            impl cynic::schema::HasArgument<input> for super::fieldWithStringArg {
                type ArgumentType = super::super::super::String;
                const NAME: &'static str = "input";
            }
        }
        pub struct __typename;
        impl cynic::schema::Field for __typename {
            type Type = super::super::String;
            const NAME: &'static str = "__typename";
        }
        impl cynic::schema::HasField<__typename> for super::super::Foo {
            type Type = super::super::String;
        }
    }
    pub mod RecursiveInputChild {
        pub struct recurse;
        impl cynic::schema::Field for recurse {
            type Type = Option<super::super::RecursiveInputParent>;
            const NAME: &'static str = "recurse";
        }
        impl cynic::schema::HasInputField<recurse, Option<super::super::RecursiveInputParent>>
            for super::super::RecursiveInputChild
        {
        }
    }
    pub mod RecursiveInputParent {
        pub struct recurse;
        impl cynic::schema::Field for recurse {
            type Type = Option<super::super::RecursiveInputChild>;
            const NAME: &'static str = "recurse";
        }
        impl cynic::schema::HasInputField<recurse, Option<super::super::RecursiveInputChild>>
            for super::super::RecursiveInputParent
        {
        }
    }
    pub mod SelfRecursiveInput {
        pub struct recurse;
        impl cynic::schema::Field for recurse {
            type Type = Option<super::super::SelfRecursiveInput>;
            const NAME: &'static str = "recurse";
        }
        impl cynic::schema::HasInputField<recurse, Option<super::super::SelfRecursiveInput>>
            for super::super::SelfRecursiveInput
        {
        }
    }
}
pub type Boolean = bool;
pub type String = std::string::String;
pub type Float = f64;
pub type Int = i32;
pub type ID = cynic::Id;
pub mod variable {
    use cynic::variables::VariableType;
    #[doc = r" Used to determine the type of a given variable that"]
    #[doc = r" appears in an argument struct."]
    pub trait Variable {
        const TYPE: VariableType;
    }
    impl<T> Variable for &T
    where
        T: ?::core::marker::Sized + Variable,
    {
        const TYPE: VariableType = T::TYPE;
    }
    impl<T> Variable for Option<T>
    where
        T: Variable,
    {
        const TYPE: VariableType = VariableType::Nullable(&T::TYPE);
    }
    impl<T> Variable for [T]
    where
        T: Variable,
    {
        const TYPE: VariableType = VariableType::List(&T::TYPE);
    }
    impl<T> Variable for Vec<T>
    where
        T: Variable,
    {
        const TYPE: VariableType = VariableType::List(&T::TYPE);
    }
    impl<T> Variable for Box<T>
    where
        T: Variable,
    {
        const TYPE: VariableType = T::TYPE;
    }
    impl<T> Variable for std::rc::Rc<T>
    where
        T: Variable,
    {
        const TYPE: VariableType = T::TYPE;
    }
    impl<T> Variable for std::sync::Arc<T>
    where
        T: Variable,
    {
        const TYPE: VariableType = T::TYPE;
    }
    impl<T> Variable for std::borrow::Cow<'_, T>
    where
        T: ?::core::marker::Sized + Variable + ToOwned,
    {
        const TYPE: VariableType = T::TYPE;
    }
    impl Variable for bool {
        const TYPE: VariableType = VariableType::Named("Boolean");
    }
    impl Variable for str {
        const TYPE: VariableType = VariableType::Named("String");
    }
    impl Variable for String {
        const TYPE: VariableType = <str as Variable>::TYPE;
    }
    impl Variable for f64 {
        const TYPE: VariableType = VariableType::Named("Float");
    }
    impl Variable for i32 {
        const TYPE: VariableType = VariableType::Named("Int");
    }
    impl Variable for cynic::Id {
        const TYPE: VariableType = VariableType::Named("ID");
    }
}