## Show schema
```console
$ cargo-indicate --show-schema
? success
# This is not truly a GraphQL file; Instead it is a GraphQL representation of
# the types provided by `indicate`.

# _This is the single source of truth for `indicate`. Any deviation from it is
# to be considered a bug._

# This is the currently supported Trustfall directives. They are handled by the
# Trustfall engine.
schema {
    query: RootQuery
}
directive @filter(
    """
    Name of the filter operation to perform.
    """
    op: String!
    """
    List of string operands for the operator.
    """
    value: [String!]
) on FIELD | INLINE_FRAGMENT
directive @tag(
    """
    Name to apply to the given property field.
    """
    name: String
) on FIELD
directive @output(
    """
    What to designate the output field generated from this property field.
    """
    name: String
) on FIELD
directive @optional on FIELD
directive @recurse(
    """
    Recurse up to this many times on this edge. A depth of 1 produces the
    current vertex and its immediate neighbors along the given edge.
    """
    depth: Int!
) on FIELD
directive @fold on FIELD
directive @transform(
    """
    Name of the transformation operation to perform.
    """
    op: String!
) on FIELD

"""
This is the actual types that can be used to create queries.
"""

type RootQuery {
    RootPackage: Package!
    Dependencies(includeRoot: Boolean!): [Package!]!

    """
    Dependencies that are indirect dependencies of the root package;
    excluding direct dependencies that are _only_ direct dependencies, and
    appear nowhere else in the dependency tree
    """
    TransitiveDependencies: [Package!]!
}

# See `cargo_metadata::Package`
type Package {
    id: ID!,
    name: String!,
    version: String!,
    license: String
    keywords: [String!]!
    categories: [String!]!
    manifestPath: String!
    sourcePath: String!

    # This is expensive, due to crates.io crawler policy
    cratesIo: CratesIoStats!

    repository: Webpage

    # All parameters except `ignorePaths` is exactly the same as `tokei::Config`
    codeStats(
        # If any patterns should be ignored, defaults to an empty list.
        ignoredPaths: [String!],
        # To target only some patterns. Defaults to all. If used,
        # `ignoredPaths` is still applied
        includedPaths: [String!],
        hidden: Boolean,
        noIgnore: Boolean,
        noIgnoreParent: Boolean,
        noIgnoreDot: Boolean,
        noIgnoreVcs: Boolean,
        treatDocStringsAsComments: Boolean,
        types: [String!] # Types of languages to be included in report
    ): [LanguageCodeStats!]!
    dependencies: [Package!]!
    
    # For arch and OS, see `platforms::target`
    # For severity, see `rustsec::advisory::Severity`
    advisoryHistory(
        includeWithdrawn: Boolean!,
        arch: String,
        os: String,
        minSeverity: String
    ): [Advisory!]!
    geiger: GeigerUnsafety
}

type CratesIoStats {
    totalDownloads: Int
    recentDownloads: Int
    versionDownloads: Int
    versionsCount: Int
    yanked: Boolean # If this version is yanked from crates.io
    yankedVersions: [String!]
    yankedVersionsCount: Int
    yankedRatio: Float # yanked versions count / versions count
}

# Data from tokei, shared between `Language` and `CodeStats`
interface CodeStats {
    # Name of the language
    language: String!
    # Total number of files
    files: Int!
    # Total number of lines
    lines: Int!
    # Total number of blank lines
    blanks: Int!
    # Total number of lines of code
    code: Int!
    # Number of lines of comments
    comments: Int!
    # Lines of comments / lines of code
    commentsToCode: Float!
}

# `tokei::Language`
type LanguageCodeStats implements CodeStats {
    # From CodeStats
    language: String!
    files: Int!
    lines: Int!
    blanks: Int!
    code: Int!
    comments: Int!
    commentsToCode: Float!

    # From `tokei::Languge::summarize()`
    summary: LanguageCodeStats!
    
    # If this language had problem with parsing
    inaccurate: Boolean!

    # Code contained in this
    children: [LanguageBlob!]!
}

# `tokei::CodeStats.blobs`
type LanguageBlob implements CodeStats {
    # From CodeStats
    language: String!
    files: Int!
    lines: Int!
    blanks: Int!
    code: Int!
    comments: Int!
    commentsToCode: Float!

    # Merge this with all child blobs to create new `CodeStats`
    # (`tokei::CodeStats::summarize()`)
    summary: LanguageBlob!

    # Blobs of code contained within this one
    blobs: [LanguageBlob!]!
}

type GeigerUnsafety {
    # `used` refers to code used by the `RootPackage`
    used: GeigerCategories!
    unused: GeigerCategories!

    # used + unused
    total: GeigerCategories!
    forbidsUnsafe: Boolean!
}

type GeigerCategories {
    functions: GeigerCount!
    exprs: GeigerCount!
    item_impls: GeigerCount!
    item_traits: GeigerCount!
    methods: GeigerCount!

    # (functions.safe + exprs.safe + ...), (functions.unsafe + ...)
    total: GeigerCount!
}

type GeigerCount {
    safe: Int!
    unsafe: Int!
    
    # safe + unsafe
    total: Int!
    percentageUnsafe: Float!
}

interface Webpage {
    url: String!
}

interface Repository implements Webpage {
    url: String!
}

type GitHubRepository implements Repository & Webpage {
    # From Repository and Webpage
    url: String!

    owner: GitHubUser
    name: String!
    
    starsCount: Int!
    forksCount: Int!

    # This is the sum of open issues and open PRs
    openIssuesCount: Int!
    watchersCount: Int!
    
    # If the issues page is available for this repository
    hasIssues: Boolean!
    archived: Boolean!
    
    # If this is a fork
    fork: Boolean!
}

type GitHubUser {
    username: String!
    email: String!
    unixCreatedAt: Int
    followersCount: Int!
}

# Partly flattened `rustsec::advisory::Advisory`
type Advisory {
    # These fields are flattened out of `rustsec::advisory::Metadata`

    id: String!
    title: String!
    description: String!
    unixDateReported: Int!
    severity: String
    
    # These are provided by `rustsec::advisory::Affected`
    # They may be empty, so a `None` means that we do not know
    affectedArch: [String!]
    affectedOs: [String!]
    affectedFunctions: [AffectedFunctionVersions!]
    
    # These are provided by `rustsec::advisory::Versions`
    patchedVersions: [String!]!
    unaffectedVersions: [String!]!
    
    # If it was reported in error, this will indicate when it was withdrawn
    unixDateWithdrawn: Int
    #cvss: CvssBase # TODO: Add when Trustfall supports enums
}

# `Map<FunctionPath, Vec<VersionReq>>` from `rustsec::advisory::Affected`
type AffectedFunctionVersions {
    functionPath: String!
    versions: [String!]!
}


```