supergraph.graphql

schema
  @link(url: "https://specs.apollo.dev/link/v1.0")
  @link(url: "https://specs.apollo.dev/join/v0.3", for: EXECUTION)
  @link(url: "https://specs.apollo.dev/inaccessible/v0.2", for: SECURITY)
{
  query: Query
  mutation: Mutation
}

directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_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) 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

"""An address."""
interface Address implements Node
  @join__implements(graph: ADDRESS, interface: "Node")
  @join__type(graph: ADDRESS)
  @join__type(graph: SHIPMENT)
{
  """The city part of the address"""
  city: String! @join__field(graph: ADDRESS)

  """The company name part of the address"""
  companyName: String @join__field(graph: ADDRESS)

  """The country part of the address"""
  country: String! @join__field(graph: ADDRESS)

  """The ID of the node."""
  id: UUID!

  """The name of the address"""
  name: Name @join__field(graph: ADDRESS)

  """The postal code part of the address"""
  postalCode: String! @join__field(graph: ADDRESS)

  """The first part of the street part of the address"""
  street1: String! @join__field(graph: ADDRESS)

  """The second part of the street part of the address"""
  street2: String! @join__field(graph: ADDRESS)
}

"""Input for the archiveShipmentMethod mutation."""
input ArchiveShipmentMethodInput
  @join__type(graph: SHIPMENT)
{
  """The id of the shipment method to archive."""
  id: UUID!
}

"""Input for the archiveUserAddress mutation."""
input ArchiveUserAddressInput
  @join__type(graph: ADDRESS)
{
  """The id of the user address to archive."""
  id: UUID!
}

"""Input for calculateShipmentFees query."""
input CalculateShipmentFeesInput
  @join__type(graph: SHIPMENT)
  @inaccessible
{
  """The items to calculate the shipment fees for."""
  items: [ProductVariantVersionWithQuantityAndShipmentMethodInput!]!
}

"""A categorical characteristic of a category."""
type CategoricalCategoryCharacteristic implements CategoryCharacteristic & Node
  @join__implements(graph: CATALOG, interface: "CategoryCharacteristic")
  @join__implements(graph: CATALOG, interface: "Node")
  @join__type(graph: CATALOG, key: "id", resolvable: true)
{
  """The Category this item belongs to."""
  category: Category!

  """The description of the CategoryCharacteristic."""
  description: String!

  """The ID of the node."""
  id: UUID!

  """The name of the CategoryCharacteristic."""
  name: String!

  """Get all associated values"""
  values(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CategoricalCategoryCharacteristicValueOrderInput

    """Number of items to skip"""
    skip: Int
  ): CategoricalCategoryCharacteristicValueConnection!
}

"""Input to create a CategoricalCategoryCharacteristic for a Category"""
input CategoricalCategoryCharacteristicInput
  @join__type(graph: CATALOG)
{
  """The description of the CategoricalCategoryCharacteristic"""
  description: String!

  """The name of the CategoricalCategoryCharacteristic"""
  name: String!
}

"""A possible value for a categorical characteristic."""
type CategoricalCategoryCharacteristicValue implements CategoryCharacteristicValue
  @join__implements(graph: CATALOG, interface: "CategoryCharacteristicValue")
  @join__type(graph: CATALOG)
{
  """The associated CategoryCharacteristic this is a value of."""
  characteristic: CategoryCharacteristic!

  """The value of the characteristic."""
  value: String!
}

"""
A connection to a list of `CategoricalCategoryCharacteristicValue` values.
"""
type CategoricalCategoryCharacteristicValueConnection
  @join__type(graph: CATALOG)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [CategoricalCategoryCharacteristicValue!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Input for creating a CategoricalCategoryCharacteristicValue."""
input CategoricalCategoryCharacteristicValueInput
  @join__type(graph: CATALOG)
{
  """The id of the CategoryCharacteristic."""
  characteristicId: UUID!

  """The value of the CategoricalCategoryCharacteristicValue."""
  value: String!
}

"""CategoricalCategoryCharacteristicValue order fields"""
enum CategoricalCategoryCharacteristicValueOrderField
  @join__type(graph: CATALOG)
{
  """Order CategoricalCategoryCharacteristicValue by their id"""
  VALUE @join__enumValue(graph: CATALOG)
}

"""CategoricalCategoryCharacteristicValue order"""
input CategoricalCategoryCharacteristicValueOrderInput
  @join__type(graph: CATALOG)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: CategoricalCategoryCharacteristicValueOrderField
}

"""A category"""
type Category implements Node
  @join__implements(graph: CATALOG, interface: "Node")
  @join__implements(graph: DISCOUNT, interface: "Node")
  @join__type(graph: CATALOG, key: "id", resolvable: true)
  @join__type(graph: DISCOUNT, key: "id", resolvable: true)
{
  """Get characteristics for the category"""
  characteristics(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CategoryCharacteristicOrderInput

    """Number of items to skip"""
    skip: Int
  ): CategoryCharacteristicConnection! @join__field(graph: CATALOG)

  """The description of the category."""
  description: String! @join__field(graph: CATALOG)

  """The ID of the node."""
  id: UUID!

  """The name of the category."""
  name: String! @join__field(graph: CATALOG)

  """Get all associated products"""
  products(
    """Filtering"""
    filter: ProductFilterInput

    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: ProductOrderInput

    """Number of items to skip"""
    skip: Int
  ): ProductConnection! @join__field(graph: CATALOG)

  """Get all discounts which apply directly to this category"""
  discounts(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: DiscountOrderInput

    """Number of items to skip"""
    skip: Int
  ): DiscountConnection! @join__field(graph: DISCOUNT)
}

"""A characteristic of a Category."""
interface CategoryCharacteristic implements Node
  @join__implements(graph: CATALOG, interface: "Node")
  @join__type(graph: CATALOG)
{
  """The Category this item belongs to."""
  category: Category!

  """The description of the CategoryCharacteristic."""
  description: String!

  """The ID of the node."""
  id: UUID!

  """The name of the CategoryCharacteristic."""
  name: String!
}

"""A connection to a list of `CategoryCharacteristic` values."""
type CategoryCharacteristicConnection
  @join__type(graph: CATALOG)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [CategoryCharacteristic!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""CategoryCharacteristic order fields"""
enum CategoryCharacteristicOrderField
  @join__type(graph: CATALOG)
{
  """Order categoryCharacteristics by their id"""
  ID @join__enumValue(graph: CATALOG)
}

"""CategoryCharacteristic order"""
input CategoryCharacteristicOrderInput
  @join__type(graph: CATALOG)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: CategoryCharacteristicOrderField
}

"""A value for a CategoryCharacteristic."""
interface CategoryCharacteristicValue
  @join__type(graph: CATALOG)
{
  """The associated CategoryCharacteristic this is a value of."""
  characteristic: CategoryCharacteristic!
}

"""A connection to a list of `CategoryCharacteristicValue` values."""
type CategoryCharacteristicValueConnection
  @join__type(graph: CATALOG)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [CategoryCharacteristicValue!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""CategoryCharacteristicValue order fields"""
enum CategoryCharacteristicValueOrderField
  @join__type(graph: CATALOG)
{
  """Order categoryCharacteristicValues by their id"""
  ID @join__enumValue(graph: CATALOG)
}

"""CategoryCharacteristicValue order"""
input CategoryCharacteristicValueOrderInput
  @join__type(graph: CATALOG)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: CategoryCharacteristicValueOrderField
}

"""A connection to a list of `Category` values."""
type CategoryConnection
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [Category!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Category order fields"""
enum CategoryOrderField
  @join__type(graph: CATALOG)
{
  """Order categories by their id"""
  ID @join__enumValue(graph: CATALOG)

  """Order categories by their name"""
  NAME @join__enumValue(graph: CATALOG)
}

"""Category order"""
input CategoryOrderInput
  @join__type(graph: CATALOG)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: CategoryOrderField
}

"""Common order fields"""
enum CommonOrderField
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
  @join__type(graph: ORDER)
  @join__type(graph: RETURN)
  @join__type(graph: SHOPPINGCART)
  @join__type(graph: WISHLIST)
{
  """Order entities by their id"""
  ID @join__enumValue(graph: CATALOG) @join__enumValue(graph: DISCOUNT) @join__enumValue(graph: ORDER) @join__enumValue(graph: RETURN) @join__enumValue(graph: SHOPPINGCART) @join__enumValue(graph: WISHLIST)
}

"""Discount order"""
input CommonOrderInput
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
  @join__type(graph: ORDER)
  @join__type(graph: RETURN)
  @join__type(graph: SHOPPINGCART)
  @join__type(graph: WISHLIST)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: CommonOrderField
}

"""A coupon"""
type Coupon implements Node
  @join__implements(graph: DISCOUNT, interface: "Node")
  @join__type(graph: DISCOUNT, key: "id", resolvable: true)
{
  """The code of the coupon."""
  code: String!

  """The discount granted by this coupon."""
  discount: Discount!

  """The ID of the node."""
  id: UUID!

  """The maximum number of times the coupon can be used."""
  maxUsages: Int

  """The number of times the coupon has been used."""
  usages: Int!

  """Get all users who claimed this coupon."""
  users(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CommonOrderInput

    """Number of items to skip"""
    skip: Int
  ): UserConnection!

  """The date and time from which the coupon is valid."""
  validFrom: DateTime!

  """The date and time until which the coupon is valid."""
  validUntil: DateTime!
}

"""A connection to a list of `Coupon` values."""
type CouponConnection
  @join__type(graph: DISCOUNT)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [Coupon!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Coupon filter"""
input CouponFilterInput
  @join__type(graph: DISCOUNT)
{
  """
  Filter weather the user with the provided id own the coupon, other users than the authenticated user require at least EMPLOYEE
  """
  userHasCoupon: UUID
}

"""Coupon order fields"""
enum CouponOrderField
  @join__type(graph: DISCOUNT)
{
  """Order coupons by their id"""
  ID @join__enumValue(graph: DISCOUNT)

  """Order coupons by the valid from date"""
  VALID_FROM @join__enumValue(graph: DISCOUNT)

  """Order coupons by the valid until date"""
  VALID_UNTIL @join__enumValue(graph: DISCOUNT)
}

"""Coupon order"""
input CouponOrderInput
  @join__type(graph: DISCOUNT)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: CouponOrderField
}

"""Input for the createCategoricalCategoryCharacteristic mutation"""
input CreateCategoricalCategoryCharacteristicInput
  @join__type(graph: CATALOG)
{
  """The Category that the CategoricalCategoryCharacteristicI belongs to"""
  categoryId: UUID!

  """The description of the CategoricalCategoryCharacteristic"""
  description: String!

  """The name of the CategoricalCategoryCharacteristic"""
  name: String!
}

"""Input for the createCategory mutation"""
input CreateCategoryInput
  @join__type(graph: CATALOG)
{
  """The CategoricalCategoryCharacteristics of the Category"""
  categoricalCharacteristics: [CategoricalCategoryCharacteristicInput!]!

  """The description of the Category"""
  description: String!

  """The name of the Category"""
  name: String!

  """The NumericalCategoryCharacteristics of the Category"""
  numericalCharacteristics: [NumericalCategoryCharacteristicInput!]!
}

"""Input for the createCoupon mutation."""
input CreateCouponInput
  @join__type(graph: DISCOUNT)
{
  """The code of the coupon."""
  code: String!

  """The id of the discount the coupon is for."""
  discountId: UUID!

  """The maximum number of times the coupon can be used."""
  maxUsages: Int!

  """The date and time from which the coupon is valid."""
  validFrom: DateTime!

  """The date and time until which the coupon is valid."""
  validUntil: DateTime!
}

"""All required informations to save an credit card"""
input CreateCreditCardInformationInput
  @join__type(graph: PAYMENT)
{
  """The card holders name"""
  cardHolder: String!

  """The credit cards number"""
  cardNumber: String!

  """The credit cards expiration date"""
  expirationDate: String!
}

"""Input for the createDiscount mutation."""
input CreateDiscountInput
  @join__type(graph: DISCOUNT)
{
  """The discount applied to the order item."""
  discount: Float!

  """The category ids to which the discount applies."""
  discountAppliesToCategoryIds: [UUID!]!

  """The product ids to which the discount applies."""
  discountAppliesToProductIds: [UUID!]!

  """The product variant ids to which the discount applies."""
  discountAppliesToProductVariantIds: [UUID!]!

  """
  The maximum number of times a user can use this discount in bought ProductItems.
  """
  maxUsagesPerUser: Int!

  """The minimum order amount required to use this discount."""
  minOrderAmount: Int

  """The date and time from which the discount is valid."""
  validFrom: DateTime!

  """The date and time until which the discount is valid."""
  validUntil: DateTime!
}

"""Input for the createNotification mutation"""
input CreateNotificationInput
  @join__type(graph: NOTIFICATION)
{
  """body of the notification to create"""
  body: String!

  """title of the notification to create"""
  title: String!

  """id of the user the notification should be sent to"""
  userId: UUID!
}

"""Input for the createNumericalCategoryCharacteristic mutation"""
input CreateNumericalCategoryCharacteristicInput
  @join__type(graph: CATALOG)
{
  """The Category that the NumericalCategoryCharacteristic belongs to"""
  categoryId: UUID!

  """The description of the NumericalCategoryCharacteristic"""
  description: String!

  """The name of the NumericalCategoryCharacteristic"""
  name: String!

  """The unit of the NumericalCategoryCharacteristic"""
  unit: String!
}

input CreateOrderInput
  @join__type(graph: ORDER)
{
  """UUID of user owning the order."""
  userId: UUID!

  """OrderItems of order."""
  orderItemInputs: [OrderItemInput!]!

  """UUID of address to where the order should be shipped to."""
  shipmentAddressId: UUID!

  """UUID of address of invoice."""
  invoiceAddressId: UUID!

  """UUID of payment information that the order should be processed with."""
  paymentInformationId: UUID!

  """Optional VAT number."""
  vatNumber: String
}

"""Input for the createProduct mutation"""
input CreateProductInput
  @join__type(graph: CATALOG)
{
  """The Categories this product is associated with."""
  categoryIds: [UUID!]!

  """The default ProductVariant of the Product."""
  defaultVariant: ProductVariantInput!

  """An internal name to identify the Product, not visible to customers."""
  internalName: String!

  """If true, the Product is visible to customers."""
  isPubliclyVisible: Boolean!
}

"""The input of a product item batch creation"""
input CreateProductItemBatchInput
  @join__type(graph: INVENTORY)
{
  """The product variant id of the product item"""
  productVariantId: UUID!

  """The number of products to add"""
  number: Int!
}

"""Input for the createProductVariant mutation"""
input CreateProductVariantInput
  @join__type(graph: CATALOG)
{
  """The initial ProductVariantVersion of the ProductVariant."""
  initialVersion: ProductVariantVersionInput!

  """If true, the ProductVariant is visible to customers."""
  isPubliclyVisible: Boolean!

  """The id of the Product this ProductVariant belongs to."""
  productId: UUID!
}

"""Input for the createProductVariantVersion mutation"""
input CreateProductVariantVersionInput
  @join__type(graph: CATALOG)
{
  """
  The amount of days for which an instance of the ProductVariant can be returned after purchase, if null can be returned indefinitely.
  """
  canBeReturnedForDays: Int

  """
  The CategoricalCategoryCharacteristicValues of the ProductVariant, must be compatible with the Categories of the associated Product.
  """
  categoricalCharacteristicValues: [CategoricalCategoryCharacteristicValueInput!]!

  """The description of the ProductVariant."""
  description: String!

  """The associated Media files."""
  mediaIds: [UUID!]!

  """The name of the ProductVariant."""
  name: String!

  """
  The NumericalCategoryCharacteristicValues of the ProductVariant, must be compatible with the Categories of the associated Product.
  """
  numericalCharacteristicValues: [NumericalCategoryCharacteristicValueInput!]!

  """The id of the ProductVariant this ProductVariantVersion belongs to."""
  productVariantId: UUID!

  """The retail price of the ProductVariant."""
  retailPrice: Int!

  """The associated TaxRate"""
  taxRateId: UUID!

  """The weight of a single instance of the ProductVariant."""
  weight: Float!
}

"""Input for the createReturn mutation"""
input CreateReturnInput
  @join__type(graph: RETURN)
{
  """
  The order items to return, must belong to the same order and must not be already returned.
  """
  orderItemIds: [UUID!]!

  """The reason for the return."""
  reason: String!
}

input CreateReviewInput
  @join__type(graph: REVIEW)
{
  """UUID of user owning the review."""
  userId: UUID!

  """UUID of product variant in review."""
  productVariantId: UUID!

  """Body of review."""
  body: String!

  """Rating of review in 1-5 stars."""
  rating: Rating!

  """Flag if review is visible, by default set to true."""
  isVisible: Boolean
}

"""Input for the createShipmentMethod mutation."""
input CreateShipmentMethodInput
  @join__type(graph: SHIPMENT)
{
  """The base fees for the shipment method."""
  baseFees: Int!

  """The description of the shipment method."""
  description: String!

  """
  The reference of the shipment method used by the external shipment provider.
  """
  externalReference: String!

  """The fees per item for the shipment method."""
  feesPerItem: Int!

  """The fees per kg for the shipment method."""
  feesPerKg: Int!

  """The name of the shipment method."""
  name: String!
}

input CreateShoppingCartItemInput
  @join__type(graph: SHOPPINGCART)
{
  """UUID of user owning the shopping cart."""
  id: UUID!

  """shopping cart item in shopping cart to update"""
  shoppingCartItem: ShoppingCartItemInput!
}

"""Input for the createTaxRate mutation"""
input CreateTaxRateInput
  @join__type(graph: TAX)
{
  """The description of the created TaxRate"""
  description: String!

  """The initial version of the created TaxRate"""
  initialVersion: TaxRateVersionInput!

  """The name of the created TaxRate"""
  name: String!
}

"""Input for the createTaxRateVersion mutation"""
input CreateTaxRateVersionInput
  @join__type(graph: TAX)
{
  """The rate of the created TaxRateVersion"""
  rate: Float!

  """The id of the TaxRate the created TaxRateVersion belongs to"""
  taxRateId: UUID!
}

"""Input for the createUserAddress mutation."""
input CreateUserAddressInput
  @join__type(graph: ADDRESS)
{
  """The city part of the address to create"""
  city: String!

  """The company name part of the address to create"""
  companyName: String

  """The country part of the address to create"""
  country: String!

  """The name of the address to create"""
  name: NameInput

  """The postal code part of the address to create"""
  postalCode: String!

  """The first part of the street part of the address to create"""
  street1: String!

  """The second part of the street part of the address to create"""
  street2: String!

  """The id of the user to create the address for."""
  userId: UUID!
}

"""Input for the createVendorAddress mutation."""
input CreateVendorAddressInput
  @join__type(graph: ADDRESS)
{
  """The city part of the address to create"""
  city: String!

  """The company name part of the address to create"""
  companyName: String

  """The country part of the address to create"""
  country: String!

  """The name of the address to create"""
  name: NameInput

  """The postal code part of the address to create"""
  postalCode: String!

  """The first part of the street part of the address to create"""
  street1: String!

  """The second part of the street part of the address to create"""
  street2: String!
}

input CreateWishlistInput
  @join__type(graph: WISHLIST)
{
  """UUID of user owning the wishlist."""
  userId: UUID!

  """UUIDs of product variants in wishlist."""
  productVariantIds: [UUID!]!

  """Wishlist name."""
  name: String!
}

"""An RFC-3339 compliant Full Date Scalar"""
scalar Date
  @join__type(graph: USER)

"""A slightly refined version of RFC-3339 compliant DateTime Scalar"""
scalar DateTime
  @join__type(graph: ADDRESS)
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
  @join__type(graph: INVOICE)
  @join__type(graph: NOTIFICATION)
  @join__type(graph: ORDER)
  @join__type(graph: PAYMENT)
  @join__type(graph: RETURN)
  @join__type(graph: REVIEW)
  @join__type(graph: SHIPMENT)
  @join__type(graph: SHOPPINGCART)
  @join__type(graph: TAX)
  @join__type(graph: USER)
  @join__type(graph: WISHLIST)

"""
A discount.
Multiple discounts are applied multiplicatively:
discounted = original * (1 - discount1) * (1 - discount2) * ...
"""
type Discount implements Node
  @join__implements(graph: DISCOUNT, interface: "Node")
  @join__type(graph: DISCOUNT, key: "id", resolvable: true)
  @join__type(graph: ORDER, key: "id", resolvable: false)
{
  """
  The discount applied to the order item, e.g. 0.2 meaning a 20% reduction in price.
  Multiple discounts are applied multiplicatively:
  discounted = original * (1 - discount1) * (1 - discount2) * ...
  """
  discount: Float! @join__field(graph: DISCOUNT)

  """Get all categories to which this discount directly applies"""
  discountAppliesToCategories(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CommonOrderInput

    """Number of items to skip"""
    skip: Int
  ): CategoryConnection! @join__field(graph: DISCOUNT)

  """Get all product variants to which this discount directly applies"""
  discountAppliesToProductVariants(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CommonOrderInput

    """Number of items to skip"""
    skip: Int
  ): ProductVariantConnection! @join__field(graph: DISCOUNT)

  """Get all products to which this discount directly applies"""
  discountAppliesToProducts(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CommonOrderInput

    """Number of items to skip"""
    skip: Int
  ): ProductConnection! @join__field(graph: DISCOUNT)

  """Get all product variants to which this discount directly applies"""
  discountRequiresCoupon(
    """Filtering"""
    filter: CouponFilterInput

    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CouponOrderInput

    """Number of items to skip"""
    skip: Int
  ): CouponConnection! @join__field(graph: DISCOUNT)

  """Get all the usages of this discount by all users."""
  discountUsages(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: DiscountUsageOrderInput

    """Number of items to skip"""
    skip: Int
  ): DiscountUsageConnection! @join__field(graph: DISCOUNT)

  """The ID of the node."""
  id: UUID!

  """
  The maximum number of times a user can use this discount in bought ProductItems.
  """
  maxUsagesPerUser: Int @join__field(graph: DISCOUNT)

  """The minimum order amount required to use this discount."""
  minOrderAmount: Int @join__field(graph: DISCOUNT)

  """The date and time from which the discount is valid."""
  validFrom: DateTime! @join__field(graph: DISCOUNT)

  """The date and time until which the discount is valid."""
  validUntil: DateTime! @join__field(graph: DISCOUNT)
}

"""A connection to a list of `Discount` values."""
type DiscountConnection
  @join__type(graph: DISCOUNT)
  @join__type(graph: ORDER)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [Discount!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Discount order fields"""
enum DiscountOrderField
  @join__type(graph: DISCOUNT)
{
  """Order discounts by their id"""
  ID @join__enumValue(graph: DISCOUNT)

  """Order discounts by the valid from date"""
  VALID_FROM @join__enumValue(graph: DISCOUNT)

  """Order discounts by the valid until date"""
  VALID_UNTIL @join__enumValue(graph: DISCOUNT)
}

"""Discount order"""
input DiscountOrderInput
  @join__type(graph: DISCOUNT)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: DiscountOrderField
}

"""A list of discounts for a product variant (and count)"""
type DiscountsForProductVariant
  @join__type(graph: DISCOUNT)
{
  """The number of items to which the discounts should be applied."""
  count: Int!

  """The list of applicable discounts"""
  discounts: [Discount!]!

  """The product variant id for which discounts should be computed."""
  productVariantId: UUID!
}

"""Discount usage by a user."""
type DiscountUsage implements Node
  @join__implements(graph: DISCOUNT, interface: "Node")
  @join__type(graph: DISCOUNT, key: "id", resolvable: true)
{
  """The used discount."""
  discount: Discount!

  """The ID of the node."""
  id: UUID!

  """The amount of items the user has used this discount for."""
  usages: Int!

  """The user using the discount."""
  user: User!
}

"""A connection to a list of `DiscountUsage` values."""
type DiscountUsageConnection
  @join__type(graph: DISCOUNT)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [DiscountUsage!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""DiscountUsage order fields"""
enum DiscountUsageOrderField
  @join__type(graph: DISCOUNT)
{
  """Order discount usages by their id"""
  ID @join__enumValue(graph: DISCOUNT)

  """Order discount usages by their usages"""
  USAGES @join__enumValue(graph: DISCOUNT)
}

"""DiscountUsage order"""
input DiscountUsageOrderInput
  @join__type(graph: DISCOUNT)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: DiscountUsageOrderField
}

"""Input for the findApplicableDiscounts query."""
input FindApplicableDiscountsInput
  @join__type(graph: DISCOUNT)
  @inaccessible
{
  """The order amount, used to filter applicable discounts."""
  orderAmount: Int!

  """The list of product variants for which discounts should be computed."""
  productVariants: [FindApplicableDiscountsProductVariantInput!]!

  """The user id for which discounts should be computed."""
  userId: UUID!
}

"""
Triple of a product variant id, a count, and a list of coupon ids for which discounts should be computed
"""
input FindApplicableDiscountsProductVariantInput
  @join__type(graph: DISCOUNT)
  @inaccessible
{
  """The number of items to which the discounts should be applied."""
  count: Int!

  """The list of coupon ids for which discounts should be computed."""
  couponIds: [UUID!]!

  """The product variant id for which discounts should be computed."""
  productVariantId: UUID!
}

"""The gender of a user"""
enum Gender
  @join__type(graph: USER)
{
  """Diverse gender"""
  DIVERSE @join__enumValue(graph: USER)

  """Female gender"""
  FEMALE @join__enumValue(graph: USER)

  """Male gender"""
  MALE @join__enumValue(graph: USER)

  """Other gender"""
  OTHER @join__enumValue(graph: USER)
}

"""Invoice of an order."""
type Invoice
  @join__type(graph: INVOICE, key: "id")
{
  id: UUID!
  orderId: UUID!
  issuedAt: DateTime!
  content: String!
  userAddress: UserAddress!
  vendorAddress: VendorAddress!
  vatNumber: String
}

scalar join__FieldSet

enum join__Graph {
  ADDRESS @join__graph(name: "address", url: "http://localhost:3500/v1.0/invoke/address/method/graphql")
  CATALOG @join__graph(name: "catalog", url: "http://localhost:3500/v1.0/invoke/catalog/method/graphql")
  DISCOUNT @join__graph(name: "discount", url: "http://localhost:3500/v1.0/invoke/discount/method/graphql")
  INVENTORY @join__graph(name: "inventory", url: "http://localhost:3500/v1.0/invoke/inventory/method/graphql")
  INVOICE @join__graph(name: "invoice", url: "http://localhost:3500/v1.0/invoke/invoice/method/")
  MEDIA @join__graph(name: "media", url: "http://localhost:3500/v1.0/invoke/media/method/")
  NOTIFICATION @join__graph(name: "notification", url: "http://localhost:3500/v1.0/invoke/notification/method/graphql")
  ORDER @join__graph(name: "order", url: "http://localhost:3500/v1.0/invoke/order/method/")
  PAYMENT @join__graph(name: "payment", url: "http://localhost:3500/v1.0/invoke/payment/method/graphql")
  RETURN @join__graph(name: "return", url: "http://localhost:3500/v1.0/invoke/return/method/graphql")
  REVIEW @join__graph(name: "review", url: "http://localhost:3500/v1.0/invoke/review/method/")
  SHIPMENT @join__graph(name: "shipment", url: "http://localhost:3500/v1.0/invoke/shipment/method/graphql")
  SHOPPINGCART @join__graph(name: "shoppingcart", url: "http://localhost:3500/v1.0/invoke/shoppingcart/method/")
  TAX @join__graph(name: "tax", url: "http://localhost:3500/v1.0/invoke/tax/method/graphql")
  USER @join__graph(name: "user", url: "http://localhost:3500/v1.0/invoke/user/method/graphql")
  WISHLIST @join__graph(name: "wishlist", url: "http://localhost:3500/v1.0/invoke/wishlist/method/")
}

"""
The `JSONObject` scalar type represents JSON objects as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).
"""
scalar JSONObject
  @join__type(graph: PAYMENT)

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
}

"""A Media file."""
type Media implements Node
  @join__implements(graph: CATALOG, interface: "Node")
  @join__type(graph: CATALOG, key: "id", resolvable: false)
  @join__type(graph: MEDIA, key: "id")
{
  """The ID of the node."""
  id: UUID!

  """Pre-signed path for the media."""
  path: String! @join__field(graph: MEDIA)
}

"""A connection to a list of `Media` values."""
type MediaConnection
  @join__type(graph: CATALOG)
  @join__type(graph: MEDIA)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [Media!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

type Mutation
  @join__type(graph: ADDRESS)
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
  @join__type(graph: INVENTORY)
  @join__type(graph: MEDIA)
  @join__type(graph: NOTIFICATION)
  @join__type(graph: ORDER)
  @join__type(graph: PAYMENT)
  @join__type(graph: RETURN)
  @join__type(graph: REVIEW)
  @join__type(graph: SHIPMENT)
  @join__type(graph: SHOPPINGCART)
  @join__type(graph: TAX)
  @join__type(graph: USER)
  @join__type(graph: WISHLIST)
{
  """Archive a user address"""
  archiveUserAddress(
    """Input for the archiveUserAddress mutation"""
    input: ArchiveUserAddressInput!
  ): UserAddress! @join__field(graph: ADDRESS)

  """Create a new user address"""
  createUserAddress(
    """Input for the createUserAddress mutation"""
    input: CreateUserAddressInput!
  ): UserAddress! @join__field(graph: ADDRESS)

  """Create a new vendor address"""
  createVendorAddress(
    """Input for the createVendorAddress mutation"""
    input: CreateVendorAddressInput!
  ): VendorAddress! @join__field(graph: ADDRESS)

  """
  Create a new value for a characteristic whose values have no further meaning
  """
  createCategoricalCategoryCharacteristic(
    """Input for the createCategoricalCategoryCharacteristic mutation"""
    input: CreateCategoricalCategoryCharacteristicInput!
  ): CategoricalCategoryCharacteristic! @join__field(graph: CATALOG)

  """Create a new category"""
  createCategory(
    """Input for the createCategory mutation"""
    input: CreateCategoryInput!
  ): Category! @join__field(graph: CATALOG)

  """Create a new numerical category characteristic"""
  createNumericalCategoryCharacteristic(
    """Input for the createNumericalCategoryCharacteristic mutation"""
    input: CreateNumericalCategoryCharacteristicInput!
  ): NumericalCategoryCharacteristic! @join__field(graph: CATALOG)

  """Create a new product"""
  createProduct(
    """Input for the createProduct mutation"""
    input: CreateProductInput!
  ): Product! @join__field(graph: CATALOG)

  """Create a new product variant"""
  createProductVariant(
    """Input for the createProductVariant mutation"""
    input: CreateProductVariantInput!
  ): ProductVariant! @join__field(graph: CATALOG)

  """Create a new product variant version"""
  createProductVariantVersion(
    """Input for the createProductVariantVersion mutation"""
    input: CreateProductVariantVersionInput!
  ): ProductVariantVersion! @join__field(graph: CATALOG)

  """Update a product"""
  updateProduct(
    """Input for the updateProduct mutation"""
    input: UpdateProductInput!
  ): Product! @join__field(graph: CATALOG)

  """Update a product variant"""
  updateProductVariant(
    """Input for the updateProductVariant mutation"""
    input: UpdateProductVariantInput!
  ): ProductVariant! @join__field(graph: CATALOG)

  """Create a new coupon"""
  createCoupon(
    """Input for the createCoupon mutation"""
    input: CreateCouponInput!
  ): Coupon! @join__field(graph: DISCOUNT)

  """Create a new discount"""
  createDiscount(
    """Input for the createDiscount mutation"""
    input: CreateDiscountInput!
  ): Discount! @join__field(graph: DISCOUNT)

  """Register a coupon"""
  registerCoupon(
    """Input for the registerCoupon mutation"""
    input: RegisterCouponInput!
  ): Coupon! @join__field(graph: DISCOUNT)

  """Update a coupon"""
  updateCoupon(
    """Input for the updateCoupon mutation"""
    input: UpdateCouponInput!
  ): Coupon! @join__field(graph: DISCOUNT)

  """Update a discount"""
  updateDiscount(
    """Input for the updateDiscount mutation"""
    input: UpdateDiscountInput!
  ): Discount! @join__field(graph: DISCOUNT)

  """
  Adds a batch of product items with the specified productVartiantId of size number
  """
  createProductItemBatch(input: CreateProductItemBatchInput!): [ProductItem!]! @join__field(graph: INVENTORY)

  """
  Updates storage state, productVariant of a specific product item referenced with an Id
  """
  updateProductItem(input: UpdateProductItemInput!): ProductItem! @join__field(graph: INVENTORY)

  """Deletes a product item by id"""
  deleteProductItem(
    """UUID of product item to delete"""
    id: UUID!
  ): ProductItem! @join__field(graph: INVENTORY)

  """Reserves a batch of product items of a chosen product variant"""
  reserveProductItemBatch(input: ReserveProductItemsBatchInput!): [ProductItem!]! @join__field(graph: INVENTORY)

  """
  Uploads a media to MinIO.
  
  Saves the file under a new UUID with its suitable file extension in MinIO.
  Sends an event when a media file was uploaded.
  """
  uploadMedia(
    """Media file to upload."""
    mediaFile: Upload!
  ): UUID! @join__field(graph: MEDIA)

  """Create a new notification"""
  createNotification(
    """Input for the createNotification mutation"""
    input: CreateNotificationInput!
  ): Notification! @join__field(graph: NOTIFICATION)

  """Update a notification"""
  updateNotification(
    """Input for the updateNotification mutation"""
    input: UpdateNotificationInput!
  ): Notification! @join__field(graph: NOTIFICATION)

  """Creates an order with `OrderStatus::Pending`."""
  createOrder(
    """CreateOrderInput"""
    input: CreateOrderInput!
  ): Order! @join__field(graph: ORDER)

  """
  Places an existing order by changing its status to `OrderStatus::Placed`.
  
  Adds optional payment authorization input to order DTO when placing order.
  """
  placeOrder(
    """PlaceOrderInput"""
    input: PlaceOrderInput!
  ): Order! @join__field(graph: ORDER)

  """Adds a credit card to the users stored payment informations"""
  createCreditCardPaymentInformation(input: CreateCreditCardInformationInput!): PaymentInformation! @join__field(graph: PAYMENT)

  """Deletes a payment information by id"""
  deletePaymentInformation(
    """UUID of payment information to delete"""
    id: UUID!
  ): PaymentInformation! @join__field(graph: PAYMENT)

  """Deletes a payment by id"""
  deletePayment(
    """UUID of payment to delete"""
    id: UUID!
  ): Payment! @join__field(graph: PAYMENT)

  """Create a new return"""
  createReturn(
    """Input for the createReturn mutation"""
    input: CreateReturnInput!
  ): Return! @join__field(graph: RETURN)

  """
  Adds a review for a user and a product variant with a content, rating and visibility.
  """
  createReview(
    """CreateReviewInput"""
    input: CreateReviewInput!
  ): Review! @join__field(graph: REVIEW)

  """Updates a specific review referenced with an UUID."""
  updateReview(
    """UpdateReviewInput"""
    input: UpdateReviewInput!
  ): Review! @join__field(graph: REVIEW)

  """Deletes review of UUID."""
  deleteReview(
    """UUID of review to delete."""
    id: UUID!
  ): Boolean! @join__field(graph: REVIEW)

  """Archive a shipment method"""
  archiveShipmentMethod(
    """Input for the archiveShipmentMethod mutation"""
    input: ArchiveShipmentMethodInput!
  ): ShipmentMethod! @join__field(graph: SHIPMENT)

  """Create a new shipment method"""
  createShipmentMethod(
    """Input for the createShipmentMethod mutation"""
    input: CreateShipmentMethodInput!
  ): ShipmentMethod! @join__field(graph: SHIPMENT)

  """
  Updates shopping cart items of a specific shopping cart referenced with a UUID.
  
  Formats UUIDs as hyphenated lowercase strings.
  """
  updateShoppingcart(
    """UpdateShoppingCartInput"""
    input: UpdateShoppingCartInput!
  ): ShoppingCart! @join__field(graph: SHOPPINGCART)

  """
  Adds shopping cart item to a shopping cart.
  
  Queries for existing item, otherwise adds new shoppingcart item.
  """
  createShoppingcartItem(
    """CreateShoppingCartItemInput"""
    input: CreateShoppingCartItemInput!
  ): ShoppingCartItem! @join__field(graph: SHOPPINGCART)

  """Updates a single shopping cart item."""
  updateShoppingcartItem(
    """UpdateShoppingCartItemInput"""
    input: UpdateShoppingCartItemInput!
  ): ShoppingCartItem! @join__field(graph: SHOPPINGCART)

  """Deletes shoppingcart item of UUID."""
  deleteShoppingcartItem(
    """UUID of shoppingcart item to delete."""
    id: UUID!
  ): Boolean! @join__field(graph: SHOPPINGCART)

  """Creates a new TaxRate"""
  createTaxRate(
    """Input for the createTaxRate mutation"""
    input: CreateTaxRateInput!
  ): TaxRate! @join__field(graph: TAX)

  """Creates a new TaxRateVersion"""
  createTaxRateVersion(
    """Input for the createTaxRateVersion mutation"""
    input: CreateTaxRateVersionInput!
  ): TaxRateVersion! @join__field(graph: TAX)

  """Updates a TaxRate"""
  updateTaxRate(
    """Input for the updateTaxRate mutation"""
    input: UpdateTaxRateInput!
  ): TaxRate! @join__field(graph: TAX)
  updateUser(
    """Input for the updateUser mutation"""
    input: UpdateUserInput!
  ): User! @join__field(graph: USER)

  """
  Adds a wishlist with a user_id, a list of product_variant_ids and a name.
  
  Formats UUIDs as hyphenated lowercase strings.
  """
  createWishlist(
    """CreateWishlistInput"""
    input: CreateWishlistInput!
  ): Wishlist! @join__field(graph: WISHLIST)

  """
  Updates name and/or product_variant_ids of a specific wishlist referenced with an UUID.
  
  Formats UUIDs as hyphenated lowercase strings.
  """
  updateWishlist(
    """UpdateWishlistInput"""
    input: UpdateWishlistInput!
  ): Wishlist! @join__field(graph: WISHLIST)

  """Deletes wishlist of UUID."""
  deleteWishlist(
    """UUID of wishlist to delete."""
    id: UUID!
  ): Boolean! @join__field(graph: WISHLIST)
}

"""A name consisting of a firstName and lastName."""
type Name
  @join__type(graph: ADDRESS)
  @join__type(graph: USER)
{
  """The first name of the user"""
  firstName: String!

  """The last name of the user"""
  lastName: String!
}

"""A name consisting of a firstName and lastName."""
input NameInput
  @join__type(graph: ADDRESS)
{
  """The first name of the user"""
  firstName: String!

  """The last name of the user"""
  lastName: String!
}

"""An object with an ID."""
interface Node
  @join__type(graph: ADDRESS)
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
  @join__type(graph: NOTIFICATION)
  @join__type(graph: RETURN)
  @join__type(graph: SHIPMENT)
  @join__type(graph: TAX)
  @join__type(graph: USER)
{
  """The ID of the node."""
  id: UUID!
}

"""A notification."""
type Notification implements Node
  @join__implements(graph: NOTIFICATION, interface: "Node")
  @join__type(graph: NOTIFICATION, key: "id", resolvable: true)
{
  """The content of the notification"""
  body: String!

  """The date the notification was read"""
  dateRead: DateTime

  """The date the notification was sent"""
  dateSent: DateTime!

  """The ID of the node."""
  id: UUID!

  """Whether the notification has been read"""
  isRead: Boolean!

  """The title of the notification"""
  title: String!

  """The user this notification was sent to."""
  user: User!
}

"""A connection to a list of `Notification` values."""
type NotificationConnection
  @join__type(graph: NOTIFICATION)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [Notification!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Notification order fields"""
enum NotificationOrderField
  @join__type(graph: NOTIFICATION)
{
  """Order notifications by their id"""
  ID @join__enumValue(graph: NOTIFICATION)
}

"""Notification order"""
input NotificationOrderInput
  @join__type(graph: NOTIFICATION)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: NotificationOrderField
}

"""A numerical characteristic of a Category."""
type NumericalCategoryCharacteristic implements CategoryCharacteristic & Node
  @join__implements(graph: CATALOG, interface: "CategoryCharacteristic")
  @join__implements(graph: CATALOG, interface: "Node")
  @join__type(graph: CATALOG, key: "id", resolvable: true)
{
  """The Category this item belongs to."""
  category: Category!

  """The description of the CategoryCharacteristic."""
  description: String!

  """The ID of the node."""
  id: UUID!

  """The name of the CategoryCharacteristic."""
  name: String!

  """The unit of the NumericalCategoryCharacteristic."""
  unit: String!
}

"""
Input to create a characteristic whose values have arithmetic meaning, i.e. '8GB'
"""
input NumericalCategoryCharacteristicInput
  @join__type(graph: CATALOG)
{
  """The description of the NumericalCategoryCharacteristic"""
  description: String!

  """The name of the NumericalCategoryCharacteristic"""
  name: String!

  """The unit of the NumericalCategoryCharacteristic"""
  unit: String!
}

"""A numerical value of a NumericalCategoryCharacteristic."""
type NumericalCategoryCharacteristicValue implements CategoryCharacteristicValue
  @join__implements(graph: CATALOG, interface: "CategoryCharacteristicValue")
  @join__type(graph: CATALOG)
{
  """The associated CategoryCharacteristic this is a value of."""
  characteristic: CategoryCharacteristic!

  """The value of the NumericalCategoryCharacteristic."""
  value: Float!
}

"""Input for creating a NumericalCategoryCharacteristicValue."""
input NumericalCategoryCharacteristicValueInput
  @join__type(graph: CATALOG)
{
  """The id of the CategoryCharacteristic."""
  characteristicId: UUID!

  """The value of the NumericalCategoryCharacteristicValue."""
  value: Float!
}

"""Foreign type of an order."""
type Order implements Node
  @join__implements(graph: RETURN, interface: "Node")
  @join__implements(graph: SHIPMENT, interface: "Node")
  @join__type(graph: INVOICE, key: "id")
  @join__type(graph: ORDER, key: "id")
  @join__type(graph: RETURN, key: "id", resolvable: true)
  @join__type(graph: SHIPMENT, key: "id", resolvable: true)
{
  """The ID of the node."""
  id: UUID!

  """Invoice of the order."""
  invoice: Invoice! @join__field(graph: INVOICE)

  """User owning order."""
  user: User! @join__field(graph: ORDER)

  """Timestamp when order was created."""
  createdAt: DateTime! @join__field(graph: ORDER)

  """The status of the order."""
  orderStatus: OrderStatus! @join__field(graph: ORDER)

  """Timestamp of order placement. `None` until order is placed."""
  placedAt: DateTime @join__field(graph: ORDER)

  """
  The rejection reason if status of the order is `OrderStatus::Rejected`.
  """
  rejectionReason: RejectionReason @join__field(graph: ORDER)

  """Address of invoice."""
  invoiceAddress: UserAddress! @join__field(graph: ORDER)

  """Total compensatable amount of order."""
  compensatableOrderAmount: Int! @join__field(graph: ORDER)

  """UUID of payment information that the order should be processed with."""
  paymentInformationId: UUID! @join__field(graph: ORDER)

  """Retrieves order items."""
  orderItems(
    """Describes that the `first` N order items should be retrieved."""
    first: Int

    """Describes how many order items should be skipped at the beginning."""
    skip: Int

    """Specifies the order in which order items are retrieved."""
    orderBy: CommonOrderInput
  ): OrderItemConnection! @join__field(graph: ORDER)

  """Get all associated Shipments"""
  shipments(
    """Filtering"""
    filter: ShipmentFilterInput

    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: ShipmentOrderInput

    """Number of items to skip"""
    skip: Int
  ): ShipmentConnection! @join__field(graph: SHIPMENT)
}

"""A connection of orders."""
type OrderConnection
  @join__type(graph: ORDER)
{
  """The resulting entities."""
  nodes: [Order!]!

  """Whether this connection has a next page."""
  hasNextPage: Boolean!

  """The total amount of items in this connection."""
  totalCount: Int!
}

"""Order direction"""
enum OrderDirection
  @join__type(graph: ADDRESS)
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
  @join__type(graph: INVENTORY)
  @join__type(graph: NOTIFICATION)
  @join__type(graph: ORDER)
  @join__type(graph: PAYMENT)
  @join__type(graph: RETURN)
  @join__type(graph: REVIEW)
  @join__type(graph: SHIPMENT)
  @join__type(graph: SHOPPINGCART)
  @join__type(graph: TAX)
  @join__type(graph: USER)
  @join__type(graph: WISHLIST)
{
  """Ascending order"""
  ASC @join__enumValue(graph: ADDRESS) @join__enumValue(graph: CATALOG) @join__enumValue(graph: DISCOUNT) @join__enumValue(graph: INVENTORY) @join__enumValue(graph: NOTIFICATION) @join__enumValue(graph: ORDER) @join__enumValue(graph: PAYMENT) @join__enumValue(graph: RETURN) @join__enumValue(graph: REVIEW) @join__enumValue(graph: SHIPMENT) @join__enumValue(graph: SHOPPINGCART) @join__enumValue(graph: TAX) @join__enumValue(graph: USER) @join__enumValue(graph: WISHLIST)

  """Descending order"""
  DESC @join__enumValue(graph: ADDRESS) @join__enumValue(graph: CATALOG) @join__enumValue(graph: DISCOUNT) @join__enumValue(graph: INVENTORY) @join__enumValue(graph: NOTIFICATION) @join__enumValue(graph: ORDER) @join__enumValue(graph: PAYMENT) @join__enumValue(graph: RETURN) @join__enumValue(graph: REVIEW) @join__enumValue(graph: SHIPMENT) @join__enumValue(graph: SHOPPINGCART) @join__enumValue(graph: TAX) @join__enumValue(graph: USER) @join__enumValue(graph: WISHLIST)
}

"""Describes an order item of an order."""
type OrderItem implements Node
  @join__implements(graph: RETURN, interface: "Node")
  @join__implements(graph: SHIPMENT, interface: "Node")
  @join__type(graph: ORDER, key: "id")
  @join__type(graph: RETURN, key: "id", resolvable: true)
  @join__type(graph: SHIPMENT, key: "id", resolvable: true)
{
  """The ID of the node."""
  id: UUID!

  """Timestamp when order item was created."""
  createdAt: DateTime! @join__field(graph: ORDER)

  """Product variant associated with order item."""
  productVariant: ProductVariant! @join__field(graph: ORDER)

  """Product variant version associated with order item."""
  productVariantVersion: ProductVariantVersion! @join__field(graph: ORDER)

  """Tax rate version associated with order item."""
  taxRateVersion: TaxRateVersion! @join__field(graph: ORDER)

  """Shopping cart item associated with order item."""
  shoppingCartItem: ShoppingCartItem! @join__field(graph: ORDER)

  """Specifies the quantity of the order item."""
  count: Int! @join__field(graph: ORDER)

  """Total cost of product item, which can also be refunded."""
  compensatableAmount: Int! @join__field(graph: ORDER)

  """Shipment method of order item."""
  shipmentMethod: ShipmentMethod! @join__field(graph: ORDER)

  """Retrieves discounts."""
  discounts(
    """Describes that the `first` N discounts should be retrieved."""
    first: Int

    """Describes how many discounts should be skipped at the beginning."""
    skip: Int

    """Specifies the order in which discounts are retrieved."""
    orderBy: CommonOrderInput
  ): DiscountConnection! @join__field(graph: ORDER)

  """The return this order item was returned with."""
  returnedWith: Return @join__field(graph: RETURN)

  """The shipment this order item was originally sent with."""
  sentWith: Shipment @join__field(graph: SHIPMENT)
}

"""A connection to a list of `OrderItem` values."""
type OrderItemConnection
  @join__type(graph: ORDER)
  @join__type(graph: RETURN)
  @join__type(graph: SHIPMENT)
{
  """The resulting items."""
  nodes: [OrderItem!]!

  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The total amount of items in this connection"""
  totalCount: Int!
}

input OrderItemInput
  @join__type(graph: ORDER)
{
  """UUID of shopping cart item associated with order item."""
  shoppingCartItemId: UUID!

  """UUID of shipment method to use with order item."""
  shipmentMethodId: UUID!

  """UUIDs of coupons to use with order item."""
  couponIds: [UUID!]!
}

"""OrderItem order fields"""
enum OrderItemOrderField
  @join__type(graph: SHIPMENT)
{
  """Order order items by their id"""
  ID @join__enumValue(graph: SHIPMENT)
}

"""OrderItem order"""
input OrderItemOrderInput
  @join__type(graph: SHIPMENT)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: OrderItemOrderField
}

"""Describes the fields that a order can be ordered by."""
enum OrderOrderField
  @join__type(graph: ORDER)
{
  """Orders by "id"."""
  ID @join__enumValue(graph: ORDER)

  """Orders by "user_id"."""
  USER_ID @join__enumValue(graph: ORDER)

  """Orders by "name"."""
  NAME @join__enumValue(graph: ORDER)

  """Orders by "created_at"."""
  CREATED_AT @join__enumValue(graph: ORDER)

  """Orders by "last_updated_at"."""
  LAST_UPDATED_AT @join__enumValue(graph: ORDER)
}

"""Specifies the order of orders."""
input OrderOrderInput
  @join__type(graph: ORDER)
{
  """Order direction of orders."""
  direction: OrderDirection

  """Field that orders should be ordered by."""
  field: OrderOrderField
}

"""
Describes if order is placed, or yet pending. An order can be rejected during its lifetime.
"""
enum OrderStatus
  @join__type(graph: ORDER)
{
  """
  Order is saved a a template, this status can only last for max. 1 hour.
  """
  PENDING @join__enumValue(graph: ORDER)

  """
  Order is placed, which means SAGA for payment, fullfill and other validity checks need to be triggered.
  """
  PLACED @join__enumValue(graph: ORDER)

  """
  Something went wrong with the order and it was compensated in all relevant serivces.
  """
  REJECTED @join__enumValue(graph: ORDER)
}

"""A payment of an invoice or return"""
type Payment
  @join__type(graph: PAYMENT, key: "id")
{
  """The uuid identifier of the payment"""
  id: UUID!

  """Payment Amount in the smallest currency unit (e.g. cents)"""
  totalAmount: Float!

  """Status of the payment"""
  status: PaymentStatus!

  """Used Payment Information"""
  paymentInformation: PaymentInformation!

  """Date of the payment"""
  payedAt: DateTime

  """Number of retries for the payment process"""
  numberOfRetries: Float!
}

input PaymentAuthorizationInput
  @join__type(graph: ORDER)
{
  """CVC/CVV number of 3-4 digits."""
  cvc: Int
}

"""A connection of payments"""
type PaymentConnection
  @join__type(graph: PAYMENT)
{
  """The resulting items"""
  nodes: [Payment!]

  """The total amount of items in this connection"""
  totalCount: Int!

  """Whether this connection has a next page"""
  hasNextPage: Boolean!
}

"""Filtering options for payments"""
input PaymentFilter
  @join__type(graph: PAYMENT)
{
  """Current payment status"""
  status: PaymentStatus

  """Payment Information ID"""
  paymentInformationId: String

  """Payment method"""
  paymentMethod: PaymentMethod

  """Timebox start for payment creation"""
  from: DateTime

  """Timebox end for payment creation"""
  to: DateTime
}

"""A stored payment information of an user"""
type PaymentInformation
  @join__type(graph: PAYMENT, key: "id")
{
  """The uuid identifier of the payment information"""
  id: UUID!

  """The corresponding payment method"""
  paymentMethod: PaymentMethod!

  """The details for the User to identify the payment method"""
  publicMethodDetails: JSONObject

  """The user who owns the payment information"""
  user: User!

  """A connection for an users payments made with a payment information."""
  payments(
    """Number of items to skip"""
    skip: Int = 0

    """Number of items to return"""
    first: Int = 2147483647

    """Ordering"""
    orderBy: PaymentOrder

    """Filtering"""
    filter: PaymentFilter
  ): PaymentConnection
}

"""A connection of payment informations"""
type PaymentInformationConnection
  @join__type(graph: PAYMENT)
{
  """The resulting items"""
  nodes: [PaymentInformation!]

  """The total amount of items in this connection"""
  totalCount: Int!

  """Whether this connection has a next page"""
  hasNextPage: Boolean!
}

"""Filtering options for payment informations"""
input PaymentInformationFilter
  @join__type(graph: PAYMENT)
{
  """Connected user id"""
  user: UUID

  """Linked payment method"""
  paymentMethod: PaymentMethod
}

"""Ordering options for payment informations"""
input PaymentInformationOrder
  @join__type(graph: PAYMENT)
{
  """The field to order by"""
  field: PaymentInformationOrderField

  """The direction to order by"""
  direction: OrderDirection
}

"""The field to order payment informations by"""
enum PaymentInformationOrderField
  @join__type(graph: PAYMENT)
{
  """Order payment informations by their id"""
  ID @join__enumValue(graph: PAYMENT)
}

"""The supported payment methods"""
enum PaymentMethod
  @join__type(graph: PAYMENT)
{
  """The user pays after ordering the product"""
  INVOICE @join__enumValue(graph: PAYMENT)

  """The user pays before the product is shipped"""
  PREPAYMENT @join__enumValue(graph: PAYMENT)

  """The amount is charged to the users credit card"""
  CREDIT_CARD @join__enumValue(graph: PAYMENT)
}

"""Ordering options for payments"""
input PaymentOrder
  @join__type(graph: PAYMENT)
{
  """The field to order by"""
  field: PaymentOrderField

  """The direction to order by"""
  direction: OrderDirection
}

"""The field to order Payments by"""
enum PaymentOrderField
  @join__type(graph: PAYMENT)
{
  """Order Payments by their ID"""
  ID @join__enumValue(graph: PAYMENT)
}

"""The status of an payment of an invoice or return"""
enum PaymentStatus
  @join__type(graph: PAYMENT)
{
  """The payment was created but not yet processed"""
  OPEN @join__enumValue(graph: PAYMENT)

  """The payment is currently being processed"""
  PENDING @join__enumValue(graph: PAYMENT)

  """The payment was successfully processed and the amount was transfered"""
  SUCCEEDED @join__enumValue(graph: PAYMENT)

  """The payment processing failed indefinetely"""
  FAILED @join__enumValue(graph: PAYMENT)

  """The payment was sold to external inkasso service"""
  INKASSO @join__enumValue(graph: PAYMENT)
}

input PlaceOrderInput
  @join__type(graph: ORDER)
{
  """UUID of order to place."""
  id: UUID!

  """Optional payment authorization data."""
  paymentAuthorization: PaymentAuthorizationInput
}

"""A product."""
type Product implements Node
  @join__implements(graph: CATALOG, interface: "Node")
  @join__implements(graph: DISCOUNT, interface: "Node")
  @join__type(graph: CATALOG, key: "id", resolvable: true)
  @join__type(graph: DISCOUNT, key: "id", resolvable: true)
  @join__type(graph: REVIEW, key: "id")
{
  """Get all associated Categories"""
  categories(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CategoryOrderInput

    """Number of items to skip"""
    skip: Int
  ): CategoryConnection! @join__field(graph: CATALOG)

  """The default variant of the product."""
  defaultVariant: ProductVariant! @join__field(graph: CATALOG)

  """The ID of the node."""
  id: UUID!

  """An internal name to identify the Product, not visible to customers."""
  internalName: String! @join__field(graph: CATALOG)

  """If true, the Product is visible to customers."""
  isPubliclyVisible: Boolean! @join__field(graph: CATALOG)

  """Get all associated ProductVariants"""
  variants(
    """Filtering"""
    filter: ProductVariantFilterInput

    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: ProductVariantOrderInput

    """Number of items to skip"""
    skip: Int
  ): ProductVariantConnection! @join__field(graph: CATALOG)

  """Get all discounts which apply directly to this product"""
  discounts(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: DiscountOrderInput

    """Number of items to skip"""
    skip: Int
  ): DiscountConnection! @join__field(graph: DISCOUNT)

  """Retrieves reviews of product."""
  reviews(
    """Describes that the `first` N reviews should be retrieved."""
    first: Int

    """Describes how many reviews should be skipped at the beginning."""
    skip: Int

    """Specifies the order in which reviews are retrieved."""
    orderBy: ReviewOrderInput
  ): ReviewConnection! @join__field(graph: REVIEW)

  """Retrieves average rating of product."""
  averageRating: Float @join__field(graph: REVIEW)
}

"""A connection to a list of `Product` values."""
type ProductConnection
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [Product!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Product filter"""
input ProductFilterInput
  @join__type(graph: CATALOG)
{
  isPubliclyVisible: Boolean
}

"""A product Item of a product variant"""
type ProductItem
  @join__type(graph: INVENTORY, key: "id")
{
  """The uuid identifier of the product item"""
  id: UUID!

  """The corresponding product variant"""
  productVariant: ProductVariant!

  """Describes the inventory status of the product item"""
  inventoryStatus: ProductItemStatus!

  """Reference to the order that reserved the product item"""
  orderId: UUID
}

"""A connection of product items"""
type ProductItemConnection
  @join__type(graph: INVENTORY)
{
  """The resulting items"""
  nodes: [ProductItem!]

  """The total amount of items in this connection"""
  totalCount: Int!

  """Whether this connection has a next page"""
  hasNextPage: Boolean!
}

"""Filtering options for product items"""
input ProductItemFilter
  @join__type(graph: INVENTORY)
{
  """Linked product variant id"""
  productVariant: UUID

  """Current product item status"""
  inventoryStatus: ProductItemStatus
}

"""Filtering options for product items of product variants"""
input ProductItemOfProductVariantFilter
  @join__type(graph: INVENTORY)
{
  """Current product item status"""
  inventoryStatus: ProductItemStatus
}

"""Ordering options for product items"""
input ProductItemOrder
  @join__type(graph: INVENTORY)
{
  """The field to order by"""
  field: ProductItemOrderField

  """The direction to order by"""
  direction: OrderDirection
}

"""The field to order Product Items by"""
enum ProductItemOrderField
  @join__type(graph: INVENTORY)
{
  """Order Product Items by their ID"""
  ID @join__enumValue(graph: INVENTORY)
}

"""The status of an individual product item in the inventory"""
enum ProductItemStatus
  @join__type(graph: INVENTORY)
{
  """The item is in storage, not yet sold or reserved"""
  IN_STORAGE @join__enumValue(graph: INVENTORY)

  """The item has been reserved for a customer but not yet sold"""
  RESERVED @join__enumValue(graph: INVENTORY)

  """The item is in the process of being fulfilled (packed, shipped)"""
  IN_FULFILLMENT @join__enumValue(graph: INVENTORY)

  """The item has been shipped to the customer"""
  SHIPPED @join__enumValue(graph: INVENTORY)

  """The item has been delivered to the customer"""
  DELIVERED @join__enumValue(graph: INVENTORY)

  """The item has been returned by the customer"""
  RETURNED @join__enumValue(graph: INVENTORY)

  """The item has been lost (e.g., during shipping or in the warehouse)"""
  LOST @join__enumValue(graph: INVENTORY)
}

"""Product order fields"""
enum ProductOrderField
  @join__type(graph: CATALOG)
{
  """Order products by their id"""
  ID @join__enumValue(graph: CATALOG)

  """Order products by their internal name"""
  INTERNAL_NAME @join__enumValue(graph: CATALOG)
}

"""Product order"""
input ProductOrderInput
  @join__type(graph: CATALOG)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: ProductOrderField
}

"""Foreign type of a product variant."""
type ProductVariant implements Node
  @join__implements(graph: CATALOG, interface: "Node")
  @join__implements(graph: DISCOUNT, interface: "Node")
  @join__type(graph: CATALOG, key: "id", resolvable: true)
  @join__type(graph: DISCOUNT, key: "id", resolvable: true)
  @join__type(graph: INVENTORY, key: "id")
  @join__type(graph: ORDER, key: "id", resolvable: false)
  @join__type(graph: REVIEW, key: "id")
  @join__type(graph: SHOPPINGCART, key: "id", resolvable: false)
  @join__type(graph: WISHLIST, key: "id", resolvable: false)
{
  """The current version of the ProductVariant."""
  currentVersion: ProductVariantVersion! @join__field(graph: CATALOG)

  """UUID of the product variant."""
  id: UUID!

  """If true, the ProductVariant is visible to customers."""
  isPubliclyVisible: Boolean! @join__field(graph: CATALOG)

  """The Product belonging to this variant."""
  product: Product! @join__field(graph: CATALOG)

  """Get all associated versions"""
  versions(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: ProductVariantVersionOrderInput

    """Number of items to skip"""
    skip: Int
  ): ProductVariantVersionConnection! @join__field(graph: CATALOG)

  """
  Get all discounts which apply to this product variant for the authenticated user
  """
  applicableDiscounts(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: DiscountOrderInput

    """Number of items to skip"""
    skip: Int
  ): DiscountConnection! @join__field(graph: DISCOUNT)

  """Get all discounts which apply directly to this product variant"""
  discounts(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: DiscountOrderInput

    """Number of items to skip"""
    skip: Int
  ): DiscountConnection! @join__field(graph: DISCOUNT)

  """A product item connection for referenced product items in stock"""
  productItems(
    """Number of items to skip"""
    skip: Int = 0

    """Number of items to return"""
    first: Int = 2147483647

    """Ordering"""
    orderBy: ProductItemOrder

    """Filtering"""
    filter: ProductItemOfProductVariantFilter
  ): ProductItemConnection @join__field(graph: INVENTORY)

  """The number of product items in stock"""
  inventoryCount: Int! @join__field(graph: INVENTORY)

  """Retrieves reviews of product variant."""
  reviews(
    """Describes that the `first` N reviews should be retrieved."""
    first: Int

    """Describes how many reviews should be skipped at the beginning."""
    skip: Int

    """Specifies the order in which reviews are retrieved."""
    orderBy: ReviewOrderInput
  ): ReviewConnection! @join__field(graph: REVIEW)

  """Retrieves average rating of product variant."""
  averageRating: Float @join__field(graph: REVIEW)
}

"""A connection to a list of `ProductVariant` values."""
type ProductVariantConnection
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
  @join__type(graph: WISHLIST)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [ProductVariant!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Product variant filter"""
input ProductVariantFilterInput
  @join__type(graph: CATALOG)
{
  isPubliclyVisible: Boolean
}

"""Input for creating a product variant"""
input ProductVariantInput
  @join__type(graph: CATALOG)
{
  """The initial ProductVariantVersion of the ProductVariant."""
  initialVersion: ProductVariantVersionInput!

  """If true, the ProductVariant is visible to customers."""
  isPubliclyVisible: Boolean!
}

"""ProductVariant order fields"""
enum ProductVariantOrderField
  @join__type(graph: CATALOG)
{
  """Order productVariants by their id"""
  ID @join__enumValue(graph: CATALOG)
}

"""ProductVariant order"""
input ProductVariantOrderInput
  @join__type(graph: CATALOG)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: ProductVariantOrderField
}

"""A version of a ProductVariant."""
type ProductVariantVersion implements Node
  @join__implements(graph: CATALOG, interface: "Node")
  @join__type(graph: CATALOG, key: "id", resolvable: true)
  @join__type(graph: ORDER, key: "id", resolvable: false)
{
  """
  The amount of days for which an instance of the ProductVariantVersion can be returned after purchase, if null can be returned indefinitely.
  """
  canBeReturnedForDays: Int @join__field(graph: CATALOG)

  """Get all associated CategoryCharacteristicValues"""
  characteristicValues(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CategoryCharacteristicValueOrderInput

    """Number of items to skip"""
    skip: Int
  ): CategoryCharacteristicValueConnection! @join__field(graph: CATALOG)

  """The date when the ProductVariantVersion version was created."""
  createdAt: DateTime! @join__field(graph: CATALOG)

  """The description of the ProductVariantVersion."""
  description: String! @join__field(graph: CATALOG)

  """The ID of the node."""
  id: UUID!

  """Get all associated Medias"""
  medias(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CommonOrderInput

    """Number of items to skip"""
    skip: Int
  ): MediaConnection! @join__field(graph: CATALOG)

  """The name of the ProductVariantVersion."""
  name: String! @join__field(graph: CATALOG)

  """The ProductVariant this is a version of."""
  productVariant: ProductVariant! @join__field(graph: CATALOG)

  """The retail price of the ProductVariantVersion."""
  retailPrice: Int! @join__field(graph: CATALOG)

  """The associated TaxRate."""
  taxRate: TaxRate! @join__field(graph: CATALOG)

  """The version of the ProductVariantVersion."""
  version: Int! @join__field(graph: CATALOG)

  """The weight of the ProductVariantVersion."""
  weight: Float! @join__field(graph: CATALOG)
}

"""A connection to a list of `ProductVariantVersion` values."""
type ProductVariantVersionConnection
  @join__type(graph: CATALOG)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [ProductVariantVersion!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Input for creating a ProductVariantVersion."""
input ProductVariantVersionInput
  @join__type(graph: CATALOG)
{
  """
  The amount of days for which an instance of the ProductVariant can be returned after purchase, if null can be returned indefinitely.
  """
  canBeReturnedForDays: Int

  """
  The CategoricalCategoryCharacteristicValues of the ProductVariant, must be compatible with the Categories of the associated Product.
  """
  categoricalCharacteristicValues: [CategoricalCategoryCharacteristicValueInput!]!

  """The description of the ProductVariant."""
  description: String!

  """The associated Media files."""
  mediaIds: [UUID!]!

  """The name of the ProductVariant."""
  name: String!

  """
  The NumericalCategoryCharacteristicValues of the ProductVariant, must be compatible with the Categories of the associated Product.
  """
  numericalCharacteristicValues: [NumericalCategoryCharacteristicValueInput!]!

  """The retail price of the ProductVariant."""
  retailPrice: Int!

  """The associated TaxRate"""
  taxRateId: UUID!

  """The weight of a single instance of the ProductVariant."""
  weight: Float!
}

"""ProductVariantVersion order fields"""
enum ProductVariantVersionOrderField
  @join__type(graph: CATALOG)
{
  """Order productVariantVersions by their creation date"""
  CREATED_AT @join__enumValue(graph: CATALOG)

  """Order productVariantVersions by their id"""
  ID @join__enumValue(graph: CATALOG)

  """Order productVariantVersions by their version"""
  VERSION @join__enumValue(graph: CATALOG)
}

"""ProductVariantVersion order"""
input ProductVariantVersionOrderInput
  @join__type(graph: CATALOG)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: ProductVariantVersionOrderField
}

"""
Input for a product variant version with a quantity and shipment method.
"""
input ProductVariantVersionWithQuantityAndShipmentMethodInput
  @join__type(graph: SHIPMENT)
{
  """The product variant version id."""
  productVariantVersionId: UUID!

  """The quantity of the product variant version."""
  quantity: Int!

  """The id of the shipment method."""
  shipmentMethodId: UUID!
}

"""Input for a product variant version with a quantity."""
input ProductVariantVersionWithQuantityInput
  @join__type(graph: SHIPMENT)
{
  """The product variant version id."""
  productVariantVersionId: UUID!

  """The quantity of the product variant version."""
  quantity: Int!
}

type Query
  @join__type(graph: ADDRESS)
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
  @join__type(graph: INVENTORY)
  @join__type(graph: INVOICE)
  @join__type(graph: MEDIA)
  @join__type(graph: NOTIFICATION)
  @join__type(graph: ORDER)
  @join__type(graph: PAYMENT)
  @join__type(graph: RETURN)
  @join__type(graph: REVIEW)
  @join__type(graph: SHIPMENT)
  @join__type(graph: SHOPPINGCART)
  @join__type(graph: TAX)
  @join__type(graph: USER)
  @join__type(graph: WISHLIST)
{
  """Get a address by id"""
  address(
    """The id of the address"""
    id: UUID!
  ): Address! @join__field(graph: ADDRESS)

  """Get the current vendor address"""
  vendorAddress: VendorAddress @join__field(graph: ADDRESS)

  """Get all categories"""
  categories(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CategoryOrderInput

    """Number of items to skip"""
    skip: Int
  ): CategoryConnection! @join__field(graph: CATALOG)

  """Get a category by id"""
  category(
    """The id of the category"""
    id: UUID!
  ): Category! @join__field(graph: CATALOG)

  """Get a characteristic by id"""
  categoryCharacteristic(
    """The id of the characteristic"""
    id: UUID!
  ): CategoryCharacteristic! @join__field(graph: CATALOG)

  """Get a product by id"""
  product(
    """The id of the product"""
    id: UUID!
  ): Product! @join__field(graph: CATALOG)

  """Get all products"""
  products(
    """Filtering"""
    filter: ProductFilterInput

    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: ProductOrderInput

    """Number of items to skip"""
    skip: Int
  ): ProductConnection! @join__field(graph: CATALOG)

  """Get a coupon by id"""
  coupon(
    """The id of the coupon"""
    id: UUID!
  ): Coupon! @join__field(graph: DISCOUNT)

  """Get a discount by id"""
  discount(
    """The id of the discount"""
    id: UUID!
  ): Discount! @join__field(graph: DISCOUNT)

  """
  Find all applicable discounts for a user and a list of product variant, count and coupon id triples
  """
  findApplicableDiscounts(
    """The input for the findApplicableDiscounts query."""
    input: FindApplicableDiscountsInput!
  ): [DiscountsForProductVariant!]! @inaccessible @join__field(graph: DISCOUNT)

  """Retrieves all product items matching the filter"""
  productItems(
    """Number of items to skip"""
    skip: Int = 0

    """Number of items to return"""
    first: Int = 2147483647

    """Ordering"""
    orderBy: ProductItemOrder

    """Filtering"""
    filter: ProductItemFilter
  ): ProductItemConnection! @join__field(graph: INVENTORY)

  """Retrieves a product item by id"""
  productItem(
    """UUID of the user"""
    id: UUID!
  ): ProductItem! @join__field(graph: INVENTORY)

  """Query for invoice of specific UUID."""
  invoice(
    """UUID of invoice to retrieve."""
    id: UUID!
  ): Invoice! @join__field(graph: INVOICE)

  """Returns all medias of the service."""
  getMedias(
    """Describes that the `first` N medias should be retrieved."""
    first: Int

    """Describes how many medias should be skipped at the beginning."""
    skip: Int
  ): MediaConnection! @join__field(graph: MEDIA)

  """Get a notification by id"""
  notification(
    """The id of the notification"""
    id: UUID!
  ): Notification! @join__field(graph: NOTIFICATION)

  """Retrieves order of specific UUID."""
  order(
    """UUID of order to retrieve."""
    id: UUID!
  ): Order! @join__field(graph: ORDER)

  """Retrieves order_item of specific UUID."""
  orderItem(
    """UUID of order_item to retrieve."""
    id: UUID!
  ): OrderItem! @join__field(graph: ORDER)

  """ Retrieves all payment informations matching the filter"""
  paymentInformations(
    """Number of items to skip"""
    skip: Int = 0

    """Number of items to return"""
    first: Int = 2147483647

    """Ordering"""
    orderBy: PaymentInformationOrder

    """Filtering"""
    filter: PaymentInformationFilter
  ): PaymentInformationConnection! @join__field(graph: PAYMENT)

  """Retrieves all payments"""
  payments(
    """Number of items to skip"""
    skip: Int = 0

    """Number of items to return"""
    first: Int = 2147483647

    """Ordering"""
    orderBy: PaymentOrder

    """Filtering"""
    filter: PaymentFilter
  ): PaymentConnection! @join__field(graph: PAYMENT)

  """Get a return by id"""
  return(
    """The id of the return"""
    id: UUID!
  ): Return! @join__field(graph: RETURN)

  """Get all returns"""
  returns(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: ReturnOrderInput

    """Number of items to skip"""
    skip: Int
  ): ReturnConnection! @join__field(graph: RETURN)

  """Retrieves all reviews."""
  reviews(
    """Describes that the `first` N reviews should be retrieved."""
    first: Int

    """Describes how many reviews should be skipped at the beginning."""
    skip: Int

    """Specifies the order in which reviews are retrieved."""
    orderBy: ReviewOrderInput
  ): ReviewConnection! @join__field(graph: REVIEW)

  """Retrieves review of specific UUID."""
  review(
    """UUID of review to retrieve."""
    id: UUID!
  ): Review! @join__field(graph: REVIEW)

  """
  Calculates the fees for a collection of shipped items. Should only be called by the Order service
  """
  calculateShipmentFees(
    """The input for the calculateShipmentFees query."""
    input: CalculateShipmentFeesInput!
  ): Int! @inaccessible @join__field(graph: SHIPMENT)

  """Get a shipmentMethod by id"""
  shipmentMethod(
    """The id of the shipmentMethod"""
    id: UUID!
  ): ShipmentMethod! @join__field(graph: SHIPMENT)

  """Get all shipmentMethods"""
  shipmentMethods(
    """Filtering"""
    filter: ShipmentMethodFilterInput

    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: ShipmentMethodOrderInput

    """Number of items to skip"""
    skip: Int
  ): ShipmentMethodConnection! @join__field(graph: SHIPMENT)

  """Retrieves shopping cart item of specific UUID."""
  shoppingcartItem(
    """UUID of shoppingcart to retrieve."""
    id: UUID!
  ): ShoppingCartItem! @join__field(graph: SHOPPINGCART)

  """Get a TaxRate by id"""
  taxRate(
    """The id of the TaxRate"""
    id: UUID!
  ): TaxRate! @join__field(graph: TAX)

  """Get a TaxRateVersion by id"""
  taxRateVersion(
    """The id of the TaxRateVersion"""
    id: UUID!
  ): TaxRateVersion! @join__field(graph: TAX)

  """Get all TaxRates"""
  taxRates(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: TaxRateOrderInput

    """Number of items to skip"""
    skip: Int
  ): TaxRateConnection! @join__field(graph: TAX)

  """Get the currently authenticated user"""
  currentUser: User @join__field(graph: USER)

  """Get a user by id"""
  user(
    """The id of the user"""
    id: UUID!
  ): User! @join__field(graph: USER)

  """Get all users"""
  users(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: UserOrderInput

    """Number of items to skip"""
    skip: Int
  ): UserConnection! @join__field(graph: USER)

  """Retrieves wishlist of specific UUID."""
  wishlist(
    """UUID of wishlist to retrieve."""
    id: UUID!
  ): Wishlist! @join__field(graph: WISHLIST)
}

enum Rating
  @join__type(graph: REVIEW)
{
  ONE_STARS @join__enumValue(graph: REVIEW)
  TWO_STARS @join__enumValue(graph: REVIEW)
  THREE_STARS @join__enumValue(graph: REVIEW)
  FOUR_STARS @join__enumValue(graph: REVIEW)
  FIVE_STARS @join__enumValue(graph: REVIEW)
}

"""Input for the registerCoupon mutation"""
input RegisterCouponInput
  @join__type(graph: DISCOUNT)
{
  """The code of the coupon."""
  code: String!

  """The user who wants to register the coupon."""
  userId: UUID!
}

"""
Describes the reason why an order was rejected, in case of rejection: `OrderStatus::Rejected`.
"""
enum RejectionReason
  @join__type(graph: ORDER)
{
  """The order was rejected due to its invalid content."""
  INVALID_ORDER_DATA @join__enumValue(graph: ORDER)

  """
  The inventory service was not able to reserve inventory items according to the order.
  """
  INVENTORY_RESERVATION_FAILED @join__enumValue(graph: ORDER)
}

"""The input to reserve a batch of product items"""
input ReserveProductItemsBatchInput
  @join__type(graph: INVENTORY)
{
  """The product variant id of the product item"""
  productVariantId: UUID!

  """The number of product items to reserve"""
  number: Int!

  """The order id that reserves the product items"""
  orderId: UUID!
}

"""A return."""
type Return implements Node
  @join__implements(graph: RETURN, interface: "Node")
  @join__implements(graph: SHIPMENT, interface: "Node")
  @join__type(graph: RETURN, key: "id", resolvable: true)
  @join__type(graph: SHIPMENT, key: "id", resolvable: true)
{
  """The time the return was created."""
  createdAt: DateTime! @join__field(graph: RETURN)

  """The ID of the node."""
  id: UUID!

  """The order this return is for."""
  order: Order! @join__field(graph: RETURN)

  """The reason for the return."""
  reason: String! @join__field(graph: RETURN)

  """The amount of money refunded."""
  refundedAmount: Int! @join__field(graph: RETURN)

  """Get all order items returned with this return"""
  returnedItems(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CommonOrderInput

    """Number of items to skip"""
    skip: Int
  ): OrderItemConnection! @join__field(graph: RETURN)

  """The associated Shipment"""
  shipment: Shipment! @join__field(graph: SHIPMENT)
}

"""A connection to a list of `Return` values."""
type ReturnConnection
  @join__type(graph: RETURN)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [Return!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Return order fields"""
enum ReturnOrderField
  @join__type(graph: RETURN)
{
  """Order returns by their id"""
  ID @join__enumValue(graph: RETURN)
}

"""Direction to sort returns in"""
input ReturnOrderInput
  @join__type(graph: RETURN)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: ReturnOrderField
}

"""The review of a user."""
type Review
  @join__type(graph: REVIEW)
{
  """review UUID."""
  id: UUID!

  """User."""
  user: User!

  """Product variant that review is about."""
  productVariant: ProductVariant!

  """Body of review."""
  body: String!

  """Rating of review in 1-5 stars."""
  rating: Rating!

  """Timestamp when review was created."""
  createdAt: DateTime!

  """Timestamp when review was created."""
  lastUpdatedAt: DateTime!

  """Flag if review is visible,"""
  isVisible: Boolean!
}

"""A connection of reviews."""
type ReviewConnection
  @join__type(graph: REVIEW)
{
  """The resulting entities."""
  nodes: [Review!]!

  """Whether this connection has a next page."""
  hasNextPage: Boolean!

  """The total amount of items in this connection."""
  totalCount: Int!
}

"""Describes the fields that a review can be ordered by."""
enum ReviewOrderField
  @join__type(graph: REVIEW)
{
  """Orders by "id"."""
  ID @join__enumValue(graph: REVIEW)

  """Orders by "user_id"."""
  USER_ID @join__enumValue(graph: REVIEW)

  """Orders by "product_variant"."""
  PRODUCT_VARIANT @join__enumValue(graph: REVIEW)

  """Orders by "rating"."""
  RATING @join__enumValue(graph: REVIEW)

  """Orders by "created_at"."""
  CREATED_AT @join__enumValue(graph: REVIEW)
}

"""Specifies the order of reviews."""
input ReviewOrderInput
  @join__type(graph: REVIEW)
{
  """Order direction of reviews."""
  direction: OrderDirection

  """Field that reviews should be ordered by."""
  field: ReviewOrderField
}

"""A shipment caused by either an order or a return."""
type Shipment implements Node
  @join__implements(graph: SHIPMENT, interface: "Node")
  @join__type(graph: SHIPMENT, key: "id", resolvable: true)
{
  """The ID of the node."""
  id: UUID!

  """The order creating this shipment."""
  order: Order

  """The product return causing this shipment."""
  return: Return

  """Get all OrderItems sent with this shipment"""
  sentItems(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: OrderItemOrderInput

    """Number of items to skip"""
    skip: Int
  ): OrderItemConnection!

  """The address this shipment is sent to."""
  shipmentAddress: Address!

  """The shipment method this shipment uses."""
  shipmentMethod: ShipmentMethod!

  """The status of the shipment."""
  status: ShipmentStatus!
}

"""A connection to a list of `Shipment` values."""
type ShipmentConnection
  @join__type(graph: SHIPMENT)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [Shipment!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Shipment filter"""
input ShipmentFilterInput
  @join__type(graph: SHIPMENT)
{
  """Filter shipments by their status"""
  status: ShipmentStatus
}

"""Describes the method/provider that the shipment uses."""
type ShipmentMethod implements Node
  @join__implements(graph: SHIPMENT, interface: "Node")
  @join__type(graph: ORDER, key: "id", resolvable: false)
  @join__type(graph: SHIPMENT, key: "id", resolvable: true)
{
  """UUID of the shipment method."""
  id: UUID!

  """If this shipment method is archived, the datetime it was archived."""
  archivedAt: DateTime @join__field(graph: SHIPMENT)

  """The base fees for the shipment method."""
  baseFees: Int! @join__field(graph: SHIPMENT)

  """Calculates the fees for a potential shipment."""
  calculateFees(
    """The input for the calculation."""
    items: [ProductVariantVersionWithQuantityInput!]!
  ): Int! @join__field(graph: SHIPMENT)

  """The description of the shipment method."""
  description: String! @join__field(graph: SHIPMENT)

  """
  The reference of the shipment method used by the external shipment provider.
  """
  externalReference: String! @join__field(graph: SHIPMENT)

  """The fees per item for the shipment method."""
  feesPerItem: Int! @join__field(graph: SHIPMENT)

  """The fees per kg for the shipment method."""
  feesPerKg: Int! @join__field(graph: SHIPMENT)

  """If true, this shipment method is archived and can no longer be used."""
  isArchived: Boolean! @join__field(graph: SHIPMENT)

  """The name of the shipment method."""
  name: String! @join__field(graph: SHIPMENT)
}

"""A connection to a list of `ShipmentMethod` values."""
type ShipmentMethodConnection
  @join__type(graph: SHIPMENT)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [ShipmentMethod!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Shipment method filter"""
input ShipmentMethodFilterInput
  @join__type(graph: SHIPMENT)
{
  """Filter shipment methods by their archived status"""
  isArchived: Boolean
}

"""Shipment method order fields"""
enum ShipmentMethodOrderField
  @join__type(graph: SHIPMENT)
{
  """Order shipment methods by their id"""
  ID @join__enumValue(graph: SHIPMENT)
}

"""Shipment method order"""
input ShipmentMethodOrderInput
  @join__type(graph: SHIPMENT)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: ShipmentMethodOrderField
}

"""Shipment  order fields"""
enum ShipmentOrderField
  @join__type(graph: SHIPMENT)
{
  """Order shipment s by their id"""
  ID @join__enumValue(graph: SHIPMENT)
}

"""Shipment  order"""
input ShipmentOrderInput
  @join__type(graph: SHIPMENT)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: ShipmentOrderField
}

"""The status of a shipment."""
enum ShipmentStatus
  @join__type(graph: SHIPMENT)
{
  """The shipment has been delivered."""
  DELIVERED @join__enumValue(graph: SHIPMENT)

  """The shipment has failed."""
  FAILED @join__enumValue(graph: SHIPMENT)

  """The shipment is in progress."""
  IN_PROGRESS @join__enumValue(graph: SHIPMENT)

  """The shipment is pending."""
  PENDING @join__enumValue(graph: SHIPMENT)
}

"""The shopping cart of a user."""
type ShoppingCart
  @join__type(graph: SHOPPINGCART)
{
  """Timestamp when shopping cart was last updated."""
  lastUpdatedAt: DateTime!

  """Retrieves shoppingcart items in shopping cart."""
  shoppingcartItems(
    """Describes that the `first` N shoppingcarts should be retrieved."""
    first: Int

    """Describes how many shoppingcarts should be skipped at the beginning."""
    skip: Int

    """Specifies the order in which shoppingcarts are retrieved."""
    orderBy: CommonOrderInput
  ): ShoppingCartItemConnection!
}

"""Foreign type of a shopping cart item."""
type ShoppingCartItem
  @join__type(graph: ORDER, key: "id", resolvable: false)
  @join__type(graph: SHOPPINGCART, key: "id")
{
  """UUID of the shopping cart item."""
  id: UUID!

  """Count of items in basket."""
  count: Int! @join__field(graph: SHOPPINGCART)

  """Timestamp when shopping cart item was added."""
  addedAt: DateTime! @join__field(graph: SHOPPINGCART)

  """Product variant of shopping cart item."""
  productVariant: ProductVariant! @join__field(graph: SHOPPINGCART)
}

"""A connection of shopping cart items."""
type ShoppingCartItemConnection
  @join__type(graph: SHOPPINGCART)
{
  """The resulting entities."""
  nodes: [ShoppingCartItem!]!

  """Whether this connection has a next page."""
  hasNextPage: Boolean!

  """The total amount of items in this connection."""
  totalCount: Int!
}

input ShoppingCartItemInput
  @join__type(graph: SHOPPINGCART)
{
  """Count of shopping cart items in cart."""
  count: Int!

  """UUID of product variant."""
  productVariantId: UUID!
}

"""A TaxRate."""
type TaxRate implements Node
  @join__implements(graph: CATALOG, interface: "Node")
  @join__implements(graph: TAX, interface: "Node")
  @join__type(graph: CATALOG, key: "id", resolvable: false)
  @join__type(graph: TAX, key: "id", resolvable: true)
{
  """The ID of the node."""
  id: UUID!

  """The current version of the TaxRate."""
  currentVersion: TaxRateVersion! @join__field(graph: TAX)

  """The description of the TaxRate"""
  description: String! @join__field(graph: TAX)

  """The name of the TaxRate"""
  name: String! @join__field(graph: TAX)

  """Get all associated versions"""
  versions(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: TaxRateVersionOrderInput

    """Number of items to skip"""
    skip: Int
  ): TaxRateVersionConnection! @join__field(graph: TAX)
}

"""A connection to a list of `TaxRate` values."""
type TaxRateConnection
  @join__type(graph: TAX)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [TaxRate!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""TaxRate order fields"""
enum TaxRateOrderField
  @join__type(graph: TAX)
{
  """Order TaxRates by their id"""
  ID @join__enumValue(graph: TAX)

  """Order TaxRates by their name"""
  NAME @join__enumValue(graph: TAX)
}

"""TaxRate order"""
input TaxRateOrderInput
  @join__type(graph: TAX)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: TaxRateOrderField
}

"""Foreign type of a tax rate version."""
type TaxRateVersion implements Node
  @join__implements(graph: TAX, interface: "Node")
  @join__type(graph: ORDER, key: "id", resolvable: false)
  @join__type(graph: TAX, key: "id", resolvable: true)
{
  """UUID of the tax rate."""
  id: UUID!

  """Time stamp when the TaxRateVersion was created"""
  createdAt: DateTime! @join__field(graph: TAX)

  """The rate of the TaxRateVersion"""
  rate: Float! @join__field(graph: TAX)

  """The associated TaxRate."""
  taxRate: TaxRate! @join__field(graph: TAX)

  """Version of the TaxRateVersion"""
  version: Int! @join__field(graph: TAX)
}

"""A connection to a list of `TaxRateVersion` values."""
type TaxRateVersionConnection
  @join__type(graph: TAX)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [TaxRateVersion!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""Input for creating a TaxRateVersion"""
input TaxRateVersionInput
  @join__type(graph: TAX)
{
  """The rate of the created TaxRateVersion"""
  rate: Float!
}

"""TaxRateVersion order fields"""
enum TaxRateVersionOrderField
  @join__type(graph: TAX)
{
  """Order TaxRateVersions by their creation date"""
  CREATED_AT @join__enumValue(graph: TAX)

  """Order TaxRateVersions by their id"""
  ID @join__enumValue(graph: TAX)

  """Order TaxRateVersions by their version"""
  VERSION @join__enumValue(graph: TAX)
}

"""TaxRateVersion order"""
input TaxRateVersionOrderInput
  @join__type(graph: TAX)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: TaxRateVersionOrderField
}

"""Input for the updateCoupon mutation."""
input UpdateCouponInput
  @join__type(graph: DISCOUNT)
{
  """The code of the coupon."""
  code: String

  """The id of the coupon to update."""
  id: UUID!

  """The maximum number of times the coupon can be used."""
  maxUsages: Int

  """The date and time from which the coupon is valid."""
  validFrom: DateTime

  """The date and time until which the coupon is valid."""
  validUntil: DateTime
}

"""Input for the updateDiscount mutation."""
input UpdateDiscountInput
  @join__type(graph: DISCOUNT)
{
  """Added category ids to which the discount applies."""
  addedDiscountAppliesToCategoryIds: [UUID!]

  """Added product ids to which the discount applies."""
  addedDiscountAppliesToProductIds: [UUID!]

  """Added product variant ids to which the discount applies."""
  addedDiscountAppliesToProductVariantIds: [UUID!]

  """The id of the discount to update."""
  id: UUID!

  """The discount applied to the order item."""
  maxUsagesPerUser: Int

  """The minimum order amount required to use this discount."""
  minOrderAmount: Int

  """Removed category ids to which the discount applies."""
  removedDiscountAppliesToCategoryIds: [UUID!]

  """Removed product ids to which the discount applies."""
  removedDiscountAppliesToProductIds: [UUID!]

  """Removed product variant ids to which the discount applies."""
  removedDiscountAppliesToProductVariantIds: [UUID!]

  """The date and time from which the discount is valid."""
  validFrom: DateTime

  """The date and time until which the discount is valid."""
  validUntil: DateTime
}

"""Input for the updateNotification mutation"""
input UpdateNotificationInput
  @join__type(graph: NOTIFICATION)
{
  """id of the notification to update"""
  id: UUID!

  """mark the notification as read/unread"""
  isRead: Boolean!
}

"""Input for the updateProduct mutation."""
input UpdateProductInput
  @join__type(graph: CATALOG)
{
  """If present, new value for defaultVariantId"""
  defaultVariantId: UUID

  """UUID of the product to be updated"""
  id: UUID!

  """If present, new value for internalName"""
  internalName: String

  """If present, new value for isPubliclyVisible"""
  isPubliclyVisible: Boolean
}

"""The input of a product item update"""
input UpdateProductItemInput
  @join__type(graph: INVENTORY)
{
  """The product item identifier"""
  id: UUID!

  """The product variant id of the product item"""
  productVariantId: UUID!

  """The inventory state of the product item"""
  inventoryStatus: ProductItemStatus!
}

"""Input for the updateProductVariant mutation."""
input UpdateProductVariantInput
  @join__type(graph: CATALOG)
{
  """UUID of the product variant to be updated"""
  id: UUID!

  """If present, new value for isPubliclyVisible"""
  isPubliclyVisible: Boolean
}

input UpdateReviewInput
  @join__type(graph: REVIEW)
{
  """UUID of review to update."""
  id: UUID!

  """Body of review to update."""
  body: String

  """Rating of review in 1-5 stars to update."""
  rating: Rating

  """Flag if review is visible."""
  isVisible: Boolean
}

input UpdateShoppingCartInput
  @join__type(graph: SHOPPINGCART)
{
  """UUID of user owning shopping cart."""
  id: UUID!

  """Shopping cart items of shopping cart to update."""
  shoppingCartItems: [ShoppingCartItemInput!]
}

input UpdateShoppingCartItemInput
  @join__type(graph: SHOPPINGCART)
{
  """UUID of shoppingcart item to update."""
  id: UUID!

  """Count of shopping cart items in cart."""
  count: Int!
}

"""Input for the updateTaxRate mutation"""
input UpdateTaxRateInput
  @join__type(graph: TAX)
{
  """If provided, the new description of the TaxRate"""
  description: String

  """The id of the TaxRate to update"""
  id: UUID!

  """If provided, the new name of the TaxRate"""
  name: String
}

"""Input for the updateUser mutation"""
input UpdateUserInput
  @join__type(graph: USER)
{
  """The new birthday of the user"""
  birthday: Date

  """The new first name of the user"""
  firstName: String

  """The new gender of the user"""
  gender: Gender

  """The id of the user to update"""
  id: UUID!

  """The new last name of the user"""
  lastName: String
}

input UpdateWishlistInput
  @join__type(graph: WISHLIST)
{
  """UUID of wishlist to update."""
  id: UUID!

  """product variant UUIDs of wishlist to update"""
  productVariantIds: [UUID!]

  """Wishlist name to update"""
  name: String
}

scalar Upload
  @join__type(graph: MEDIA)

"""A user."""
type User implements Node
  @join__implements(graph: ADDRESS, interface: "Node")
  @join__implements(graph: DISCOUNT, interface: "Node")
  @join__implements(graph: NOTIFICATION, interface: "Node")
  @join__implements(graph: RETURN, interface: "Node")
  @join__implements(graph: USER, interface: "Node")
  @join__type(graph: ADDRESS, key: "id", resolvable: true)
  @join__type(graph: DISCOUNT, key: "id", resolvable: true)
  @join__type(graph: NOTIFICATION, key: "id", resolvable: true)
  @join__type(graph: ORDER, key: "id")
  @join__type(graph: PAYMENT, key: "id")
  @join__type(graph: RETURN, key: "id", resolvable: true)
  @join__type(graph: REVIEW, key: "id")
  @join__type(graph: SHOPPINGCART, key: "id")
  @join__type(graph: USER, key: "id", resolvable: true)
  @join__type(graph: WISHLIST, key: "id")
{
  """Get all address the user received"""
  addresses(
    """Filtering"""
    filter: UserAddressFilterInput

    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: UserAddressOrderInput

    """Number of items to skip"""
    skip: Int
  ): UserAddressConnection! @join__field(graph: ADDRESS)

  """The ID of the node."""
  id: UUID!

  """Get all coupons this user has claimed"""
  coupons(
    """Filtering"""
    filter: CouponFilterInput

    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: CouponOrderInput

    """Number of items to skip"""
    skip: Int
  ): CouponConnection! @join__field(graph: DISCOUNT)

  """Get all the discount usages by this user"""
  discountUsages(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: DiscountUsageOrderInput

    """Number of items to skip"""
    skip: Int
  ): DiscountUsageConnection! @join__field(graph: DISCOUNT)

  """Get all notifications the user received"""
  notifications(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: NotificationOrderInput

    """Number of items to skip"""
    skip: Int
  ): NotificationConnection! @join__field(graph: NOTIFICATION)

  """Retrieves orders of user."""
  orders(
    """Describes that the `first` N orders should be retrieved."""
    first: Int

    """Describes how many orders should be skipped at the beginning."""
    skip: Int

    """Specifies the order in which orders are retrieved."""
    orderBy: OrderOrderInput
  ): OrderConnection! @join__field(graph: ORDER)

  """A connection for an users payment informations."""
  paymentInformations(
    """Number of items to skip"""
    skip: Int = 0

    """Number of items to return"""
    first: Int = 2147483647

    """Ordering"""
    orderBy: PaymentInformationOrder

    """Filtering"""
    filter: PaymentInformationFilter
  ): PaymentInformationConnection @join__field(graph: PAYMENT)

  """Get all returns of this user"""
  returns(
    """Number of items to return"""
    first: Int

    """Ordering"""
    orderBy: ReturnOrderInput

    """Number of items to skip"""
    skip: Int
  ): ReturnConnection! @join__field(graph: RETURN)

  """Retrieves reviews of user."""
  reviews(
    """Describes that the `first` N reviews should be retrieved."""
    first: Int

    """Describes how many reviews should be skipped at the beginning."""
    skip: Int

    """Specifies the order in which reviews are retrieved."""
    orderBy: ReviewOrderInput
  ): ReviewConnection! @join__field(graph: REVIEW)

  """Shopping cart of the user."""
  shoppingcart: ShoppingCart! @join__field(graph: SHOPPINGCART)

  """The birthday of the user"""
  birthday: Date @join__field(graph: USER)

  """The date when the user joined"""
  dateJoined: DateTime! @join__field(graph: USER)

  """The gender of the user"""
  gender: Gender @join__field(graph: USER)

  """The name of the user"""
  name: Name! @join__field(graph: USER)

  """The username of the user"""
  username: String! @join__field(graph: USER)

  """Retrieves wishlists of user."""
  wishlists(
    """Describes that the `first` N wishlists should be retrieved."""
    first: Int

    """Describes how many wishlists should be skipped at the beginning."""
    skip: Int

    """Specifies the order in which wishlists are retrieved."""
    orderBy: WishlistOrderInput
  ): WishlistConnection! @join__field(graph: WISHLIST)
}

"""A address associated with a user."""
type UserAddress implements Address & Node
  @join__implements(graph: ADDRESS, interface: "Address")
  @join__implements(graph: ADDRESS, interface: "Node")
  @join__implements(graph: SHIPMENT, interface: "Address")
  @join__type(graph: ADDRESS, key: "id", resolvable: true)
  @join__type(graph: INVOICE, key: "id", resolvable: false)
  @join__type(graph: ORDER, key: "id", resolvable: false)
  @join__type(graph: SHIPMENT, key: "id", resolvable: false)
{
  """If this address is archived, the datetime it was archived."""
  archivedAt: DateTime @join__field(graph: ADDRESS)

  """The city part of the address"""
  city: String! @join__field(graph: ADDRESS)

  """The company name part of the address"""
  companyName: String @join__field(graph: ADDRESS)

  """The country part of the address"""
  country: String! @join__field(graph: ADDRESS)

  """The ID of the node."""
  id: UUID!

  """If true, this address is archived and can no longer be used."""
  isArchived: Boolean! @join__field(graph: ADDRESS)

  """The name of the address"""
  name: Name @join__field(graph: ADDRESS)

  """The postal code part of the address"""
  postalCode: String! @join__field(graph: ADDRESS)

  """The first part of the street part of the address"""
  street1: String! @join__field(graph: ADDRESS)

  """The second part of the street part of the address"""
  street2: String! @join__field(graph: ADDRESS)

  """The user this address belongs to."""
  user: User! @join__field(graph: ADDRESS)
}

"""A connection to a list of `Address` values."""
type UserAddressConnection
  @join__type(graph: ADDRESS)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [UserAddress!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""User address filter"""
input UserAddressFilterInput
  @join__type(graph: ADDRESS)
{
  isArchived: Boolean
}

"""User address order fields"""
enum UserAddressOrderField
  @join__type(graph: ADDRESS)
{
  """Order addresss by their id"""
  ID @join__enumValue(graph: ADDRESS)
}

"""User address order"""
input UserAddressOrderInput
  @join__type(graph: ADDRESS)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: UserAddressOrderField
}

"""A connection to a list of `User` values."""
type UserConnection
  @join__type(graph: DISCOUNT)
  @join__type(graph: USER)
{
  """Whether this connection has a next page"""
  hasNextPage: Boolean!

  """The resulting items."""
  nodes: [User!]!

  """The total amount of items in this connection"""
  totalCount: Int!
}

"""User order fields"""
enum UserOrderField
  @join__type(graph: USER)
{
  """Order users by their id"""
  ID @join__enumValue(graph: USER)

  """Order users by their username"""
  USERNAME @join__enumValue(graph: USER)
}

"""User order"""
input UserOrderInput
  @join__type(graph: USER)
{
  """The direction to order by"""
  direction: OrderDirection

  """The field to order by"""
  field: UserOrderField
}

"""A universally unique identifier compliant UUID Scalar"""
scalar UUID
  @join__type(graph: ADDRESS)
  @join__type(graph: CATALOG)
  @join__type(graph: DISCOUNT)
  @join__type(graph: INVENTORY)
  @join__type(graph: INVOICE)
  @join__type(graph: MEDIA)
  @join__type(graph: NOTIFICATION)
  @join__type(graph: ORDER)
  @join__type(graph: PAYMENT)
  @join__type(graph: RETURN)
  @join__type(graph: REVIEW)
  @join__type(graph: SHIPMENT)
  @join__type(graph: SHOPPINGCART)
  @join__type(graph: TAX)
  @join__type(graph: USER)
  @join__type(graph: WISHLIST)

"""An address associated with the vendor."""
type VendorAddress implements Address & Node
  @join__implements(graph: ADDRESS, interface: "Address")
  @join__implements(graph: ADDRESS, interface: "Node")
  @join__implements(graph: SHIPMENT, interface: "Address")
  @join__type(graph: ADDRESS, key: "id", resolvable: true)
  @join__type(graph: INVOICE, key: "id", resolvable: false)
  @join__type(graph: SHIPMENT, key: "id", resolvable: false)
{
  """The city part of the address"""
  city: String! @join__field(graph: ADDRESS)

  """The company name part of the address"""
  companyName: String @join__field(graph: ADDRESS)

  """The country part of the address"""
  country: String! @join__field(graph: ADDRESS)

  """The ID of the node."""
  id: UUID!

  """The name of the address"""
  name: Name @join__field(graph: ADDRESS)

  """The postal code part of the address"""
  postalCode: String! @join__field(graph: ADDRESS)

  """The first part of the street part of the address"""
  street1: String! @join__field(graph: ADDRESS)

  """The second part of the street part of the address"""
  street2: String! @join__field(graph: ADDRESS)
}

"""The wishlist of a user."""
type Wishlist
  @join__type(graph: WISHLIST, key: "id")
{
  """Wishlist UUID."""
  id: UUID!

  """User."""
  user: User!

  """Name of wishlist."""
  name: String!

  """Timestamp when wishlist was created."""
  createdAt: DateTime!

  """Timestamp when wishlist was last updated."""
  lastUpdatedAt: DateTime!

  """Retrieves product variants."""
  productVariants(
    """Describes that the `first` N product variants should be retrieved."""
    first: Int

    """
    Describes how many product variants should be skipped at the beginning.
    """
    skip: Int

    """Specifies the order in which product variants are retrieved."""
    orderBy: CommonOrderInput
  ): ProductVariantConnection!
}

"""A connection of wishlists."""
type WishlistConnection
  @join__type(graph: WISHLIST)
{
  """The resulting entities."""
  nodes: [Wishlist!]!

  """Whether this connection has a next page."""
  hasNextPage: Boolean!

  """The total amount of items in this connection."""
  totalCount: Int!
}

"""Describes the fields that a wishlist can be ordered by."""
enum WishlistOrderField
  @join__type(graph: WISHLIST)
{
  """Orders by "id"."""
  ID @join__enumValue(graph: WISHLIST)

  """Orders by "user_id"."""
  USER_ID @join__enumValue(graph: WISHLIST)

  """Orders by "name"."""
  NAME @join__enumValue(graph: WISHLIST)

  """Orders by "created_at"."""
  CREATED_AT @join__enumValue(graph: WISHLIST)

  """Orders by "last_updated_at"."""
  LAST_UPDATED_AT @join__enumValue(graph: WISHLIST)
}

"""Specifies the order of wishlists."""
input WishlistOrderInput
  @join__type(graph: WISHLIST)
{
  """Order direction of wishlists."""
  direction: OrderDirection

  """Field that wishlists should be ordered by."""
  field: WishlistOrderField
}