schema
  @link(url: "https://specs.apollo.dev/link/v1.0")
  @link(url: "https://specs.apollo.dev/join/v0.5", for: EXECUTION)
  @link(url: "https://specs.apollo.dev/cost/v0.1", import: ["@listSize"]) {
  query: Query
}

directive @cost(
  weight: Int!
) on ARGUMENT_DEFINITION | ENUM | FIELD_DEFINITION | INPUT_FIELD_DEFINITION | OBJECT | SCALAR

directive @join__directive(
  graphs: [join__Graph!]
  name: String!
  args: join__DirectiveArguments
) repeatable on SCHEMA | OBJECT | INTERFACE | FIELD_DEFINITION

directive @join__enumValue(graph: join__Graph!) repeatable on ENUM_VALUE

directive @join__field(
  graph: join__Graph
  requires: join__FieldSet
  provides: join__FieldSet
  type: String
  external: Boolean
  override: String
  usedOverridden: Boolean
  overrideLabel: String
  contextArguments: [join__ContextArgument!]
) repeatable on FIELD_DEFINITION | INPUT_FIELD_DEFINITION

directive @join__graph(name: String!, url: String!) on ENUM_VALUE

directive @join__implements(
  graph: join__Graph!
  interface: String!
) repeatable on OBJECT | INTERFACE

directive @join__type(
  graph: join__Graph!
  key: join__FieldSet
  extension: Boolean! = false
  resolvable: Boolean! = true
  isInterfaceObject: Boolean! = false
) repeatable on OBJECT | INTERFACE | UNION | ENUM | INPUT_OBJECT | SCALAR

directive @join__unionMember(
  graph: join__Graph!
  member: String!
) repeatable on UNION

directive @link(
  url: String
  as: String
  for: link__Purpose
  import: [link__Import]
) repeatable on SCHEMA

directive @listSize(
  assumedSize: Int
  slicingArguments: [String!]
  sizedFields: [String!]
  requireOneSlicingArgument: Boolean = true
) on FIELD_DEFINITION

type A @join__type(graph: SUBGRAPHWITHLISTSIZE) {
  id: ID
}

enum AorB @join__type(graph: SUBGRAPHWITHCOST) @cost(weight: 15) {
  A @join__enumValue(graph: SUBGRAPHWITHCOST)
  B @join__enumValue(graph: SUBGRAPHWITHCOST)
}

scalar ExpensiveInt @join__type(graph: SUBGRAPHWITHCOST) @cost(weight: 30)

type ExpensiveObject @join__type(graph: SUBGRAPHWITHCOST) @cost(weight: 40) {
  id: ID
}

input InputTypeWithCost @join__type(graph: SUBGRAPHWITHCOST) {
  somethingWithCost: Int @cost(weight: 20)
}

input join__ContextArgument {
  name: String!
  type: String!
  context: String!
  selection: join__FieldValue!
}

scalar join__DirectiveArguments

scalar join__FieldSet

scalar join__FieldValue

enum join__Graph {
  SUBGRAPHWITHCOST
    @join__graph(name: "subgraphWithCost", url: "http://0.0.0.0:4200/subgraphWithCost")
  SUBGRAPHWITHLISTSIZE
    @join__graph(name: "subgraphWithListSize", url: "http://0.0.0.0:4200/subgraphWithListSize")
}

scalar link__Import

enum link__Purpose {
  """
  `SECURITY` features provide metadata necessary to securely resolve fields.
  """
  SECURITY

  """
  `EXECUTION` features provide metadata necessary for operation execution.
  """
  EXECUTION
}

type Query
  @join__type(graph: SUBGRAPHWITHCOST)
  @join__type(graph: SUBGRAPHWITHLISTSIZE) {
  fieldWithCost: Int @join__field(graph: SUBGRAPHWITHCOST) @cost(weight: 5)
  argWithCost(arg: Int @cost(weight: 10)): Int
    @join__field(graph: SUBGRAPHWITHCOST)
  enumWithCost: AorB @join__field(graph: SUBGRAPHWITHCOST)
  inputWithCost(someInput: InputTypeWithCost): Int
    @join__field(graph: SUBGRAPHWITHCOST)
  scalarWithCost: ExpensiveInt @join__field(graph: SUBGRAPHWITHCOST)
  objectWithCost: ExpensiveObject @join__field(graph: SUBGRAPHWITHCOST)
  fieldWithListSize: [String!]
    @join__field(graph: SUBGRAPHWITHLISTSIZE)
    @listSize(assumedSize: 2000, requireOneSlicingArgument: false)
  fieldWithDynamicListSize(first: Int = 10): SizedField
    @join__field(graph: SUBGRAPHWITHLISTSIZE)
    @listSize(
      slicingArguments: ["first"]
      sizedFields: ["items"]
      requireOneSlicingArgument: true
    )
  itemsByIds(ids: [ID!]!): [A]
    @join__field(graph: SUBGRAPHWITHLISTSIZE)
    @listSize(
      slicingArguments: ["ids"]
      requireOneSlicingArgument: true
    )
  itemsByIdsWithAssumedSize(ids: [ID!]): [A]
    @join__field(graph: SUBGRAPHWITHLISTSIZE)
    @listSize(
      slicingArguments: ["ids"]
      assumedSize: 50
      requireOneSlicingArgument: false
    )
  search(input: SearchInput!): [A]
    @join__field(graph: SUBGRAPHWITHLISTSIZE)
    @listSize(
      slicingArguments: ["input.pagination.first"]
      requireOneSlicingArgument: true
    )
  searchWithAssumedSize(input: SearchInput): [A]
    @join__field(graph: SUBGRAPHWITHLISTSIZE)
    @listSize(
      slicingArguments: ["input.pagination.first"]
      assumedSize: 25
      requireOneSlicingArgument: false
    )
  deeplyNested(input: DeeplyNestedInput!): [A]
    @join__field(graph: SUBGRAPHWITHLISTSIZE)
    @listSize(
      slicingArguments: ["input.level1.level2.count"]
      requireOneSlicingArgument: true
    )
  containerWithNestedList(first: Int): ResultContainer!
    @join__field(graph: SUBGRAPHWITHLISTSIZE)
    @listSize(
      slicingArguments: ["first"]
      sizedFields: ["page"]
      requireOneSlicingArgument: false
    )
  deepContainerWithNestedList(first: Int = 10): DeepContainer!
    @join__field(graph: SUBGRAPHWITHLISTSIZE)
    @listSize(
      slicingArguments: ["first"]
      sizedFields: ["results { page }"]
      requireOneSlicingArgument: false
    )
  deepContainerWithMixedSizedFields(first: Int = 10): DeepContainer!
    @join__field(graph: SUBGRAPHWITHLISTSIZE)
    @listSize(
      slicingArguments: ["first"]
      sizedFields: ["page", "results { page }"]
      requireOneSlicingArgument: false
    )
}

type ResultContainer @join__type(graph: SUBGRAPHWITHLISTSIZE) {
  page: [A]
  metadata: String
}

type DeepContainer @join__type(graph: SUBGRAPHWITHLISTSIZE) {
  page: [A]
  results: ResultContainer
  total: Int
  metadata: String
}

type SizedField @join__type(graph: SUBGRAPHWITHLISTSIZE) {
  items: [A]
}

input PaginationInput @join__type(graph: SUBGRAPHWITHLISTSIZE) {
  first: Int
  after: String
}

input SearchInput @join__type(graph: SUBGRAPHWITHLISTSIZE) {
  pagination: PaginationInput
  query: String
}

input DeeplyNestedInput @join__type(graph: SUBGRAPHWITHLISTSIZE) {
  level1: NestedLevel1Input
}

input NestedLevel1Input @join__type(graph: SUBGRAPHWITHLISTSIZE) {
  level2: NestedLevel2Input
}

input NestedLevel2Input @join__type(graph: SUBGRAPHWITHLISTSIZE) {
  count: Int
}
