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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

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

  attribute: [Attribute!]
  span: Span
}

"""
An item that can have generic parameters.
"""
interface GenericItem implements 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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

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

  attribute: [Attribute!]
  span: Span

  """
  Generic type, lifetime, or const parameters by which this item is parameterized.
  """
  generic_parameter: [GenericParameter]
}

"""
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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  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 & GenericItem {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  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!]

  # edges from GenericItem
  """
  Generic type, lifetime, or const parameters by which this struct is parameterized.
  """
  generic_parameter: [GenericParameter]

  # 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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  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 & GenericItem {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  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!]

  # edges from GenericItem
  """
  Generic type, lifetime, or const parameters by which this enum is parameterized.
  """
  generic_parameter: [GenericParameter]

  # 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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

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

  # own edges
  field: [StructField!]

  """
  The discriminant value of this variant, if its value is well-defined.

  A discriminant is an integer value that is logically associated with an enum variant,
  and is used to determine which variant an enum value holds.

  Discriminant values are not always well-defined.

  In order for variants to have well-defined discriminants, their enum must either
  - define a primitive representation (e.g., `#[repr(u8)]`), or
  - be "unit-only" i.e. consisting solely of unit variants.

  The variants of such enums may be explicitly assigned a discriminant value, or
  the discriminant may be defined implicitly:
  - The first variant has a discriminant of zero, unless explicitly assigned a value.
  - Subsequent variants have a discriminant one higher than the previous variant,
    unless explicitly assigned a value.
  """
  discriminant: Discriminant
}

"""
https://docs.rs/rustdoc-types/0.28.0/rustdoc_types/struct.Discriminant.html
https://doc.rust-lang.org/reference/items/enumerations.html
"""
type Discriminant {
  """
  The numerical value of the discriminant. Stored as a string. Ranges from `i128::MIN` to `u128::MAX`.
  """
  value: String!
}

"""
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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

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

  # edges from Variant
  field: [StructField!]

  """
  The discriminant value of this variant, if its value is well-defined.

  A discriminant is an integer value that is logically associated with an enum variant,
  and is used to determine which variant an enum value holds.

  Discriminant values are not always well-defined.

  In order for variants to have well-defined discriminants, their enum must either
  - define a primitive representation (e.g., `#[repr(u8)]`), or
  - be "unit-only" i.e. consisting solely of unit variants.

  The variants of such enums may be explicitly assigned a discriminant value, or
  the discriminant may be defined implicitly:
  - The first variant has a discriminant of zero, unless explicitly assigned a value.
  - Subsequent variants have a discriminant one higher than the previous variant,
    unless explicitly assigned a value.
  """
  discriminant: Discriminant
}

"""
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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

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

  # edges from Variant
  field: [StructField!]

  """
  The discriminant value of this variant, if its value is well-defined.

  A discriminant is an integer value that is logically associated with an enum variant,
  and is used to determine which variant an enum value holds.

  Discriminant values are not always well-defined.

  In order for variants to have well-defined discriminants, their enum must either
  - define a primitive representation (e.g., `#[repr(u8)]`), or
  - be "unit-only" i.e. consisting solely of unit variants.

  The variants of such enums may be explicitly assigned a discriminant value, or
  the discriminant may be defined implicitly:
  - The first variant has a discriminant of zero, unless explicitly assigned a value.
  - Subsequent variants have a discriminant one higher than the previous variant,
    unless explicitly assigned a value.
  """
  discriminant: Discriminant
}

"""
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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

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

  # edges from Variant
  field: [StructField!]

  """
  The discriminant value of this variant, if its value is well-defined.

  A discriminant is an integer value that is logically associated with an enum variant,
  and is used to determine which variant an enum value holds.

  Discriminant values are not always well-defined.

  In order for variants to have well-defined discriminants, their enum must either
  - define a primitive representation (e.g., `#[repr(u8)]`), or
  - be "unit-only" i.e. consisting solely of unit variants.

  The variants of such enums may be explicitly assigned a discriminant value, or
  the discriminant may be defined implicitly:
  - The first variant has a discriminant of zero, unless explicitly assigned a value.
  - Subsequent variants have a discriminant one higher than the previous variant,
    unless explicitly assigned a value.
  """
  discriminant: Discriminant
}

"""
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.Union.html
"""
type Union implements Item & Importable & ImplOwner & GenericItem {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

  # own properties
  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!]

  # edges from GenericItem
  """
  Generic type, lifetime, or const parameters by which this union is parameterized.
  """
  generic_parameter: [GenericParameter]

  # own edges
  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 & GenericItem {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

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

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

  # edges from GenericItem
  """
  Generic type, lifetime, or const parameters by which this item is parameterized.
  """
  generic_parameter: [GenericParameter]

  # 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 & GenericItem {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  # 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!]

  # edges from GenericItem
  """
  Generic type, lifetime, or const parameters by which this impl is parameterized.
  """
  generic_parameter: [GenericParameter]

  # own edges
  """
  The trait being implemented. Inherent impls don't have a trait.
  """
  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 & GenericItem {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

  # own properties
  """
  Whether this trait is defined as `unsafe` and requires the `unsafe` keyword when implementing.
  """
  unsafe: Boolean!

  """
  Whether this trait can be used as `dyn Trait`.
  """
  object_safe: Boolean!

  """
  Whether downstream crates are prevented from implementing this trait themselves.

  Required implementation items can be added to sealed traits without causing a breaking change,
  since no implementations of that trait may exist in other crates.
  """
  sealed: Boolean!

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

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

  # edges from GenericItem
  """
  Generic type, lifetime, or const parameters by which this trait is parameterized.
  """
  generic_parameter: [GenericParameter]

  # 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!

  """
  This path is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This path is deprecated.
  """
  deprecated: Boolean!

  """
  This path should be treated as public API. This is true if either:
  - The path is visible in documentation.
  - The path is not visible and is deprecated,
    since deprecated paths are assumed to have been part of the public API in the past.
  """
  public_api: Boolean!

  """
  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!
  has_body: Boolean!
  """
  Stringified representation of the function's signature, as close to the
  original source code as possible.  May not preserve whitespace, constant
  expressions in types, or path names, but the output will be semantically
  equivalent to the original.
  """
  signature: String!

  # 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 & GenericItem {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

  # properties from FunctionLike
  const: Boolean!
  unsafe: Boolean!
  async: Boolean!
  has_body: Boolean!
  """
  Stringified representation of the function's signature, as close to the
  original source code as possible.  May not preserve whitespace, constant
  expressions in types, or path names, but the output will be semantically
  equivalent to the original.
  """
  signature: String!

  # own properties
  """
  The unmangled or explicitly-specified export name of this item, if any.

  Export names are defined using the `#[export_name]` or `#[no_mangle]` attributes.

  For example:
  - The following function has `export_name = "example"`:
    ```rust
    #[no_mangle]
    extern "C" fn example() {}
    ```
  - The following function has `export_name = "other"`:
    ```rust
    #[export_name = "other"]
    extern "C" fn example() {}
    ```

  More info:
  https://doc.rust-lang.org/reference/abi.html#the-no_mangle-attribute
  https://doc.rust-lang.org/reference/abi.html#the-export_name-attribute
  """
  export_name: String

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

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

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

  # edges from GenericItem
  """
  Generic type, lifetime, or const parameters by which this function is parameterized.
  """
  generic_parameter: [GenericParameter]
}

"""
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 & GenericItem {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

  # properties from FunctionLike
  const: Boolean!
  unsafe: Boolean!
  async: Boolean!
  has_body: Boolean!
  """
  Stringified representation of the function's signature, as close to the
  original source code as possible.  May not preserve whitespace, constant
  expressions in types, or path names, but the output will be semantically
  equivalent to the original.
  """
  signature: String!

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

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

  # edges from GenericItem
  """
  Generic type, lifetime, or const parameters by which this method is parameterized.

  This only includes the *method's own* generic parameters. It does not include
  any generic parameters that may be part of the definition of the type that owns the method.
  """
  generic_parameter: [GenericParameter]
}

"""
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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  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 {
  """
  The name of the trait being implemented, without any generic parameters. Just the name.

  In `impl Foo<u64> for Bar`, this is `"Foo"`.
  """
  bare_name: String!

  """
  Deprecated alias of `bare_name`.

  The name of the trait being implemented.

  In `impl Foo<u64> for Bar`, this is `"Foo"`.
  """
  name: String! @deprecated(reason: "Renamed to `bare_name`, please use that instead.")

  """
  The trait being implemented together with any generic parameters.

  In `impl Foo<u64> for Bar`, this is `"Foo<u64>"`.
  """
  instantiated_name: String!

  """
  The item identifier of the trait being implemented here.

  Useful in case the trait's definition isn't available for querying, for example
  if the trait is located in a different crate than the currently-queried one.
  In such a case, there won't be any instances of the `trait` edge, but this ID
  will make it possible to look up more information on the trait regardless.
  """
  trait_id: String!

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

  Currently, item information for items from a foreign crate is not generally available,
  so if the trait is defined in a different crate then this edge won't have any instances.

  Even the `std` and `core` built-in crates are considered foreign.
  However, a limited number of common built-in Rust traits have their definitions hard-coded
  into our adapter and their information will be available for inspection.
  The set of such traits will include, at minimum:
  `Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash, Sized, Send, Sync, Unpin, UnwindSafe,
  RefUnwindSafe`.
  """
  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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  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!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  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 `macro_rules` declarative macro.

When such macros are exported by a crate, they are always exported at the top level of the crate,
even if the macro's definition is located inside a `mod`. In essence, the `#[macro_export]`
attribute behaves as a `pub use` of the macro into the crate's root module.

This is why we don't model macro items as `Importable`:
- They always have only one importable path: `the_crate::macro_name`.
- Their names are in their own namespace, and do not mix with the types or values namespaces.
"""
type Macro implements Item {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

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

"""
A procedural macro. Unlike declarative macros (`Macro`), expanding these macros runs Rust code.

There are multiple kinds of procedural macros.
More info: https://doc.rust-lang.org/reference/procedural-macros.html

When such macros are exported by a crate, they are always exported at the top level of the crate.

This is why we don't model macro items as `Importable`:
- They always have only one importable path: `the_crate::macro_name`.
- Their names are in their own namespace, and do not mix with the types or values namespaces.
"""
interface ProcMacro implements Item {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

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

"""
A proc macro meant to be used as `my_macro!();`.

More info:
https://doc.rust-lang.org/reference/procedural-macros.html#function-like-procedural-macros

When such macros are exported by a crate, they are always exported at the top level of the crate.

This is why we don't model macro items as `Importable`:
- They always have only one importable path: `the_crate::macro_name`.
- Their names are in their own namespace, and do not mix with the types or values namespaces.
"""
type FunctionLikeProcMacro implements Item & ProcMacro {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

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

"""
A proc macro meant to be used as `#[item_attribute]`.

More info: https://doc.rust-lang.org/reference/procedural-macros.html#attribute-macros

When such macros are exported by a crate, they are always exported at the top level of the crate.

This is why we don't model macro items as `Importable`:
- They always have only one importable path: `the_crate::macro_name`.
- Their names are in their own namespace, and do not mix with the types or values namespaces.
"""
type AttributeProcMacro implements Item & ProcMacro {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

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

"""
A proc macro meant to be used as a `#[derive(MyMacro)]`.

More info: https://doc.rust-lang.org/reference/procedural-macros.html#derive-macros

When such macros are exported by a crate, they are always exported at the top level of the crate.

This is why we don't model macro items as `Importable`:
- They always have only one importable path: `the_crate::MacroName`.
- Their names are in their own namespace, and do not mix with the types or values namespaces.
"""
type DeriveProcMacro implements Item & ProcMacro {
  # properties from Item
  id: String!
  crate_id: Int!
  name: String
  docs: String
  attrs: [String!]!

  """
  This item is hidden in documentation.
  """
  doc_hidden: Boolean!

  """
  This item is deprecated.
  """
  deprecated: Boolean!

  """
  Whether this item is eligible to be in the public API. This is true if both:
  - The item is public, either explicitly (`pub`) or implicitly (like enum variants).
  - The item is visible in documentation, or is not visible but is deprecated,
    since deprecated items are assumed to have been part of the public API in the past.

  Being eligible to be part of the public API *does not* make an item public API!
  An item that is not eligible by itself cannot be part of the public API,
  but eligible items might not be public API -- for example, pub-in-priv items
  (public items in a private module) are eligible but not public API. Another example
  would be a public item that is only reachable via modules that are both
  `#[doc(hidden)]` and not deprecated.

  To check whether an item is part of the public API:
  - For items that are legal in a `use` import statement, use the `importable_path` edge and the
    path's `public_api` property.
  - For all other items (e.g. struct fields), first check whether that parent item is public API
    as above, and then check whether the item itself is `public_api_eligible`.
  """
  public_api_eligible: Boolean!

  visibility_limit: String!

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

  # own edges
  """
  Any additional helper attributes defined by this macro.
  """
  helper_attribute: [DeriveMacroHelperAttribute]
}

"""
Derive proc macros may add additional attributes into the scope of the item where they are applied.
Such additional attributes are called "derive macro helper attributes" and their only purpose is to
be read by the derive proc macro.

More info: https://doc.rust-lang.org/reference/procedural-macros.html#derive-macro-helper-attributes
"""
type DeriveMacroHelperAttribute {
  """
  The name of the helper attribute.
  """
  name: String!
}

interface GenericParameter {
  """
  The name of the generic parameter.

  For example:
  - `"T"` as a generic type
  - `"'a"` as a generic lifetime
  - `"N"` as a generic constant
  """
  name: String!
}

type GenericTypeParameter implements GenericParameter {
  # properties from GenericParameter
  """
  The name of the generic parameter.

  For example:
  - `"T"` as a generic type
  - `"'a"` as a generic lifetime
  - `"N"` as a generic constant
  """
  name: String!

  """
  Whether the generic type parameter has a default value.
  """
  has_default: Boolean!

  """
  Whether the type parameter is synthetic.

  This is normally `false`, which means that this generic parameter is
  declared in the Rust source text.

  If it is `true`, this generic parameter has been introduced by the
  compiler behind the scenes, for example in `impl Trait` uses:
  `fn f(_: impl Trait) {}` is transformed by the compiler into (pseudo-Rust)
  `fn f<impl Trait: Trait>(_: impl Trait) {}`. In this example,
  the generic parameter named `impl Trait` is synthetic because
  it was not originally in the Rust source text.
  """
  synthetic: Boolean!

  # own edges
  """
  Type bounds applied specifically to this generic type parameter.

  For example:
  - For `<T: Clone + PartialEq<i64>>`, this edge would have two instances
    pointing to each of `Clone` and `PartialEq<i64>`.
  - For `impl Trait<'a, T, i64>`, this edge would point to `Trait<'a, T, i64>`.

  Bounds involving this type parameter but not specifically applying to it are not included.
  For example, for type parameter `T`, a bound like `Arc<T>: Clone` wouldn't be included here.
  """
  type_bound: [ImplementedTrait!]

  # TODO: needs lifetime bounds
  # lifetime_bound: ?
}

type GenericLifetimeParameter implements GenericParameter {
  # properties from GenericParameter
  """
  The name of the generic parameter.

  For example:
  - `"T"` as a generic type
  - `"'a"` as a generic lifetime
  - `"N"` as a generic constant
  """
  name: String!

  # own edges
  # TODO: needs lifetime bounds
  # lifetime_bound: ?
}

type GenericConstParameter implements GenericParameter {
  # properties from GenericParameter
  """
  The name of the generic parameter.

  For example:
  - `"T"` as a generic type
  - `"'a"` as a generic lifetime
  - `"N"` as a generic constant
  """
  name: String!

  """
  Whether the generic const parameter has a default value.
  """
  has_default: Boolean!

  # own edges
  # TODO: needs type and value
}

"""
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!
}