# Generated by `rake schema_artifacts:dump`.
# DO NOT EDIT BY HAND. Any edits will be lost the next time the rake task is run.

"""
Indicates an upper bound on how quickly a query must respond to meet the service-level objective.
ElasticGraph will log a "good event" message if the query latency is less than or equal to this value,
and a "bad event" message if the query latency is greater than this value. These messages can be used
to drive an SLO dashboard.

Note that the latency compared against this only contains processing time within ElasticGraph itself.
Any time spent on sending the request or response over the network is not included in the comparison.
"""
directive @egLatencySlo(ms: Int!) on QUERY

"""
Provides detail about an aggregation `count`.
"""
type AggregationCountDetail {
  """
  The (approximate) count of documents in this aggregation bucket.

  When documents in an aggregation bucket are sourced from multiple shards, the count may be only
  approximate. The `upperBound` indicates the maximum value of the true count, but usually
  the true count is much closer to this approximate value (which also provides a lower bound on the
  true count).

  When this approximation is known to be exact, the same value will be available from `exactValue`
  and `upperBound`.
  """
  approximateValue: JsonSafeLong!

  """
  The exact count of documents in this aggregation bucket, if an exact value can be determined.

  When documents in an aggregation bucket are sourced from multiple shards, it may not be possible to
  efficiently determine an exact value. When no exact value can be determined, this field will be `null`.
  The `approximateValue` field--which will never be `null`--can be used to get an approximation
  for the count.
  """
  exactValue: JsonSafeLong

  """
  An upper bound on how large the true count of documents in this aggregation bucket could be.

  When documents in an aggregation bucket are sourced from multiple shards, it may not be possible to
  efficiently determine an exact value. The `approximateValue` field provides an approximation,
  and this field puts an upper bound on the true count.
  """
  upperBound: JsonSafeLong!
}

type Album {
  name: String
  releasedOn: Date
}

"""
Type used to perform aggregation computations on `Album` fields.
"""
type AlbumAggregatedValues {
  """
  Computed aggregate values for the `name` field.
  """
  name: NonNumericAggregatedValues

  """
  Computed aggregate values for the `releasedOn` field.
  """
  releasedOn: DateAggregatedValues
}

"""
Input type used to specify filters on `Album` fields.

Will match all documents if passed as an empty object (or as `null`).
"""
input AlbumFilterInput {
  """
  Matches records where all of the provided sub-filters evaluate to true. This works just like an AND operator in SQL.

  Note: multiple filters are automatically ANDed together. This is only needed when you have multiple filters that can't
  be provided on a single `AlbumFilterInput` input because of collisions between
  key names. For example, if you want to AND multiple
  OR'd sub-filters (the equivalent of (A OR B) AND (C OR D)), you could do allOf: [{anyOf: [...]}, {anyOf: [...]}].

  When `null` or an empty list is passed, matches all documents.
  """
  allOf: [AlbumFilterInput!]

  """
  Matches records where any of the provided sub-filters evaluate to true.
  This works just like an OR operator in SQL.

  When `null` is passed, matches all documents.
  When an empty list is passed, this part of the filter matches no documents.
  """
  anyOf: [AlbumFilterInput!]

  """
  Used to filter on the `name` field.

  When `null` or an empty object is passed, matches all documents.
  """
  name: StringFilterInput

  """
  Matches records where the provided sub-filter evaluates to false.
  This works just like a NOT operator in SQL.

  When `null` or an empty object is passed, matches no documents.
  """
  not: AlbumFilterInput

  """
  Used to filter on the `releasedOn` field.

  When `null` or an empty object is passed, matches all documents.
  """
  releasedOn: DateFilterInput
}

"""
Type used to specify the `Album` fields to group by for aggregations.
"""
type AlbumGroupedBy {
  """
  The `name` field value for this group.
  """
  name: String

  """
  Offers the different grouping options for the `releasedOn` value within this group.
  """
  releasedOn: DateGroupedBy
}

"""
Input type used to specify filters on `[Album]` fields.

Will match all documents if passed as an empty object (or as `null`).
"""
input AlbumListFilterInput {
  """
  Matches records where all of the provided sub-filters evaluate to true. This works just like an AND operator in SQL.

  Note: multiple filters are automatically ANDed together. This is only needed when you have multiple filters that can't
  be provided on a single `AlbumListFilterInput` input because of collisions
  between key names. For example, if you want to AND multiple
  OR'd sub-filters (the equivalent of (A OR B) AND (C OR D)), you could do allOf: [{anyOf: [...]}, {anyOf: [...]}].

  When `null` or an empty list is passed, matches all documents.
  """
  allOf: [AlbumListFilterInput!]

  """
  Matches records where any of the provided sub-filters evaluate to true.
  This works just like an OR operator in SQL.

  When `null` is passed, matches all documents.
  When an empty list is passed, this part of the filter matches no documents.
  """
  anyOf: [AlbumListFilterInput!]

  """
  Matches records where any of the list elements match the provided sub-filter.

  When `null` or an empty object is passed, matches all documents.
  """
  anySatisfy: AlbumFilterInput

  """
  Used to filter on the number of non-null elements in this list field.

  When `null` or an empty object is passed, matches all documents.
  """
  count: IntFilterInput

  """
  Matches records where the provided sub-filter evaluates to false.
  This works just like a NOT operator in SQL.

  When `null` or an empty object is passed, matches no documents.
  """
  not: AlbumListFilterInput
}

type Artist {
  albums: [Album!]!
  id: ID
  lifetimeSales: JsonSafeLong
  name: String
}

"""
Type used to perform aggregation computations on `Artist` fields.
"""
type ArtistAggregatedValues {
  """
  Computed aggregate values for the `id` field.
  """
  id: NonNumericAggregatedValues

  """
  Computed aggregate values for the `lifetimeSales` field.
  """
  lifetimeSales: JsonSafeLongAggregatedValues

  """
  Computed aggregate values for the `name` field.
  """
  name: NonNumericAggregatedValues
}

"""
Return type representing a bucket of `Artist` documents for an aggregations query.
"""
type ArtistAggregation {
  """
  Provides computed aggregated values over all `Artist` documents in an aggregation bucket.
  """
  aggregatedValues: ArtistAggregatedValues

  """
  The count of `Artist` documents in an aggregation bucket.
  """
  count: JsonSafeLong!

  """
  Used to specify the `Artist` fields to group by. The returned values identify each aggregation bucket.
  """
  groupedBy: ArtistGroupedBy

  """
  Used to perform sub-aggregations of `ArtistAggregation` data.
  """
  subAggregations: ArtistAggregationSubAggregations
}

"""
Represents a paginated collection of `ArtistAggregation` results.

See the [Relay GraphQL Cursor Connections
Specification](https://relay.dev/graphql/connections.htm#sec-Connection-Types) for more info.
"""
type ArtistAggregationConnection {
  """
  Wraps a specific `ArtistAggregation` to pair it with its pagination cursor.
  """
  edges: [ArtistAggregationEdge!]!

  """
  The list of `ArtistAggregation` results.
  """
  nodes: [ArtistAggregation!]!

  """
  Provides pagination-related information.
  """
  pageInfo: PageInfo!
}

"""
Represents a specific `ArtistAggregation` in the context of a `ArtistAggregationConnection`,
providing access to both the `ArtistAggregation` and a pagination `Cursor`.

See the [Relay GraphQL Cursor Connections
Specification](https://relay.dev/graphql/connections.htm#sec-Edge-Types) for more info.
"""
type ArtistAggregationEdge {
  """
  The `Cursor` of this `ArtistAggregation`. This can be passed in the next query as
  a `before` or `after` argument to continue paginating from this `ArtistAggregation`.
  """
  cursor: Cursor

  """
  The `ArtistAggregation` of this edge.
  """
  node: ArtistAggregation
}

"""
Provides access to the `subAggregations` within each `ArtistAggregation`.
"""
type ArtistAggregationSubAggregations {
  """
  Used to perform a sub-aggregation of `albums`.
  """
  albums(
    """
    Used to filter the `Album` documents included in this sub-aggregation based on the provided criteria.
    """
    filter: AlbumFilterInput

    """
    Determines how many sub-aggregation buckets should be returned.
    """
    first: Int
  ): ArtistAlbumSubAggregationConnection
}

"""
Return type representing a bucket of `Album` objects for a sub-aggregation within each `ArtistAggregation`.
"""
type ArtistAlbumSubAggregation {
  """
  Provides computed aggregated values over all `Album` documents in a sub-aggregation bucket.
  """
  aggregatedValues: AlbumAggregatedValues

  """
  Details of the count of `Album` documents in a sub-aggregation bucket.
  """
  countDetail: AggregationCountDetail

  """
  Used to specify the `Album` fields to group by. The returned values identify each sub-aggregation bucket.
  """
  groupedBy: AlbumGroupedBy
}

"""
Represents a collection of `ArtistAlbumSubAggregation` results.
"""
type ArtistAlbumSubAggregationConnection {
  """
  The list of `ArtistAlbumSubAggregation` results.
  """
  nodes: [ArtistAlbumSubAggregation!]!

  """
  Provides pagination-related information.
  """
  pageInfo: PageInfo!
}

"""
Represents a paginated collection of `Artist` results.

See the [Relay GraphQL Cursor Connections
Specification](https://relay.dev/graphql/connections.htm#sec-Connection-Types) for more info.
"""
type ArtistConnection {
  """
  Wraps a specific `Artist` to pair it with its pagination cursor.
  """
  edges: [ArtistEdge!]!

  """
  The list of `Artist` results.
  """
  nodes: [Artist!]!

  """
  Provides pagination-related information.
  """
  pageInfo: PageInfo!

  """
  The total number of edges available in this connection to paginate over.
  """
  totalEdgeCount: JsonSafeLong!
}

"""
Represents a specific `Artist` in the context of a `ArtistConnection`,
providing access to both the `Artist` and a pagination `Cursor`.

See the [Relay GraphQL Cursor Connections
Specification](https://relay.dev/graphql/connections.htm#sec-Edge-Types) for more info.
"""
type ArtistEdge {
  """
  The `Cursor` of this `Artist`. This can be passed in the next query as
  a `before` or `after` argument to continue paginating from this `Artist`.
  """
  cursor: Cursor

  """
  The `Artist` of this edge.
  """
  node: Artist
}

"""
Input type used to specify filters on `Artist` fields.

Will match all documents if passed as an empty object (or as `null`).
"""
input ArtistFilterInput {
  """
  Used to filter on the `albums` field.

  When `null` or an empty object is passed, matches all documents.
  """
  albums: AlbumListFilterInput

  """
  Matches records where all of the provided sub-filters evaluate to true. This works just like an AND operator in SQL.

  Note: multiple filters are automatically ANDed together. This is only needed when you have multiple filters that can't
  be provided on a single `ArtistFilterInput` input because of collisions
  between key names. For example, if you want to AND multiple
  OR'd sub-filters (the equivalent of (A OR B) AND (C OR D)), you could do allOf: [{anyOf: [...]}, {anyOf: [...]}].

  When `null` or an empty list is passed, matches all documents.
  """
  allOf: [ArtistFilterInput!]

  """
  Matches records where any of the provided sub-filters evaluate to true.
  This works just like an OR operator in SQL.

  When `null` is passed, matches all documents.
  When an empty list is passed, this part of the filter matches no documents.
  """
  anyOf: [ArtistFilterInput!]

  """
  Used to filter on the `id` field.

  When `null` or an empty object is passed, matches all documents.
  """
  id: IDFilterInput

  """
  Used to filter on the `lifetimeSales` field.

  When `null` or an empty object is passed, matches all documents.
  """
  lifetimeSales: JsonSafeLongFilterInput

  """
  Used to filter on the `name` field.

  When `null` or an empty object is passed, matches all documents.
  """
  name: StringFilterInput

  """
  Matches records where the provided sub-filter evaluates to false.
  This works just like a NOT operator in SQL.

  When `null` or an empty object is passed, matches no documents.
  """
  not: ArtistFilterInput
}

"""
Type used to specify the `Artist` fields to group by for aggregations.
"""
type ArtistGroupedBy {
  """
  The `lifetimeSales` field value for this group.
  """
  lifetimeSales: JsonSafeLong

  """
  The `name` field value for this group.
  """
  name: String
}

"""
Enumerates the ways `Artist`s can be sorted.
"""
enum ArtistSortOrderInput {
  """
  Sorts ascending by the `id` field.
  """
  id_ASC

  """
  Sorts descending by the `id` field.
  """
  id_DESC

  """
  Sorts ascending by the `lifetimeSales` field.
  """
  lifetimeSales_ASC

  """
  Sorts descending by the `lifetimeSales` field.
  """
  lifetimeSales_DESC

  """
  Sorts ascending by the `name` field.
  """
  name_ASC

  """
  Sorts descending by the `name` field.
  """
  name_DESC
}

"""
An opaque string value representing a specific location in a paginated connection type.
Returned cursors can be passed back in the next query via the `before` or `after`
arguments to continue paginating from that point.
"""
scalar Cursor

"""
A date, represented as an [ISO 8601 date string](https://en.wikipedia.org/wiki/ISO_8601).
"""
scalar Date

"""
A return type used from aggregations to provided aggregated values over `Date` fields.
"""
type DateAggregatedValues {
  """
  The average (mean) of the field values within this grouping.
  The returned value will be rounded to the nearest `Date` value.
  """
  approximateAvg: Date

  """
  An approximation of the number of unique values for this field within this grouping.

  The approximation uses the HyperLogLog++ algorithm from the [HyperLogLog in
  Practice](https://research.google.com/pubs/archive/40671.pdf)
  paper. The accuracy of the returned value varies based on the specific dataset, but
  it usually differs from the true distinct value count by less than 7%.
  """
  approximateDistinctValueCount: JsonSafeLong

  """
  The maximum of the field values within this grouping.

  So long as the grouping contains at least one non-null value for the
  underlying indexed field, this will return an exact non-null value.
  """
  exactMax: Date

  """
  The minimum of the field values within this grouping.

  So long as the grouping contains at least one non-null value for the
  underlying indexed field, this will return an exact non-null value.
  """
  exactMin: Date
}

"""
Input type used to specify filters on `Date` fields.

Will match all documents if passed as an empty object (or as `null`).
"""
input DateFilterInput {
  """
  Matches records where all of the provided sub-filters evaluate to true. This works just like an AND operator in SQL.

  Note: multiple filters are automatically ANDed together. This is only needed when you have multiple filters that can't
  be provided on a single `DateFilterInput` input because of collisions between
  key names. For example, if you want to AND multiple
  OR'd sub-filters (the equivalent of (A OR B) AND (C OR D)), you could do allOf: [{anyOf: [...]}, {anyOf: [...]}].

  When `null` or an empty list is passed, matches all documents.
  """
  allOf: [DateFilterInput!]

  """
  Matches records where any of the provided sub-filters evaluate to true.
  This works just like an OR operator in SQL.

  When `null` is passed, matches all documents.
  When an empty list is passed, this part of the filter matches no documents.
  """
  anyOf: [DateFilterInput!]

  """
  Matches records where the field value is equal to any of the provided values.
  This works just like an IN operator in SQL.

  When `null` is passed, matches all documents. When an empty list is passed,
  this part of the filter matches no documents. When `null` is passed in the
  list, this part of the filter matches records where the field value is `null`.
  """
  equalToAnyOf: [Date]

  """
  Matches records where the field value is greater than (>) the provided value.

  When `null` is passed, matches all documents.
  """
  gt: Date

  """
  Matches records where the field value is greater than or equal to (>=) the provided value.

  When `null` is passed, matches all documents.
  """
  gte: Date

  """
  Matches records where the field value is less than (<) the provided value.

  When `null` is passed, matches all documents.
  """
  lt: Date

  """
  Matches records where the field value is less than or equal to (<=) the provided value.

  When `null` is passed, matches all documents.
  """
  lte: Date

  """
  Matches records where the provided sub-filter evaluates to false.
  This works just like a NOT operator in SQL.

  When `null` or an empty object is passed, matches no documents.
  """
  not: DateFilterInput
}

"""
Allows for grouping `Date` values based on the desired return type.
"""
type DateGroupedBy {
  """
  Used when grouping on the full `Date` value.
  """
  asDate(
    """
    Amount of offset (positive or negative) to shift the `Date` boundaries of each grouping bucket.

    For example, when grouping by `WEEK`, you can shift by 1 day to change what
    day-of-week weeks are considered to start on.
    """
    offset: DateGroupingOffsetInput

    """
    Determines the grouping truncation unit for this field.
    """
    truncationUnit: DateGroupingTruncationUnitInput!
  ): Date

  """
  An alternative to `asDate` for when grouping on the day-of-week is desired.
  """
  asDayOfWeek(
    """
    Amount of offset (positive or negative) to shift the `DayOfWeek` boundaries of each grouping bucket.

    For example, you can apply an offset of -2 hours to shift `DateTime` values to the prior `DayOfWeek`
    when they fall between midnight and 2 AM.
    """
    offset: DayOfWeekGroupingOffsetInput
  ): DayOfWeek
}

"""
Input type offered when grouping on `Date` fields, representing the amount of offset
(positive or negative) to shift the `Date` boundaries of each grouping bucket.

For example, when grouping by `WEEK`, you can shift by 1 day to change
what day-of-week weeks are considered to start on.
"""
input DateGroupingOffsetInput {
  """
  Number (positive or negative) of the given `unit` to offset the boundaries of the `Date` groupings.
  """
  amount: Int!

  """
  Unit of offsetting to apply to the boundaries of the `Date` groupings.
  """
  unit: DateUnitInput!
}

"""
Enumerates the supported truncation units of a `Date`.
"""
enum DateGroupingTruncationUnitInput {
  """
  The exact day of a `Date`.
  """
  DAY

  """
  The month a `Date` falls in.
  """
  MONTH

  """
  The quarter a `Date` falls in.
  """
  QUARTER

  """
  The week, beginning on Monday, a `Date` falls in.
  """
  WEEK

  """
  The year a `Date` falls in.
  """
  YEAR
}

"""
Enumeration of `DateTime` units.
"""
enum DateTimeUnitInput {
  """
  The time period of a full rotation of the Earth with respect to the Sun.
  """
  DAY

  """
  1/24th of a day.
  """
  HOUR

  """
  1/1000th of a second.
  """
  MILLISECOND

  """
  1/60th of an hour.
  """
  MINUTE

  """
  1/60th of a minute.
  """
  SECOND
}

"""
Enumeration of `Date` units.
"""
enum DateUnitInput {
  """
  The time period of a full rotation of the Earth with respect to the Sun.
  """
  DAY
}

"""
Indicates the specific day of the week.
"""
enum DayOfWeek {
  """
  Friday.
  """
  FRIDAY

  """
  Monday.
  """
  MONDAY

  """
  Saturday.
  """
  SATURDAY

  """
  Sunday.
  """
  SUNDAY

  """
  Thursday.
  """
  THURSDAY

  """
  Tuesday.
  """
  TUESDAY

  """
  Wednesday.
  """
  WEDNESDAY
}

"""
Input type offered when grouping on `DayOfWeek` fields, representing the amount of offset
(positive or negative) to shift the `DayOfWeek` boundaries of each grouping bucket.

For example, you can apply an offset of -2 hours to shift `DateTime` values to the prior `DayOfWeek`
when they fall between midnight and 2 AM.
"""
input DayOfWeekGroupingOffsetInput {
  """
  Number (positive or negative) of the given `unit` to offset the boundaries of the `DayOfWeek` groupings.
  """
  amount: Int!

  """
  Unit of offsetting to apply to the boundaries of the `DayOfWeek` groupings.
  """
  unit: DateTimeUnitInput!
}

"""
Input type used to specify filters on `ID` fields.

Will match all documents if passed as an empty object (or as `null`).
"""
input IDFilterInput {
  """
  Matches records where all of the provided sub-filters evaluate to true. This works just like an AND operator in SQL.

  Note: multiple filters are automatically ANDed together. This is only needed when you have multiple filters that can't
  be provided on a single `IDFilterInput` input because of collisions between
  key names. For example, if you want to AND multiple
  OR'd sub-filters (the equivalent of (A OR B) AND (C OR D)), you could do allOf: [{anyOf: [...]}, {anyOf: [...]}].

  When `null` or an empty list is passed, matches all documents.
  """
  allOf: [IDFilterInput!]

  """
  Matches records where any of the provided sub-filters evaluate to true.
  This works just like an OR operator in SQL.

  When `null` is passed, matches all documents.
  When an empty list is passed, this part of the filter matches no documents.
  """
  anyOf: [IDFilterInput!]

  """
  Matches records where the field value is equal to any of the provided values.
  This works just like an IN operator in SQL.

  When `null` is passed, matches all documents. When an empty list is passed,
  this part of the filter matches no documents. When `null` is passed in the
  list, this part of the filter matches records where the field value is `null`.
  """
  equalToAnyOf: [ID]

  """
  Matches records where the provided sub-filter evaluates to false.
  This works just like a NOT operator in SQL.

  When `null` or an empty object is passed, matches no documents.
  """
  not: IDFilterInput
}

"""
Input type used to specify filters on `Int` fields.

Will match all documents if passed as an empty object (or as `null`).
"""
input IntFilterInput {
  """
  Matches records where all of the provided sub-filters evaluate to true. This works just like an AND operator in SQL.

  Note: multiple filters are automatically ANDed together. This is only needed when you have multiple filters that can't
  be provided on a single `IntFilterInput` input because of collisions between
  key names. For example, if you want to AND multiple
  OR'd sub-filters (the equivalent of (A OR B) AND (C OR D)), you could do allOf: [{anyOf: [...]}, {anyOf: [...]}].

  When `null` or an empty list is passed, matches all documents.
  """
  allOf: [IntFilterInput!]

  """
  Matches records where any of the provided sub-filters evaluate to true.
  This works just like an OR operator in SQL.

  When `null` is passed, matches all documents.
  When an empty list is passed, this part of the filter matches no documents.
  """
  anyOf: [IntFilterInput!]

  """
  Matches records where the field value is equal to any of the provided values.
  This works just like an IN operator in SQL.

  When `null` is passed, matches all documents. When an empty list is passed,
  this part of the filter matches no documents. When `null` is passed in the
  list, this part of the filter matches records where the field value is `null`.
  """
  equalToAnyOf: [Int]

  """
  Matches records where the field value is greater than (>) the provided value.

  When `null` is passed, matches all documents.
  """
  gt: Int

  """
  Matches records where the field value is greater than or equal to (>=) the provided value.

  When `null` is passed, matches all documents.
  """
  gte: Int

  """
  Matches records where the field value is less than (<) the provided value.

  When `null` is passed, matches all documents.
  """
  lt: Int

  """
  Matches records where the field value is less than or equal to (<=) the provided value.

  When `null` is passed, matches all documents.
  """
  lte: Int

  """
  Matches records where the provided sub-filter evaluates to false.
  This works just like a NOT operator in SQL.

  When `null` or an empty object is passed, matches no documents.
  """
  not: IntFilterInput
}

"""
A numeric type for large integer values that can serialize safely as JSON.

While JSON itself has no hard limit on the size of integers, the RFC-7159 spec
mentions that values outside of the range -9,007,199,254,740,991 (-(2^53) + 1)
to 9,007,199,254,740,991 (2^53 - 1) may not be interopable with all JSON
implementations. As it turns out, the number implementation used by JavaScript
has this issue. When you parse a JSON string that contains a numeric value like
`4693522397653681111`, the parsed result will contain a rounded value like
`4693522397653681000`.

While this is entirely a client-side problem, we want to preserve maximum compatibility
with common client languages. Given the ubiquity of GraphiQL as a GraphQL client,
we want to avoid this problem.

Our solution is to support two separate types:

- This type (`JsonSafeLong`) is serialized as a number, but limits values to the safely
  serializable range.
- The `LongString` type supports long values that use all 64 bits, but serializes as a
  string rather than a number, avoiding the JavaScript compatibility problems.

For more background, see the [JavaScript `Number.MAX_SAFE_INTEGER`
docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER).
"""
scalar JsonSafeLong

"""
A return type used from aggregations to provided aggregated values over `JsonSafeLong` fields.
"""
type JsonSafeLongAggregatedValues {
  """
  The average (mean) of the field values within this grouping.

  Note that the returned value is approximate. Imprecision can be introduced by the computation if
  any intermediary values fall outside the `JsonSafeLong` range (-9,007,199,254,740,991
  to 9,007,199,254,740,991).
  """
  approximateAvg: Float

  """
  An approximation of the number of unique values for this field within this grouping.

  The approximation uses the HyperLogLog++ algorithm from the [HyperLogLog in
  Practice](https://research.google.com/pubs/archive/40671.pdf)
  paper. The accuracy of the returned value varies based on the specific dataset, but
  it usually differs from the true distinct value count by less than 7%.
  """
  approximateDistinctValueCount: JsonSafeLong

  """
  The (approximate) sum of the field values within this grouping.

  Sums of large `JsonSafeLong` values can result in overflow, where the exact sum cannot
  fit in a `JsonSafeLong` return value. This field, as a double-precision `Float`, can
  represent larger sums, but the value may only be approximate.
  """
  approximateSum: Float!

  """
  The maximum of the field values within this grouping.

  So long as the grouping contains at least one non-null value for the
  underlying indexed field, this will return an exact non-null value.
  """
  exactMax: JsonSafeLong

  """
  The minimum of the field values within this grouping.

  So long as the grouping contains at least one non-null value for the
  underlying indexed field, this will return an exact non-null value.
  """
  exactMin: JsonSafeLong

  """
  The exact sum of the field values within this grouping, if it fits in a `JsonSafeLong`.

  Sums of large `JsonSafeLong` values can result in overflow, where the exact sum cannot
  fit in a `JsonSafeLong`. In that case, `null` will be returned, and `approximateSum`
  can be used to get an approximate value.
  """
  exactSum: JsonSafeLong
}

"""
Input type used to specify filters on `JsonSafeLong` fields.

Will match all documents if passed as an empty object (or as `null`).
"""
input JsonSafeLongFilterInput {
  """
  Matches records where all of the provided sub-filters evaluate to true. This works just like an AND operator in SQL.

  Note: multiple filters are automatically ANDed together. This is only needed when you have multiple filters that can't
  be provided on a single `JsonSafeLongFilterInput` input because of collisions
  between key names. For example, if you want to AND multiple
  OR'd sub-filters (the equivalent of (A OR B) AND (C OR D)), you could do allOf: [{anyOf: [...]}, {anyOf: [...]}].

  When `null` or an empty list is passed, matches all documents.
  """
  allOf: [JsonSafeLongFilterInput!]

  """
  Matches records where any of the provided sub-filters evaluate to true.
  This works just like an OR operator in SQL.

  When `null` is passed, matches all documents.
  When an empty list is passed, this part of the filter matches no documents.
  """
  anyOf: [JsonSafeLongFilterInput!]

  """
  Matches records where the field value is equal to any of the provided values.
  This works just like an IN operator in SQL.

  When `null` is passed, matches all documents. When an empty list is passed,
  this part of the filter matches no documents. When `null` is passed in the
  list, this part of the filter matches records where the field value is `null`.
  """
  equalToAnyOf: [JsonSafeLong]

  """
  Matches records where the field value is greater than (>) the provided value.

  When `null` is passed, matches all documents.
  """
  gt: JsonSafeLong

  """
  Matches records where the field value is greater than or equal to (>=) the provided value.

  When `null` is passed, matches all documents.
  """
  gte: JsonSafeLong

  """
  Matches records where the field value is less than (<) the provided value.

  When `null` is passed, matches all documents.
  """
  lt: JsonSafeLong

  """
  Matches records where the field value is less than or equal to (<=) the provided value.

  When `null` is passed, matches all documents.
  """
  lte: JsonSafeLong

  """
  Matches records where the provided sub-filter evaluates to false.
  This works just like a NOT operator in SQL.

  When `null` or an empty object is passed, matches no documents.
  """
  not: JsonSafeLongFilterInput
}

"""
A return type used from aggregations to provided aggregated values over non-numeric fields.
"""
type NonNumericAggregatedValues {
  """
  An approximation of the number of unique values for this field within this grouping.

  The approximation uses the HyperLogLog++ algorithm from the [HyperLogLog in
  Practice](https://research.google.com/pubs/archive/40671.pdf)
  paper. The accuracy of the returned value varies based on the specific dataset, but
  it usually differs from the true distinct value count by less than 7%.
  """
  approximateDistinctValueCount: JsonSafeLong
}

"""
Provides information about the specific fetched page. This implements the `PageInfo`
specification from the [Relay GraphQL Cursor Connections
Specification](https://relay.dev/graphql/connections.htm#sec-undefined.PageInfo).
"""
type PageInfo {
  """
  The `Cursor` of the last edge of the current page. This can be passed in the next query as
  a `after` argument to paginate forwards.
  """
  endCursor: Cursor

  """
  Indicates if there is another page of results available after the current one.
  """
  hasNextPage: Boolean!

  """
  Indicates if there is another page of results available before the current one.
  """
  hasPreviousPage: Boolean!

  """
  The `Cursor` of the first edge of the current page. This can be passed in the next query as
  a `before` argument to paginate backwards.
  """
  startCursor: Cursor
}

"""
The query entry point for the entire schema.
"""
type Query {
  """
  Aggregations over the `artists` data:

  > Fetches `Artist`s based on the provided arguments.
  """
  artistAggregations(
    """
    Used to forward-paginate through the `artistAggregations`. When provided, the next page after the
    provided cursor will be returned.

    See the [Relay GraphQL Cursor Connections
    Specification](https://relay.dev/graphql/connections.htm#sec-Arguments) for more info.
    """
    after: Cursor

    """
    Used to backward-paginate through the `artistAggregations`. When provided, the previous page before the
    provided cursor will be returned.

    See the [Relay GraphQL Cursor Connections
    Specification](https://relay.dev/graphql/connections.htm#sec-Arguments) for more info.
    """
    before: Cursor

    """
    Used to filter the `Artist` documents that get aggregated over based on the provided criteria.
    """
    filter: ArtistFilterInput

    """
    Used in conjunction with the `after` argument to forward-paginate through the `artistAggregations`.
    When provided, limits the number of returned results to the first `n` after the provided
    `after` cursor (or from the start of the `artistAggregations`, if no `after` cursor is provided).

    See the [Relay GraphQL Cursor Connections
    Specification](https://relay.dev/graphql/connections.htm#sec-Arguments) for more info.
    """
    first: Int

    """
    Used in conjunction with the `before` argument to backward-paginate through the `artistAggregations`.
    When provided, limits the number of returned results to the last `n` before the provided
    `before` cursor (or from the end of the `artistAggregations`, if no `before` cursor is provided).

    See the [Relay GraphQL Cursor Connections
    Specification](https://relay.dev/graphql/connections.htm#sec-Arguments) for more info.
    """
    last: Int
  ): ArtistAggregationConnection

  """
  Fetches `Artist`s based on the provided arguments.
  """
  artists(
    """
    Used to forward-paginate through the `artists`. When provided, the next page after the
    provided cursor will be returned.

    See the [Relay GraphQL Cursor Connections
    Specification](https://relay.dev/graphql/connections.htm#sec-Arguments) for more info.
    """
    after: Cursor

    """
    Used to backward-paginate through the `artists`. When provided, the previous page before the
    provided cursor will be returned.

    See the [Relay GraphQL Cursor Connections
    Specification](https://relay.dev/graphql/connections.htm#sec-Arguments) for more info.
    """
    before: Cursor

    """
    Used to filter the returned `artists` based on the provided criteria.
    """
    filter: ArtistFilterInput

    """
    Used in conjunction with the `after` argument to forward-paginate through the `artists`.
    When provided, limits the number of returned results to the first `n` after the provided
    `after` cursor (or from the start of the `artists`, if no `after` cursor is provided).

    See the [Relay GraphQL Cursor Connections
    Specification](https://relay.dev/graphql/connections.htm#sec-Arguments) for more info.
    """
    first: Int

    """
    Used in conjunction with the `before` argument to backward-paginate through the `artists`.
    When provided, limits the number of returned results to the last `n` before the provided
    `before` cursor (or from the end of the `artists`, if no `before` cursor is provided).

    See the [Relay GraphQL Cursor Connections
    Specification](https://relay.dev/graphql/connections.htm#sec-Arguments) for more info.
    """
    last: Int

    """
    Used to specify how the returned `artists` should be sorted.
    """
    orderBy: [ArtistSortOrderInput!]
  ): ArtistConnection
}

"""
Input type used to specify filters on `String` fields.

Will match all documents if passed as an empty object (or as `null`).
"""
input StringFilterInput {
  """
  Matches records where all of the provided sub-filters evaluate to true. This works just like an AND operator in SQL.

  Note: multiple filters are automatically ANDed together. This is only needed when you have multiple filters that can't
  be provided on a single `StringFilterInput` input because of collisions
  between key names. For example, if you want to AND multiple
  OR'd sub-filters (the equivalent of (A OR B) AND (C OR D)), you could do allOf: [{anyOf: [...]}, {anyOf: [...]}].

  When `null` or an empty list is passed, matches all documents.
  """
  allOf: [StringFilterInput!]

  """
  Matches records where any of the provided sub-filters evaluate to true.
  This works just like an OR operator in SQL.

  When `null` is passed, matches all documents.
  When an empty list is passed, this part of the filter matches no documents.
  """
  anyOf: [StringFilterInput!]

  """
  Matches records where the field value is equal to any of the provided values.
  This works just like an IN operator in SQL.

  When `null` is passed, matches all documents. When an empty list is passed,
  this part of the filter matches no documents. When `null` is passed in the
  list, this part of the filter matches records where the field value is `null`.
  """
  equalToAnyOf: [String]

  """
  Matches records where the provided sub-filter evaluates to false.
  This works just like a NOT operator in SQL.

  When `null` or an empty object is passed, matches no documents.
  """
  not: StringFilterInput
}