rustdoc_schema.graphql

schema {
  query: RootSchemaQuery
}
directive @filter(op: String!, value: [String!]) on FIELD | INLINE_FRAGMENT
directive @tag(name: String) on FIELD
directive @output(name: String) on FIELD
directive @optional on FIELD
directive @recurse(depth: Int!) on FIELD
directive @fold on FIELD

type RootSchemaQuery {
  Crate: Crate!
  CrateDiff: CrateDiff!
}

type CrateDiff {
  current: Crate!
  baseline: Crate
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Crate.html
"""
type Crate {
  root: String!
  crate_version: String
  includes_private: Boolean!
  format_version: Int!

  """
  The top-level module of the crate, in which everything else in the crate is contained.
  """
  root_module: Module!

  item: [Item!]
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
"""
interface Item {
  id: String!
  crate_id: Int!
  name: String
  docs: String

  """
  A list of all the attributes applied to this item.

  The attributes are also available through the `attribute` edge,
  which makes certain operations easier.
  """
  attrs: [String!]!

  # stringified version of the visibility struct field
  visibility_limit: String!

  attribute: [Attribute!]
  span: Span
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.16.0/rustdoc_types/struct.Module.html
"""
type Module implements Item & Importable {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # own properties
  is_stripped: Boolean!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Importable
  importable_path: [ImportablePath!]
  canonical_path: Path

  # own edges
  item: [Item!]!
}


"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Struct.html
"""
type Struct implements Item & Importable & ImplOwner {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # own properties
  struct_type: String!
  fields_stripped: Boolean!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Importable
  importable_path: [ImportablePath!]
  canonical_path: Path

  # edges from ImplOwner
  """
  Any impl for this type.

  All impl kinds are included:
  - inherent impls: `impl Foo`
  - explicit trait implementations: `impl Bar for Foo`
  - blanket implementations: `impl<T> Bar for T`
  """
  impl: [Impl!]

  """
  Only inherent impls: implementations of the type itself (`impl Foo`).

  The impls pointed to here are guaranteed to have no `trait` and no `blanket` edges.

  This edge is just a convenience to simplify query-writing,
  so we don't have to keep writing "@fold @transform(...) @filter(...)" chains
  over the `trait` and `blanket` edges.

  When Trustfall supports macro edges, this should just become a macro edge.
  """
  inherent_impl: [Impl!]

  # own edges
  field: [StructField!]
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.Type.html
"""
type StructField implements Item {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # own edges
  raw_type: RawType
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Enum.html
"""
type Enum implements Item & Importable & ImplOwner {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # own properties
  variants_stripped: Boolean!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Importable
  importable_path: [ImportablePath!]
  canonical_path: Path

  # edges from ImplOwner
  """
  Any impl for this type.

  All impl kinds are included:
  - inherent impls: `impl Foo`
  - explicit trait implementations: `impl Bar for Foo`
  - blanket implementations: `impl<T> Bar for T`
  """
  impl: [Impl!]

  """
  Only inherent impls: implementations of the type itself (`impl Foo`).

  The impls pointed to here are guaranteed to have no `trait` and no `blanket` edges.

  This edge is just a convenience to simplify query-writing,
  so we don't have to keep writing "@fold @transform(...) @filter(...)" chains
  over the `trait` and `blanket` edges.

  When Trustfall supports macro edges, this should just become a macro edge.
  """
  inherent_impl: [Impl!]

  # own edges
  variant: [Variant!]
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.Variant.html
"""
interface Variant implements Item {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # own edges
  field: [StructField!]
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.Variant.html
"""
type PlainVariant implements Item & Variant {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Variant
  field: [StructField!]
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.Variant.html
"""
type TupleVariant implements Item & Variant {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Variant
  field: [StructField!]
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.Variant.html
"""
type StructVariant implements Item & Variant {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Variant
  field: [StructField!]
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Span.html
"""
type Span {
  filename: String!
  begin_line: Int!
  begin_column: Int!
  end_line: Int!
  end_column: Int!
}

"""
An item that can be imported, through one or more paths.
"""
interface Importable {
  importable_path: [ImportablePath!]
  canonical_path: Path
}

"""
An item that can have impl blocks, like a struct or enum.
"""
interface ImplOwner implements Item & Importable {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Importable
  importable_path: [ImportablePath!]
  canonical_path: Path

  # own edges
  """
  Any impl for this type.

  All impl kinds are included:
  - inherent impls: `impl Foo`
  - explicit trait implementations: `impl Bar for Foo`
  - blanket implementations: `impl<T> Bar for T`
  """
  impl: [Impl!]

  """
  Only inherent impls: implementations of the type itself (`impl Foo`).

  The impls pointed to here are guaranteed to have no `trait` and no `blanket` edges.

  This edge is just a convenience to simplify query-writing,
  so we don't have to keep writing "@fold @transform(...) @filter(...)" chains
  over the `trait` and `blanket` edges.

  When Trustfall supports macro edges, this should just become a macro edge.
  """
  inherent_impl: [Impl!]
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/struct.Impl.html
"""
type Impl implements Item {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  # stringified version of the visibility struct field
  visibility_limit: String!

  # own properties
  unsafe: Boolean!
  negative: Boolean!
  synthetic: Boolean!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # own edges

  """
  The trait being implemented. Inherent impls don't have a trait.

  TODO: implement me
  """
  implemented_trait: ImplementedTrait

  # """
  # The generic type across which the blanket trait implementation is made.

  # TODO: implement me
  # """
  # blanket: GenericType

  """
  Methods defined in this impl.
  """
  method: [Method!]

  """
  Constants associated with this type that are defined in this impl.
  """
  associated_constant: [AssociatedConstant!]
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/struct.Trait.html
"""
type Trait implements Item & Importable {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # own properties
  unsafe: Boolean!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Importable
  importable_path: [ImportablePath!]
  canonical_path: Path

  # own edges
  """
  Methods defined in this trait.
  """
  method: [Method!]

  """
  Traits whose implementation is a prerequisite for implementing this trait.
  """
  supertrait: [ImplementedTrait!]

  """
  Types associated with the implementation of this trait.

  For example: in the `Iterator` trait, `Iterator::Item` is an associated type.
  """
  associated_type: [AssociatedType!]

  """
  Constants associated with this type that are defined in this impl.
  """
  associated_constant: [AssociatedConstant!]
}

"""
A possible way that an item could be imported.
"""
type ImportablePath {
  """
  The visibility restriction on this importable path.

  For example: "public"
  """
  visibility_limit: String!

  """
  The path from which the item can be imported.

  For example: ["foo", "bar", "Baz"] for a type importable as foo::bar::Baz
  """
  path: [String!]!
}

"""
The fully-qualified path of an item including the full sequence of modules in which it is found.

For example, consider a struct `Quux` in `foo/bar/mod.rs`. Its canonical path is `"foo::bar::Quux"`,
even if `foo/mod.rs` might have a line like `pub use bar::Quux;`. The re-export is visible through
the struct's ImportablePath neighbors.
"""
type Path {
  path: [String!]!
}

"""
A function-like entity, like a function, function pointer, or method.

Combines:
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Header.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.FnDecl.html
"""
interface FunctionLike {
  const: Boolean!
  unsafe: Boolean!
  async: Boolean!

  # own edges
  parameter: [FunctionParameter!]
  abi: FunctionAbi!
}

"""
A function parameter.
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.FnDecl.html
"""
type FunctionParameter {
  name: String!
}

"""
The ABI of a function, method, or function pointer.

It defines the calling convention for those functions, including whether unwinding across
the call boundary is supported. More info: https://rust-lang.github.io/rfcs/2945-c-unwind-abi.html

The list of supported ABIs is here:
https://github.com/rust-lang/rust/blob/557359f92512ca88b62a602ebda291f17a953002/compiler/rustc_target/src/spec/abi.rs#L74-L110

Backed by:
https://docs.rs/rustdoc-types/latest/rustdoc_types/enum.Abi.html
"""
type FunctionAbi {
    """
    The name of the ABI, with any `"-unwind"` modifier stripped.

    To get the ABI name directly as it would appear in a Rust source file,
    use the `raw_name` property instead.

    For example, a function defined as `extern "C-unwind" fn example()` would
    have `name = "C"` and `raw_name = "C-unwind"`.

    Functions with no specified ABI by default have an ABI named `"Rust"`.
    """
    name: String!

    """
    The raw name of the ABI, as it would appear in a Rust source file.

    For example: "C-unwind" or "thiscall-unwind"

    Functions with no specified ABI by default have an ABI named `"Rust"`.
    """
    raw_name: String!

    """
    Whether unwinding across this call is supported.

    If encountering an unknown ABI, this value will be `null` due to unknown unwind semantics.

    Unwind ability is specified in rustc here:
    https://github.com/rust-lang/rust/blob/557359f92512ca88b62a602ebda291f17a953002/compiler/rustc_middle/src/ty/layout.rs#L1422-L1488

    More info: https://rust-lang.github.io/rfcs/2945-c-unwind-abi.html
    """
    unwind: Boolean
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Function.html
"""
type Function implements Item & FunctionLike & Importable {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # properties from FunctionLike
  const: Boolean!
  unsafe: Boolean!
  async: Boolean!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from FunctionLike
  parameter: [FunctionParameter!]
  abi: FunctionAbi!

  # edges from Importable
  importable_path: [ImportablePath!]
  canonical_path: Path
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Method.html
"""
type Method implements Item & FunctionLike {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # properties from FunctionLike
  const: Boolean!
  unsafe: Boolean!
  async: Boolean!

  # edge from Item
  span: Span
  attribute: [Attribute!]

  # edges from FunctionLike
  parameter: [FunctionParameter!]
  abi: FunctionAbi!
}

"""
Common supertype of `Constant` and `Static`.
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
"""
interface GlobalValue implements Item & Importable {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Importable
  importable_path: [ImportablePath!]
  canonical_path: Path
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/struct.Constant.html
"""
type Constant implements Item & Importable & GlobalValue {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # properties for Constant
  """
  The expression of the constant, if any, as a Rust literal or `"_"`. For example:
  ```rust
  //                                 // expr
  const MIN     : usize = 16       ; // 16
  const MIN_SIZE: usize = MIN      ; // "MIN", referring to the other constant's name
  const LOG_AS  : &str  = "batch"  ; // "\"batch\"", including escaped quotes
  const YEAR    : Years = Years(42); // "_"
  const EXPR_2_2: i32   = 2 + 2    ; // "_"
  const FN_FIVE : i32   = five()   ; // "_"
  const fn five() -> i32 { 5 };
  struct Years(i32);
  ```

  If the constant is set:

    - to be equal to another constant, `expr` holds the name of that other constant.
    - by evaluating a `const` expression, such as `2 + 2` or a `const fn` call, `expr` is `"_"` instead of including the full expression.
  """
  expr: String
  """
  The value of the constant, if any, as a Rust literal. For example:
  ```rust
  //                                 // value
  const MIN     : usize = 16       ; // "16usize"
  const MIN_SIZE: usize = MIN      ; // "16usize"
  const LOG_AS  : &str  = "batch"  ; // None
  const YEAR    : Years = Years(42); // None
  const EXPR_2_2: i32   = 2 + 2    ; // "4i32"
  const FN_FIVE : i32   = five()   ; // "5i32"
  const fn five() -> i32 { 5 };
  struct Years(i32);
  ```

  If the constant is set:

    - to be equal to another constant, `value` holds the value of that other constant.
    - by evaluating a `const` expression, such as `2 + 2` or a `const fn` call, `value` is evaluated
  """
  value: String
  """
  The literal flag of the constant. For example:
  ```rust
  //                                 // is_literal
  const MIN     : usize = 16       ; // true
  const MIN_SIZE: usize = MIN      ; // false
  const LOG_AS  : &str  = "batch"  ; // true
  const YEAR    : Years = Years(42); // false
  const EXPR_2_2: i32   = 2 + 2    ; // false
  const FN_FIVE : i32   = five()   ; // false
  const fn five() -> i32 { 5 };
  struct Years(i32);
  ```
  """
  is_literal: Boolean

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Importable
  importable_path: [ImportablePath!]
  canonical_path: Path
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/enum.ItemEnum.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/struct.Static.html
"""
type Static implements Item & Importable & GlobalValue {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # own properties
  mutable: Boolean!

  # edges from Item
  span: Span
  attribute: [Attribute!]

  # edges from Importable
  importable_path: [ImportablePath!]
  canonical_path: Path
}

"""
A specific attribute applied to an Item.
"""
type Attribute {
  """
  String representation of the attribute as it is found in the code.

  For example: `#[non_exhaustive]`
  """
  raw_attribute: String!

  """
  True for an inner attribute (starting with `#![`), and false for an
  outer one (starting with `#[`).

  For example: false for `#[non_exhaustive]`
  """
  is_inner: Boolean!

  # edges

  # Edge to parsed content of the attribute
  content: AttributeMetaItem!
}

"""
A single meta item used by a specific attribute
(see https://doc.rust-lang.org/reference/attributes.html#meta-item-attribute-syntax).
"""
type AttributeMetaItem {
  """
  The entire meta item represented as a string as it is found in the code.

  For example: `"derive(Debug, Clone)"`
  """
  raw_item: String!

  """
  SimplePath of the meta item.

  For example: `"derive"` for `derive(Debug, Clone)`,
               `"must_use"` for `must_use = "example_message"`
  """
  base: String!

  """
  Assigned item if the meta item is in the form `SimplePath = AssignedItem`.

  For example: `"\"example_message\""` for `must_use = "example_message"`
  """
  assigned_item: String

  # edges

  """
  Inner meta items if the meta item is in the form `SimplePath(MetaSeq)`.

  For example: `[AttributeMetaItem::new("Debug"), AttributeMetaItem::new("Clone")]`
  for `derive(Debug, Clone)`
  """
  argument: [AttributeMetaItem!]
}

"""
The trait that is being implemented in an impl block.

In `impl Foo<u64> for Bar`, this is the `Foo<u64>` part.
"""
type ImplementedTrait {
  name: String!

  # own edges
  """
  In `impl Foo<u64> for Bar`, this refers to `trait Foo<T>`.
  """
  trait: Trait
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/enum.ItemEnum.html#variant.AssocType
"""
type AssociatedType implements Item {
  # properties from Item
  id: String!
  crate_id: Int!

  """
  The name of the associated type.

  For example:
  ```rust
  trait Iterator {
      type Item;  // `"Item"` is the name of the associated type
  }
  ```
  """
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # properties for AssociatedType
  """
  Whether the type is defined to have a default value.

  For example:
  ```rust
  trait IntIterator {
      type Item = i64;  // by default, the associated type is `i64` so this property is `true`.
  }
  ```

  Associated type defaults are currently unstable: https://github.com/rust-lang/rust/issues/29661
  """
  has_default: Boolean!

  # edges from Item
  span: Span
  attribute: [Attribute!]
}

"""
https://docs.rs/rustdoc-types/0.11.0/rustdoc_types/struct.Item.html
https://docs.rs/rustdoc-types/latest/rustdoc_types/enum.ItemEnum.html#variant.AssocConst
"""
type AssociatedConstant implements Item {
  # properties from Item
  id: String!
  crate_id: Int!

  """
  The name of the associated constant.

  For example:
  ```rust
  trait BatchIterator {
    const SIZE: usize;  // `"SIZE"` is the name of the associated constant
  }
  ```
  """
  name: String
  docs: String
  attrs: [String!]!
  visibility_limit: String!

  # properties for AssociatedConstant
  """
  The default value of the constant, if any, as a Rust literal, expression, or `"_"`.

  For example:
  ```rust
  const fn five() -> i32 { 5 };
  struct Years(i32);
  trait MyTrait<const MIN: usize> {           // rustdocs default field
    const NUM     : i32          = 16       ; // 16
    const MIN_SIZE: usize        = MIN      ; // "MIN", referring to the other constant's name
    const LOG_AS  : &'static str = "batch"  ; // "\"batch\"", including escaped quotes
    const EXPR2_2 : i32          = 2+2      ; // "_"
    const FN_FIVE : i32          = five()   ; // "_"
    const YEAR    : Years        = Years(42); // "_"
  }
  ```

  If the associated constant is on a type's inherent impl, `default` is always required to be set.

  If the associated constant is set:

    - to be equal to another constant, `default` holds the name of that other constant.
    - by evaluating a `const` expression, such as `2 + 2` or a `const fn` call,
      `default` is `"_"` instead of evaluating the constant value or including the full expression.
  """
  default: String

  # edges from Item
  span: Span
  attribute: [Attribute!]
}

"""
A type represented in the "raw" rustdoc JSON representation.

Copiously detailed, but not the easiest to use due to its complexity.

This interface is a temporary, perma-unstable type intended to be used
only until the rustdoc JSON format is stabilized and until subsequently
we are able to design a better, more permanent representation for
Rust types in this schema.

https://docs.rs/rustdoc-types/latest/rustdoc_types/enum.Type.html
"""
interface RawType {
  name: String!
}

"""
Represents a struct, enum, or trait.

https://docs.rs/rustdoc-types/latest/rustdoc_types/enum.Type.html#variant.ResolvedPath
"""
type ResolvedPathType implements RawType {
  """
  The fully-qualified canonical name of the type.

  For example: "core::marker::PhantomData" or "std::marker::PhantomData"
  """
  name: String!
}