schema {
  query: Query
  mutation: Mutation
}

type AccountAddressCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
  address: Address
}

type AccountAddressDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
  address: Address
}

type AccountAddressUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
  address: Address
}

type AccountDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  accountErrors: [AccountError!]!
  user: User
}

type AccountError {
  field: String
  message: String
  code: AccountErrorCode!
}

enum AccountErrorCode {
  ACTIVATE_OWN_ACCOUNT
  ACTIVATE_SUPERUSER_ACCOUNT
  DUPLICATED_INPUT_ITEM
  DEACTIVATE_OWN_ACCOUNT
  DEACTIVATE_SUPERUSER_ACCOUNT
  DELETE_NON_STAFF_USER
  DELETE_OWN_ACCOUNT
  DELETE_STAFF_ACCOUNT
  DELETE_SUPERUSER_ACCOUNT
  GRAPHQL_ERROR
  INACTIVE
  INVALID
  INVALID_PASSWORD
  LEFT_NOT_MANAGEABLE_PERMISSION
  INVALID_CREDENTIALS
  NOT_FOUND
  OUT_OF_SCOPE_USER
  OUT_OF_SCOPE_GROUP
  OUT_OF_SCOPE_PERMISSION
  PASSWORD_ENTIRELY_NUMERIC
  PASSWORD_TOO_COMMON
  PASSWORD_TOO_SHORT
  PASSWORD_TOO_SIMILAR
  REQUIRED
  UNIQUE
  JWT_SIGNATURE_EXPIRED
  JWT_INVALID_TOKEN
  JWT_DECODE_ERROR
  JWT_MISSING_TOKEN
  JWT_INVALID_CSRF_TOKEN
}

input AccountInput {
  firstName: String
  lastName: String
  defaultBillingAddress: AddressInput
  defaultShippingAddress: AddressInput
}

type AccountRegister {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  requiresConfirmation: Boolean
  accountErrors: [AccountError!]!
  user: User
}

input AccountRegisterInput {
  email: String!
  password: String!
  redirectUrl: String
}

type AccountRequestDeletion {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  accountErrors: [AccountError!]!
}

type AccountSetDefaultAddress {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
}

type AccountUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  accountErrors: [AccountError!]!
  user: User
}

type Address implements Node {
  id: ID!
  firstName: String!
  lastName: String!
  companyName: String!
  streetAddress1: String!
  streetAddress2: String!
  city: String!
  cityArea: String!
  postalCode: String!
  country: CountryDisplay!
  countryArea: String!
  phone: String
  isDefaultShippingAddress: Boolean
  isDefaultBillingAddress: Boolean
}

type AddressCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
  address: Address
}

type AddressDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
  address: Address
}

input AddressInput {
  firstName: String
  lastName: String
  companyName: String
  streetAddress1: String
  streetAddress2: String
  city: String
  cityArea: String
  postalCode: String
  country: CountryCode
  countryArea: String
  phone: String
}

type AddressSetDefault {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
}

enum AddressTypeEnum {
  BILLING
  SHIPPING
}

type AddressUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
  address: Address
}

type AddressValidationData {
  countryCode: String
  countryName: String
  addressFormat: String
  addressLatinFormat: String
  allowedFields: [String]
  requiredFields: [String]
  upperFields: [String]
  countryAreaType: String
  countryAreaChoices: [ChoiceValue]
  cityType: String
  cityChoices: [ChoiceValue]
  cityAreaType: String
  cityAreaChoices: [ChoiceValue]
  postalCodeType: String
  postalCodeMatchers: [String]
  postalCodeExamples: [String]
  postalCodePrefix: String
}

type Allocation implements Node {
  id: ID!
  quantity: Int!
  warehouse: Warehouse!
}

type App implements Node & ObjectWithMetadata {
  id: ID!
  name: String
  created: DateTime
  isActive: Boolean
  permissions: [Permission]
  tokens: [AppToken]
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  type: AppTypeEnum
  webhooks: [Webhook]
  aboutApp: String
  dataPrivacy: String
  dataPrivacyUrl: String
  homepageUrl: String
  supportUrl: String
  configurationUrl: String
  appUrl: String
  version: String
  accessToken: String
}

type AppActivate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  appErrors: [AppError!]!
  app: App
}

type AppCountableConnection {
  pageInfo: PageInfo!
  edges: [AppCountableEdge!]!
  totalCount: Int
}

type AppCountableEdge {
  node: App!
  cursor: String!
}

type AppCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  authToken: String
  appErrors: [AppError!]!
  app: App
}

type AppDeactivate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  appErrors: [AppError!]!
  app: App
}

type AppDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  appErrors: [AppError!]!
  app: App
}

type AppDeleteFailedInstallation {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  appErrors: [AppError!]!
  appInstallation: AppInstallation
}

type AppError {
  field: String
  message: String
  code: AppErrorCode!
  permissions: [PermissionEnum!]
}

enum AppErrorCode {
  FORBIDDEN
  GRAPHQL_ERROR
  INVALID
  INVALID_STATUS
  INVALID_PERMISSION
  INVALID_URL_FORMAT
  INVALID_MANIFEST_FORMAT
  MANIFEST_URL_CANT_CONNECT
  NOT_FOUND
  REQUIRED
  UNIQUE
  OUT_OF_SCOPE_APP
  OUT_OF_SCOPE_PERMISSION
}

type AppFetchManifest {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  manifest: Manifest
  appErrors: [AppError!]!
}

input AppFilterInput {
  search: String
  isActive: Boolean
  type: AppTypeEnum
}

input AppInput {
  name: String
  isActive: Boolean
  permissions: [PermissionEnum]
}

type AppInstall {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  appErrors: [AppError!]!
  appInstallation: AppInstallation
}

input AppInstallInput {
  appName: String
  manifestUrl: String
  activateAfterInstallation: Boolean = true
  permissions: [PermissionEnum]
}

type AppInstallation implements Node & Job {
  appName: String!
  manifestUrl: String!
  id: ID!
  status: JobStatusEnum!
  createdAt: DateTime!
  updatedAt: DateTime!
  message: String
}

type AppRetryInstall {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  appErrors: [AppError!]!
  appInstallation: AppInstallation
}

enum AppSortField {
  NAME
  CREATION_DATE
}

input AppSortingInput {
  direction: OrderDirection!
  field: AppSortField!
}

type AppToken implements Node {
  name: String
  authToken: String
  id: ID!
}

type AppTokenCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  authToken: String
  appErrors: [AppError!]!
  appToken: AppToken
}

type AppTokenDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  appErrors: [AppError!]!
  appToken: AppToken
}

input AppTokenInput {
  name: String
  app: ID!
}

type AppTokenVerify {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  valid: Boolean!
  appErrors: [AppError!]!
}

enum AppTypeEnum {
  LOCAL
  THIRDPARTY
}

type AppUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  appErrors: [AppError!]!
  app: App
}

type AssignNavigation {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  menu: Menu
  menuErrors: [MenuError!]!
}

type Attribute implements Node & ObjectWithMetadata {
  id: ID!
  productTypes(
    before: String
    after: String
    first: Int
    last: Int
  ): ProductTypeCountableConnection!
  productVariantTypes(
    before: String
    after: String
    first: Int
    last: Int
  ): ProductTypeCountableConnection!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  inputType: AttributeInputTypeEnum
  entityType: AttributeEntityTypeEnum
  name: String
  slug: String
  type: AttributeTypeEnum
  values: [AttributeValue]
  valueRequired: Boolean!
  visibleInStorefront: Boolean!
  filterableInStorefront: Boolean!
  filterableInDashboard: Boolean!
  availableInGrid: Boolean!
  translation(languageCode: LanguageCodeEnum!): AttributeTranslation
  storefrontSearchPosition: Int!
}

type AttributeBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  attributeErrors: [AttributeError!]!
}

type AttributeCountableConnection {
  pageInfo: PageInfo!
  edges: [AttributeCountableEdge!]!
  totalCount: Int
}

type AttributeCountableEdge {
  node: Attribute!
  cursor: String!
}

type AttributeCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  attribute: Attribute
  attributeErrors: [AttributeError!]!
}

input AttributeCreateInput {
  inputType: AttributeInputTypeEnum
  entityType: AttributeEntityTypeEnum
  name: String!
  slug: String
  type: AttributeTypeEnum!
  values: [AttributeValueCreateInput]
  valueRequired: Boolean
  isVariantOnly: Boolean
  visibleInStorefront: Boolean
  filterableInStorefront: Boolean
  filterableInDashboard: Boolean
  storefrontSearchPosition: Int
  availableInGrid: Boolean
}

type AttributeDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  attributeErrors: [AttributeError!]!
  attribute: Attribute
}

enum AttributeEntityTypeEnum {
  PAGE
  PRODUCT
}

type AttributeError {
  field: String
  message: String
  code: AttributeErrorCode!
}

enum AttributeErrorCode {
  ALREADY_EXISTS
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
}

input AttributeFilterInput {
  valueRequired: Boolean
  isVariantOnly: Boolean
  visibleInStorefront: Boolean
  filterableInStorefront: Boolean
  filterableInDashboard: Boolean
  availableInGrid: Boolean
  search: String
  ids: [ID]
  type: AttributeTypeEnum
  inCollection: ID
  inCategory: ID
  channel: String
}

input AttributeInput {
  slug: String!
  value: String
  values: [String]
}

enum AttributeInputTypeEnum {
  DROPDOWN
  MULTISELECT
  FILE
  REFERENCE
}

type AttributeReorderValues {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  attribute: Attribute
  attributeErrors: [AttributeError!]!
}

enum AttributeSortField {
  NAME
  SLUG
  VALUE_REQUIRED
  IS_VARIANT_ONLY
  VISIBLE_IN_STOREFRONT
  FILTERABLE_IN_STOREFRONT
  FILTERABLE_IN_DASHBOARD
  STOREFRONT_SEARCH_POSITION
  AVAILABLE_IN_GRID
}

input AttributeSortingInput {
  direction: OrderDirection!
  field: AttributeSortField!
}

type AttributeTranslatableContent implements Node {
  id: ID!
  name: String!
  translation(languageCode: LanguageCodeEnum!): AttributeTranslation
  attribute: Attribute
}

type AttributeTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  attribute: Attribute
}

type AttributeTranslation implements Node {
  id: ID!
  name: String!
  language: LanguageDisplay!
}

enum AttributeTypeEnum {
  PRODUCT_TYPE
  PAGE_TYPE
}

type AttributeUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  attribute: Attribute
  attributeErrors: [AttributeError!]!
}

input AttributeUpdateInput {
  name: String
  slug: String
  removeValues: [ID]
  addValues: [AttributeValueCreateInput]
  valueRequired: Boolean
  isVariantOnly: Boolean
  visibleInStorefront: Boolean
  filterableInStorefront: Boolean
  filterableInDashboard: Boolean
  storefrontSearchPosition: Int
  availableInGrid: Boolean
}

type AttributeValue implements Node {
  id: ID!
  name: String
  slug: String
  translation(languageCode: LanguageCodeEnum!): AttributeValueTranslation
  inputType: AttributeInputTypeEnum
  reference: ID
  file: File
}

type AttributeValueBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  attributeErrors: [AttributeError!]!
}

type AttributeValueCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  attribute: Attribute
  attributeErrors: [AttributeError!]!
  attributeValue: AttributeValue
}

input AttributeValueCreateInput {
  name: String!
}

type AttributeValueDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  attribute: Attribute
  attributeErrors: [AttributeError!]!
  attributeValue: AttributeValue
}

input AttributeValueInput {
  id: ID
  values: [String]
  file: String
  contentType: String
  references: [ID!]
}

type AttributeValueTranslatableContent implements Node {
  id: ID!
  name: String!
  translation(languageCode: LanguageCodeEnum!): AttributeValueTranslation
  attributeValue: AttributeValue
}

type AttributeValueTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  attributeValue: AttributeValue
}

type AttributeValueTranslation implements Node {
  id: ID!
  name: String!
  language: LanguageDisplay!
}

type AttributeValueUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  attribute: Attribute
  attributeErrors: [AttributeError!]!
  attributeValue: AttributeValue
}

input BulkAttributeValueInput {
  id: ID
  values: [String]!
}

type BulkProductError {
  field: String
  message: String
  code: ProductErrorCode!
  attributes: [ID!]
  values: [ID!]
  index: Int
  warehouses: [ID!]
  channels: [ID!]
}

type BulkStockError {
  field: String
  message: String
  code: ProductErrorCode!
  attributes: [ID!]
  values: [ID!]
  index: Int
}

input CatalogueInput {
  products: [ID]
  categories: [ID]
  collections: [ID]
}

type Category implements Node & ObjectWithMetadata {
  seoTitle: String
  seoDescription: String
  id: ID!
  name: String!
  description: JSONString
  slug: String!
  parent: Category
  level: Int!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  descriptionJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `description` field instead."
    )
  ancestors(
    before: String
    after: String
    first: Int
    last: Int
  ): CategoryCountableConnection
  products(
    channel: String
    before: String
    after: String
    first: Int
    last: Int
  ): ProductCountableConnection
  url: String
    @deprecated(reason: "This field will be removed after 2020-07-31.")
  children(
    before: String
    after: String
    first: Int
    last: Int
  ): CategoryCountableConnection
  backgroundImage(size: Int): Image
  translation(languageCode: LanguageCodeEnum!): CategoryTranslation
}

type CategoryBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  productErrors: [ProductError!]!
}

type CategoryCountableConnection {
  pageInfo: PageInfo!
  edges: [CategoryCountableEdge!]!
  totalCount: Int
}

type CategoryCountableEdge {
  node: Category!
  cursor: String!
}

type CategoryCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  category: Category
}

type CategoryDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  category: Category
}

input CategoryFilterInput {
  search: String
  ids: [ID]
}

input CategoryInput {
  description: JSONString
  name: String
  slug: String
  seo: SeoInput
  backgroundImage: Upload
  backgroundImageAlt: String
}

enum CategorySortField {
  NAME
  PRODUCT_COUNT
  SUBCATEGORY_COUNT
}

input CategorySortingInput {
  direction: OrderDirection!
  channel: String
  field: CategorySortField!
}

type CategoryTranslatableContent implements Node {
  seoTitle: String
  seoDescription: String
  id: ID!
  name: String!
  description: JSONString
  descriptionJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `description` field instead."
    )
  translation(languageCode: LanguageCodeEnum!): CategoryTranslation
  category: Category
}

type CategoryTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  category: Category
}

type CategoryTranslation implements Node {
  seoTitle: String
  seoDescription: String
  id: ID!
  name: String!
  description: JSONString
  language: LanguageDisplay!
  descriptionJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `description` field instead."
    )
}

type CategoryUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  category: Category
}

type Channel implements Node {
  id: ID!
  name: String!
  isActive: Boolean!
  slug: String!
  currencyCode: String!
  hasOrders: Boolean!
}

type ChannelActivate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  channel: Channel
  channelErrors: [ChannelError!]!
}

type ChannelCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  channelErrors: [ChannelError!]!
  channel: Channel
}

input ChannelCreateInput {
  isActive: Boolean
  name: String!
  slug: String!
  currencyCode: String!
}

type ChannelDeactivate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  channel: Channel
  channelErrors: [ChannelError!]!
}

type ChannelDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  channelErrors: [ChannelError!]!
  channel: Channel
}

input ChannelDeleteInput {
  targetChannel: ID!
}

type ChannelError {
  field: String
  message: String
  code: ChannelErrorCode!
}

enum ChannelErrorCode {
  ALREADY_EXISTS
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
  CHANNEL_TARGET_ID_MUST_BE_DIFFERENT
  CHANNELS_CURRENCY_MUST_BE_THE_SAME
  CHANNEL_WITH_ORDERS
}

type ChannelUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  channelErrors: [ChannelError!]!
  channel: Channel
}

input ChannelUpdateInput {
  isActive: Boolean
  name: String
  slug: String
}

type Checkout implements Node & ObjectWithMetadata {
  created: DateTime!
  lastChange: DateTime!
  user: User
  quantity: Int!
  channel: Channel!
  billingAddress: Address
  shippingAddress: Address
  note: String!
  discount: Money
  discountName: String
  translatedDiscountName: String
  voucherCode: String
  giftCards: [GiftCard]
  id: ID!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  availableShippingMethods: [ShippingMethod]!
  availablePaymentGateways: [PaymentGateway!]!
  email: String!
  isShippingRequired: Boolean!
  lines: [CheckoutLine]
  shippingPrice: TaxedMoney
  shippingMethod: ShippingMethod
  subtotalPrice: TaxedMoney
  token: UUID!
  totalPrice: TaxedMoney
}

type CheckoutAddPromoCode {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

type CheckoutBillingAddressUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

type CheckoutComplete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  confirmationNeeded: Boolean!
  confirmationData: JSONString
  checkoutErrors: [CheckoutError!]!
}

type CheckoutCountableConnection {
  pageInfo: PageInfo!
  edges: [CheckoutCountableEdge!]!
  totalCount: Int
}

type CheckoutCountableEdge {
  node: Checkout!
  cursor: String!
}

type CheckoutCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  created: Boolean
  checkoutErrors: [CheckoutError!]!
  checkout: Checkout
}

input CheckoutCreateInput {
  channel: String
  lines: [CheckoutLineInput]!
  email: String
  shippingAddress: AddressInput
  billingAddress: AddressInput
}

type CheckoutCustomerAttach {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

type CheckoutCustomerDetach {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

type CheckoutEmailUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

type CheckoutError {
  field: String
  message: String
  code: CheckoutErrorCode!
  variants: [ID!]
}

enum CheckoutErrorCode {
  BILLING_ADDRESS_NOT_SET
  CHECKOUT_NOT_FULLY_PAID
  GRAPHQL_ERROR
  PRODUCT_NOT_PUBLISHED
  PRODUCT_UNAVAILABLE_FOR_PURCHASE
  INSUFFICIENT_STOCK
  INVALID
  INVALID_SHIPPING_METHOD
  NOT_FOUND
  PAYMENT_ERROR
  QUANTITY_GREATER_THAN_LIMIT
  REQUIRED
  SHIPPING_ADDRESS_NOT_SET
  SHIPPING_METHOD_NOT_APPLICABLE
  SHIPPING_METHOD_NOT_SET
  SHIPPING_NOT_REQUIRED
  TAX_ERROR
  UNIQUE
  VOUCHER_NOT_APPLICABLE
  ZERO_QUANTITY
  MISSING_CHANNEL_SLUG
  CHANNEL_INACTIVE
}

type CheckoutLine implements Node {
  id: ID!
  variant: ProductVariant!
  quantity: Int!
  totalPrice: TaxedMoney
  requiresShipping: Boolean
}

type CheckoutLineCountableConnection {
  pageInfo: PageInfo!
  edges: [CheckoutLineCountableEdge!]!
  totalCount: Int
}

type CheckoutLineCountableEdge {
  node: CheckoutLine!
  cursor: String!
}

type CheckoutLineDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

input CheckoutLineInput {
  quantity: Int!
  variantId: ID!
}

type CheckoutLinesAdd {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

type CheckoutLinesUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

type CheckoutPaymentCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  payment: Payment
  paymentErrors: [PaymentError!]!
}

type CheckoutRemovePromoCode {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

type CheckoutShippingAddressUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

type CheckoutShippingMethodUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  checkout: Checkout
  checkoutErrors: [CheckoutError!]!
}

type ChoiceValue {
  raw: String
  verbose: String
}

type Collection implements Node & ObjectWithMetadata {
  seoTitle: String
  seoDescription: String
  id: ID!
  name: String!
  description: JSONString
  slug: String!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  descriptionJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `description` field instead."
    )
  products(
    filter: ProductFilterInput
    sortBy: ProductOrder
    before: String
    after: String
    first: Int
    last: Int
  ): ProductCountableConnection
  backgroundImage(size: Int): Image
  translation(languageCode: LanguageCodeEnum!): CollectionTranslation
  channelListings: [CollectionChannelListing!]
}

type CollectionAddProducts {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  collection: Collection
  collectionErrors: [CollectionError!]!
}

type CollectionBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  productErrors: [ProductError!]!
}

type CollectionChannelListing implements Node {
  publicationDate: Date
  isPublished: Boolean!
  id: ID!
  channel: Channel!
}

type CollectionChannelListingError {
  field: String
  message: String
  code: ProductErrorCode!
  attributes: [ID!]
  values: [ID!]
  channels: [ID!]
}

type CollectionChannelListingUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  collection: Collection
  collectionChannelListingErrors: [CollectionChannelListingError!]!
}

input CollectionChannelListingUpdateInput {
  addChannels: [PublishableChannelListingInput!]
  removeChannels: [ID!]
}

type CollectionCountableConnection {
  pageInfo: PageInfo!
  edges: [CollectionCountableEdge!]!
  totalCount: Int
}

type CollectionCountableEdge {
  node: Collection!
  cursor: String!
}

type CollectionCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  collectionErrors: [CollectionError!]!
  collection: Collection
}

input CollectionCreateInput {
  isPublished: Boolean
  name: String
  slug: String
  description: JSONString
  backgroundImage: Upload
  backgroundImageAlt: String
  seo: SeoInput
  publicationDate: Date
  products: [ID]
}

type CollectionDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  collectionErrors: [CollectionError!]!
  collection: Collection
}

type CollectionError {
  field: String
  message: String
  products: [ID!]
  code: CollectionErrorCode!
}

enum CollectionErrorCode {
  DUPLICATED_INPUT_ITEM
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
  CANNOT_MANAGE_PRODUCT_WITHOUT_VARIANT
}

input CollectionFilterInput {
  published: CollectionPublished
  search: String
  ids: [ID]
  channel: String
}

input CollectionInput {
  isPublished: Boolean
  name: String
  slug: String
  description: JSONString
  backgroundImage: Upload
  backgroundImageAlt: String
  seo: SeoInput
  publicationDate: Date
}

enum CollectionPublished {
  PUBLISHED
  HIDDEN
}

type CollectionRemoveProducts {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  collection: Collection
  collectionErrors: [CollectionError!]!
}

type CollectionReorderProducts {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  collection: Collection
  collectionErrors: [CollectionError!]!
}

enum CollectionSortField {
  NAME
  AVAILABILITY
  PRODUCT_COUNT
  PUBLICATION_DATE
}

input CollectionSortingInput {
  direction: OrderDirection!
  channel: String
  field: CollectionSortField!
}

type CollectionTranslatableContent implements Node {
  seoTitle: String
  seoDescription: String
  id: ID!
  name: String!
  description: JSONString
  descriptionJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `description` field instead."
    )
  translation(languageCode: LanguageCodeEnum!): CollectionTranslation
  collection: Collection
}

type CollectionTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  collection: Collection
}

type CollectionTranslation implements Node {
  seoTitle: String
  seoDescription: String
  id: ID!
  name: String!
  description: JSONString
  language: LanguageDisplay!
  descriptionJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `description` field instead."
    )
}

type CollectionUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  collectionErrors: [CollectionError!]!
  collection: Collection
}

type ConfigurationItem {
  name: String!
  value: String
  type: ConfigurationTypeFieldEnum
  helpText: String
  label: String
}

input ConfigurationItemInput {
  name: String!
  value: String
}

enum ConfigurationTypeFieldEnum {
  STRING
  BOOLEAN
  SECRET
  PASSWORD
  SECRETMULTILINE
}

type ConfirmAccount {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
}

type ConfirmEmailChange {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
}

enum CountryCode {
  AF
  AX
  AL
  DZ
  AS
  AD
  AO
  AI
  AQ
  AG
  AR
  AM
  AW
  AU
  AT
  AZ
  BS
  BH
  BD
  BB
  BY
  BE
  BZ
  BJ
  BM
  BT
  BO
  BQ
  BA
  BW
  BV
  BR
  IO
  BN
  BG
  BF
  BI
  CV
  KH
  CM
  CA
  KY
  CF
  TD
  CL
  CN
  CX
  CC
  CO
  KM
  CG
  CD
  CK
  CR
  CI
  HR
  CU
  CW
  CY
  CZ
  DK
  DJ
  DM
  DO
  EC
  EG
  SV
  GQ
  ER
  EE
  SZ
  ET
  EU
  FK
  FO
  FJ
  FI
  FR
  GF
  PF
  TF
  GA
  GM
  GE
  DE
  GH
  GI
  GR
  GL
  GD
  GP
  GU
  GT
  GG
  GN
  GW
  GY
  HT
  HM
  VA
  HN
  HK
  HU
  IS
  IN
  ID
  IR
  IQ
  IE
  IM
  IL
  IT
  JM
  JP
  JE
  JO
  KZ
  KE
  KI
  KW
  KG
  LA
  LV
  LB
  LS
  LR
  LY
  LI
  LT
  LU
  MO
  MG
  MW
  MY
  MV
  ML
  MT
  MH
  MQ
  MR
  MU
  YT
  MX
  FM
  MD
  MC
  MN
  ME
  MS
  MA
  MZ
  MM
  NA
  NR
  NP
  NL
  NC
  NZ
  NI
  NE
  NG
  NU
  NF
  KP
  MK
  MP
  NO
  OM
  PK
  PW
  PS
  PA
  PG
  PY
  PE
  PH
  PN
  PL
  PT
  PR
  QA
  RE
  RO
  RU
  RW
  BL
  SH
  KN
  LC
  MF
  PM
  VC
  WS
  SM
  ST
  SA
  SN
  RS
  SC
  SL
  SG
  SX
  SK
  SI
  SB
  SO
  ZA
  GS
  KR
  SS
  ES
  LK
  SD
  SR
  SJ
  SE
  CH
  SY
  TW
  TJ
  TZ
  TH
  TL
  TG
  TK
  TO
  TT
  TN
  TR
  TM
  TC
  TV
  UG
  UA
  AE
  GB
  UM
  US
  UY
  UZ
  VU
  VE
  VN
  VG
  VI
  WF
  EH
  YE
  ZM
  ZW
}

type CountryDisplay {
  code: String!
  country: String!
  vat: VAT
}

type CreateToken {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  token: String
  refreshToken: String
  csrfToken: String
  user: User
  accountErrors: [AccountError!]!
}

type CreditCard {
  brand: String!
  firstDigits: String
  lastDigits: String!
  expMonth: Int
  expYear: Int
}

type CustomerBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  accountErrors: [AccountError!]!
}

type CustomerCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  accountErrors: [AccountError!]!
  user: User
}

type CustomerDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  accountErrors: [AccountError!]!
  user: User
}

type CustomerEvent implements Node {
  id: ID!
  date: DateTime
  type: CustomerEventsEnum
  user: User
  message: String
  count: Int
  order: Order
  orderLine: OrderLine
}

enum CustomerEventsEnum {
  ACCOUNT_CREATED
  PASSWORD_RESET_LINK_SENT
  PASSWORD_RESET
  EMAIL_CHANGED_REQUEST
  PASSWORD_CHANGED
  EMAIL_CHANGED
  PLACED_ORDER
  NOTE_ADDED_TO_ORDER
  DIGITAL_LINK_DOWNLOADED
  CUSTOMER_DELETED
  NAME_ASSIGNED
  EMAIL_ASSIGNED
  NOTE_ADDED
}

input CustomerFilterInput {
  dateJoined: DateRangeInput
  numberOfOrders: IntRangeInput
  placedOrders: DateRangeInput
  search: String
}

input CustomerInput {
  defaultBillingAddress: AddressInput
  defaultShippingAddress: AddressInput
  firstName: String
  lastName: String
  email: String
  isActive: Boolean
  note: String
}

type CustomerUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  accountErrors: [AccountError!]!
  user: User
}

scalar Date

input DateRangeInput {
  gte: Date
  lte: Date
}

scalar DateTime

input DateTimeRangeInput {
  gte: DateTime
  lte: DateTime
}

type DeactivateAllUserTokens {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  accountErrors: [AccountError!]!
}

type DeleteMetadata {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  metadataErrors: [MetadataError!]!
  item: ObjectWithMetadata
}

type DeletePrivateMetadata {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  metadataErrors: [MetadataError!]!
  item: ObjectWithMetadata
}

type DigitalContent implements Node & ObjectWithMetadata {
  useDefaultSettings: Boolean!
  automaticFulfillment: Boolean!
  productVariant: ProductVariant!
  contentFile: String!
  maxDownloads: Int
  urlValidDays: Int
  urls: [DigitalContentUrl]
  id: ID!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
}

type DigitalContentCountableConnection {
  pageInfo: PageInfo!
  edges: [DigitalContentCountableEdge!]!
  totalCount: Int
}

type DigitalContentCountableEdge {
  node: DigitalContent!
  cursor: String!
}

type DigitalContentCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  variant: ProductVariant
  content: DigitalContent
  productErrors: [ProductError!]!
}

type DigitalContentDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  variant: ProductVariant
  productErrors: [ProductError!]!
}

input DigitalContentInput {
  useDefaultSettings: Boolean!
  maxDownloads: Int
  urlValidDays: Int
  automaticFulfillment: Boolean
}

type DigitalContentUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  variant: ProductVariant
  content: DigitalContent
  productErrors: [ProductError!]!
}

input DigitalContentUploadInput {
  useDefaultSettings: Boolean!
  maxDownloads: Int
  urlValidDays: Int
  automaticFulfillment: Boolean
  contentFile: Upload!
}

type DigitalContentUrl implements Node {
  content: DigitalContent!
  created: DateTime!
  downloadNum: Int!
  id: ID!
  url: String
  token: UUID!
}

type DigitalContentUrlCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  digitalContentUrl: DigitalContentUrl
}

input DigitalContentUrlCreateInput {
  content: ID!
}

type DiscountError {
  field: String
  message: String
  products: [ID!]
  code: DiscountErrorCode!
  channels: [ID!]
}

enum DiscountErrorCode {
  ALREADY_EXISTS
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
  CANNOT_MANAGE_PRODUCT_WITHOUT_VARIANT
  DUPLICATED_INPUT_ITEM
}

enum DiscountStatusEnum {
  ACTIVE
  EXPIRED
  SCHEDULED
}

enum DiscountValueTypeEnum {
  FIXED
  PERCENTAGE
}

type Domain {
  host: String!
  sslEnabled: Boolean!
  url: String!
}

type DraftOrderBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  orderErrors: [OrderError!]!
}

type DraftOrderComplete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

type Geolocalization {
  country: CountryDisplay
}

type DraftOrderCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  orderErrors: [OrderError!]!
  order: Order
}

input DraftOrderCreateInput {
  billingAddress: AddressInput
  user: ID
  userEmail: String
  discount: PositiveDecimal
  shippingAddress: AddressInput
  shippingMethod: ID
  voucher: ID
  customerNote: String
  channel: ID
  redirectUrl: String
  lines: [OrderLineCreateInput]
}

type DraftOrderDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  orderErrors: [OrderError!]!
  order: Order
}

input DraftOrderInput {
  billingAddress: AddressInput
  user: ID
  userEmail: String
  discount: PositiveDecimal
  shippingAddress: AddressInput
  shippingMethod: ID
  voucher: ID
  customerNote: String
  channel: ID
  redirectUrl: String
}

type DraftOrderLineDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderLine: OrderLine
  orderErrors: [OrderError!]!
}

type DraftOrderLineUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
  orderLine: OrderLine
}

type DraftOrderLinesBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  orderErrors: [OrderError!]!
}

type DraftOrderLinesCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderLines: [OrderLine!]
  orderErrors: [OrderError!]!
}

type DraftOrderUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  orderErrors: [OrderError!]!
  order: Order
}

type Error {
  field: String
  message: String
}

type ExportError {
  field: String
  message: String
  code: ExportErrorCode!
}

enum ExportErrorCode {
  INVALID
  NOT_FOUND
  REQUIRED
}

type ExportEvent implements Node {
  id: ID!
  date: DateTime!
  type: ExportEventsEnum!
  user: User
  app: App
  message: String!
}

enum ExportEventsEnum {
  EXPORT_PENDING
  EXPORT_SUCCESS
  EXPORT_FAILED
  EXPORT_DELETED
  EXPORTED_FILE_SENT
  EXPORT_FAILED_INFO_SENT
}

type ExportFile implements Node & Job {
  id: ID!
  user: User
  app: App
  status: JobStatusEnum!
  createdAt: DateTime!
  updatedAt: DateTime!
  message: String
  url: String
  events: [ExportEvent!]
}

type ExportFileCountableConnection {
  pageInfo: PageInfo!
  edges: [ExportFileCountableEdge!]!
  totalCount: Int
}

type ExportFileCountableEdge {
  node: ExportFile!
  cursor: String!
}

input ExportFileFilterInput {
  createdAt: DateTimeRangeInput
  updatedAt: DateTimeRangeInput
  status: JobStatusEnum
  user: String
  app: String
}

enum ExportFileSortField {
  STATUS
  CREATED_AT
  UPDATED_AT
}

input ExportFileSortingInput {
  direction: OrderDirection!
  field: ExportFileSortField!
}

input ExportInfoInput {
  attributes: [ID!]
  warehouses: [ID!]
  channels: [ID!]
  fields: [ProductFieldEnum!]
}

type ExportProducts {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  exportFile: ExportFile
  exportErrors: [ExportError!]!
}

input ExportProductsInput {
  scope: ExportScope!
  filter: ProductFilterInput
  ids: [ID!]
  exportInfo: ExportInfoInput
  fileType: FileTypesEnum!
}

enum ExportScope {
  ALL
  IDS
  FILTER
}

type ExternalAuthentication {
  id: String!
  name: String
}

type ExternalAuthenticationUrl {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  authenticationData: JSONString
  accountErrors: [AccountError!]!
}

type ExternalLogout {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  logoutData: JSONString
  accountErrors: [AccountError!]!
}

type ExternalObtainAccessTokens {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  token: String
  refreshToken: String
  csrfToken: String
  user: User
  accountErrors: [AccountError!]!
}

type ExternalRefresh {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  token: String
  refreshToken: String
  csrfToken: String
  user: User
  accountErrors: [AccountError!]!
}

type ExternalVerify {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  isValid: Boolean!
  verifyData: JSONString
  accountErrors: [AccountError!]!
}

type File {
  url: String!
  contentType: String
}

enum FileTypesEnum {
  CSV
  XLSX
}

type FileUpload {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  uploadedFile: File
  uploadErrors: [UploadError!]!
}

type Fulfillment implements Node & ObjectWithMetadata {
  id: ID!
  fulfillmentOrder: Int!
  status: FulfillmentStatus!
  trackingNumber: String!
  created: DateTime!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  lines: [FulfillmentLine]
  statusDisplay: String
  warehouse: Warehouse
}

type FulfillmentCancel {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  fulfillment: Fulfillment
  order: Order
  orderErrors: [OrderError!]!
}

input FulfillmentCancelInput {
  warehouseId: ID!
}

type FulfillmentLine implements Node {
  id: ID!
  quantity: Int!
  orderLine: OrderLine
}

type FulfillmentRefundProducts {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  fulfillment: Fulfillment
  order: Order
  orderErrors: [OrderError!]!
}

type FulfillmentReturnProducts {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  returnFulfillment: Fulfillment
  replaceFulfillment: Fulfillment
  order: Order
  replaceOrder: Order
  orderErrors: [OrderError!]!
}

enum FulfillmentStatus {
  FULFILLED
  REFUNDED
  RETURNED
  REPLACED
  REFUNDED_AND_RETURNED
  CANCELED
}

type FulfillmentUpdateTracking {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  fulfillment: Fulfillment
  order: Order
  orderErrors: [OrderError!]!
}

input FulfillmentUpdateTrackingInput {
  trackingNumber: String
  notifyCustomer: Boolean = false
}

type GatewayConfigLine {
  field: String!
  value: String
}

scalar GenericScalar

type GiftCard implements Node {
  code: String
  user: User
  created: DateTime!
  startDate: Date!
  endDate: Date
  lastUsedOn: DateTime
  isActive: Boolean!
  initialBalance: Money
  currentBalance: Money
  id: ID!
  displayCode: String
}

type GiftCardActivate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  giftCard: GiftCard
  giftCardErrors: [GiftCardError!]!
}

type GiftCardCountableConnection {
  pageInfo: PageInfo!
  edges: [GiftCardCountableEdge!]!
  totalCount: Int
}

type GiftCardCountableEdge {
  node: GiftCard!
  cursor: String!
}

type GiftCardCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  giftCardErrors: [GiftCardError!]!
  giftCard: GiftCard
}

input GiftCardCreateInput {
  startDate: Date
  endDate: Date
  balance: PositiveDecimal
  userEmail: String
  code: String
}

type GiftCardDeactivate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  giftCard: GiftCard
  giftCardErrors: [GiftCardError!]!
}

type GiftCardError {
  field: String
  message: String
  code: GiftCardErrorCode!
}

enum GiftCardErrorCode {
  ALREADY_EXISTS
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
}

type GiftCardUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  giftCardErrors: [GiftCardError!]!
  giftCard: GiftCard
}

input GiftCardUpdateInput {
  startDate: Date
  endDate: Date
  balance: PositiveDecimal
  userEmail: String
}

type Group implements Node {
  id: ID!
  name: String!
  permissions: [Permission]
  users: [User]
  userCanManage: Boolean!
}

type GroupCountableConnection {
  pageInfo: PageInfo!
  edges: [GroupCountableEdge!]!
  totalCount: Int
}

type GroupCountableEdge {
  node: Group!
  cursor: String!
}

type Image {
  url: String!
  alt: String
}

input IntRangeInput {
  gte: Int
  lte: Int
}

type Invoice implements ObjectWithMetadata & Job & Node {
  id: ID!
  metadata: [MetadataItem]!
  status: JobStatusEnum!
  number: String
  externalUrl: String
  privateMetadata: [MetadataItem]!
  createdAt: DateTime!
  updatedAt: DateTime!
  message: String
  url: String
}

type InvoiceCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  invoiceErrors: [InvoiceError!]!
  invoice: Invoice
}

input InvoiceCreateInput {
  number: String!
  url: String!
}

type InvoiceDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  invoiceErrors: [InvoiceError!]!
  invoice: Invoice
}

type InvoiceError {
  field: String
  message: String
  code: InvoiceErrorCode!
}

enum InvoiceErrorCode {
  REQUIRED
  NOT_READY
  URL_NOT_SET
  EMAIL_NOT_SET
  NUMBER_NOT_SET
  NOT_FOUND
  INVALID_STATUS
}

type InvoiceRequest {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  invoiceErrors: [InvoiceError!]!
  invoice: Invoice
}

type InvoiceRequestDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  invoiceErrors: [InvoiceError!]!
  invoice: Invoice
}

type InvoiceSendEmail {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  invoiceErrors: [InvoiceError!]!
  invoice: Invoice
}

type InvoiceUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  invoiceErrors: [InvoiceError!]!
  invoice: Invoice
}

scalar JSONString

interface Job {
  status: JobStatusEnum!
  createdAt: DateTime!
  updatedAt: DateTime!
  message: String
}

enum JobStatusEnum {
  PENDING
  SUCCESS
  FAILED
  DELETED
}

enum LanguageCodeEnum {
  AR
  AZ
  BG
  BN
  CA
  CS
  DA
  DE
  EL
  EN
  ES
  ES_CO
  ET
  FA
  FI
  FR
  HI
  HU
  HY
  ID
  IS
  IT
  JA
  KA
  KM
  KO
  LT
  MN
  MY
  NB
  NL
  PL
  PT
  PT_BR
  RO
  RU
  SK
  SL
  SQ
  SR
  SV
  SW
  TA
  TH
  TR
  UK
  VI
  ZH_HANS
  ZH_HANT
}

type LanguageDisplay {
  code: LanguageCodeEnum!
  language: String!
}

type Manifest {
  identifier: String!
  version: String!
  name: String!
  about: String
  permissions: [Permission]
  appUrl: String
  configurationUrl: String
  tokenTargetUrl: String
  dataPrivacy: String
  dataPrivacyUrl: String
  homepageUrl: String
  supportUrl: String
}

type Margin {
  start: Int
  stop: Int
}

type Menu implements Node & ObjectWithMetadata {
  id: ID!
  name: String!
  slug: String!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  items: [MenuItem]
}

type MenuBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  menuErrors: [MenuError!]!
}

type MenuCountableConnection {
  pageInfo: PageInfo!
  edges: [MenuCountableEdge!]!
  totalCount: Int
}

type MenuCountableEdge {
  node: Menu!
  cursor: String!
}

type MenuCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  menuErrors: [MenuError!]!
  menu: Menu
}

input MenuCreateInput {
  name: String!
  slug: String
  items: [MenuItemInput]
}

type MenuDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  menuErrors: [MenuError!]!
  menu: Menu
}

type MenuError {
  field: String
  message: String
  code: MenuErrorCode!
}

enum MenuErrorCode {
  CANNOT_ASSIGN_NODE
  GRAPHQL_ERROR
  INVALID
  INVALID_MENU_ITEM
  NO_MENU_ITEM_PROVIDED
  NOT_FOUND
  REQUIRED
  TOO_MANY_MENU_ITEMS
  UNIQUE
}

input MenuFilterInput {
  search: String
  slug: [String]
}

input MenuInput {
  name: String
  slug: String
}

type MenuItem implements Node & ObjectWithMetadata {
  id: ID!
  name: String!
  menu: Menu!
  parent: MenuItem
  category: Category
  collection: Collection
  page: Page
  level: Int!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  children: [MenuItem]
  url: String
  translation(languageCode: LanguageCodeEnum!): MenuItemTranslation
}

type MenuItemBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  menuErrors: [MenuError!]!
}

type MenuItemCountableConnection {
  pageInfo: PageInfo!
  edges: [MenuItemCountableEdge!]!
  totalCount: Int
}

type MenuItemCountableEdge {
  node: MenuItem!
  cursor: String!
}

type MenuItemCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  menuErrors: [MenuError!]!
  menuItem: MenuItem
}

input MenuItemCreateInput {
  name: String!
  url: String
  category: ID
  collection: ID
  page: ID
  menu: ID!
  parent: ID
}

type MenuItemDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  menuErrors: [MenuError!]!
  menuItem: MenuItem
}

input MenuItemFilterInput {
  search: String
}

input MenuItemInput {
  name: String
  url: String
  category: ID
  collection: ID
  page: ID
}

type MenuItemMove {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  menu: Menu
  menuErrors: [MenuError!]!
}

input MenuItemMoveInput {
  itemId: ID!
  parentId: ID
  sortOrder: Int
}

input MenuItemSortingInput {
  direction: OrderDirection!
  field: MenuItemsSortField!
}

type MenuItemTranslatableContent implements Node {
  id: ID!
  name: String!
  translation(languageCode: LanguageCodeEnum!): MenuItemTranslation
  menuItem: MenuItem
}

type MenuItemTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  menuItem: MenuItem
}

type MenuItemTranslation implements Node {
  id: ID!
  name: String!
  language: LanguageDisplay!
}

type MenuItemUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  menuErrors: [MenuError!]!
  menuItem: MenuItem
}

enum MenuItemsSortField {
  NAME
}

enum MenuSortField {
  NAME
  ITEMS_COUNT
}

input MenuSortingInput {
  direction: OrderDirection!
  field: MenuSortField!
}

type MenuUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  menuErrors: [MenuError!]!
  menu: Menu
}

type MetadataError {
  field: String
  message: String
  code: MetadataErrorCode!
}

enum MetadataErrorCode {
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
}

input MetadataInput {
  key: String!
  value: String!
}

type MetadataItem {
  key: String!
  value: String!
}

type Money {
  currency: String!
  amount: Float!
  localized: String!
    @deprecated(
      reason: "Price formatting according to the current locale should be handled by the frontend client. This field will be removed after 2020-07-31."
    )
}

type MoneyRange {
  start: Money
  stop: Money
}

input MoveProductInput {
  productId: ID!
  sortOrder: Int
}

type Mutation {
  webhookCreate(input: WebhookCreateInput!): WebhookCreate
  webhookDelete(id: ID!): WebhookDelete
  webhookUpdate(id: ID!, input: WebhookUpdateInput!): WebhookUpdate
  createWarehouse(input: WarehouseCreateInput!): WarehouseCreate
  updateWarehouse(id: ID!, input: WarehouseUpdateInput!): WarehouseUpdate
  deleteWarehouse(id: ID!): WarehouseDelete
  assignWarehouseShippingZone(
    id: ID!
    shippingZoneIds: [ID!]!
  ): WarehouseShippingZoneAssign
  unassignWarehouseShippingZone(
    id: ID!
    shippingZoneIds: [ID!]!
  ): WarehouseShippingZoneUnassign
  staffNotificationRecipientCreate(
    input: StaffNotificationRecipientInput!
  ): StaffNotificationRecipientCreate
  staffNotificationRecipientUpdate(
    id: ID!
    input: StaffNotificationRecipientInput!
  ): StaffNotificationRecipientUpdate
  staffNotificationRecipientDelete(id: ID!): StaffNotificationRecipientDelete
  shopDomainUpdate(input: SiteDomainInput): ShopDomainUpdate
  shopSettingsUpdate(input: ShopSettingsInput!): ShopSettingsUpdate
  shopFetchTaxRates: ShopFetchTaxRates
  shopSettingsTranslate(
    input: ShopSettingsTranslationInput!
    languageCode: LanguageCodeEnum!
  ): ShopSettingsTranslate
  shopAddressUpdate(input: AddressInput): ShopAddressUpdate
  orderSettingsUpdate(input: OrderSettingsUpdateInput!): OrderSettingsUpdate
  shippingMethodChannelListingUpdate(
    id: ID!
    input: ShippingMethodChannelListingInput!
  ): ShippingMethodChannelListingUpdate
  shippingPriceCreate(input: ShippingPriceInput!): ShippingPriceCreate
  shippingPriceDelete(id: ID!): ShippingPriceDelete
  shippingPriceBulkDelete(ids: [ID]!): ShippingPriceBulkDelete
  shippingPriceUpdate(id: ID!, input: ShippingPriceInput!): ShippingPriceUpdate
  shippingPriceTranslate(
    id: ID!
    input: NameTranslationInput!
    languageCode: LanguageCodeEnum!
  ): ShippingPriceTranslate
  shippingPriceExcludeProducts(
    id: ID!
    input: ShippingPriceExcludeProductsInput!
  ): ShippingPriceExcludeProducts
  shippingPriceRemoveProductFromExclude(
    id: ID!
    products: [ID]!
  ): ShippingPriceRemoveProductFromExclude
  shippingZoneCreate(input: ShippingZoneCreateInput!): ShippingZoneCreate
  shippingZoneDelete(id: ID!): ShippingZoneDelete
  shippingZoneBulkDelete(ids: [ID]!): ShippingZoneBulkDelete
  shippingZoneUpdate(
    id: ID!
    input: ShippingZoneUpdateInput!
  ): ShippingZoneUpdate
  productAttributeAssign(
    operations: [ProductAttributeAssignInput]!
    productTypeId: ID!
  ): ProductAttributeAssign
  productAttributeUnassign(
    attributeIds: [ID]!
    productTypeId: ID!
  ): ProductAttributeUnassign
  categoryCreate(input: CategoryInput!, parent: ID): CategoryCreate
  categoryDelete(id: ID!): CategoryDelete
  categoryBulkDelete(ids: [ID]!): CategoryBulkDelete
  categoryUpdate(id: ID!, input: CategoryInput!): CategoryUpdate
  categoryTranslate(
    id: ID!
    input: TranslationInput!
    languageCode: LanguageCodeEnum!
  ): CategoryTranslate
  collectionAddProducts(
    collectionId: ID!
    products: [ID]!
  ): CollectionAddProducts
  collectionCreate(input: CollectionCreateInput!): CollectionCreate
  collectionDelete(id: ID!): CollectionDelete
  collectionReorderProducts(
    collectionId: ID!
    moves: [MoveProductInput]!
  ): CollectionReorderProducts
  collectionBulkDelete(ids: [ID]!): CollectionBulkDelete
  collectionRemoveProducts(
    collectionId: ID!
    products: [ID]!
  ): CollectionRemoveProducts
  collectionUpdate(id: ID!, input: CollectionInput!): CollectionUpdate
  collectionTranslate(
    id: ID!
    input: TranslationInput!
    languageCode: LanguageCodeEnum!
  ): CollectionTranslate
  collectionChannelListingUpdate(
    id: ID!
    input: CollectionChannelListingUpdateInput!
  ): CollectionChannelListingUpdate
  productCreate(input: ProductCreateInput!): ProductCreate
  productDelete(id: ID!): ProductDelete
  productBulkDelete(ids: [ID]!): ProductBulkDelete
  productUpdate(id: ID!, input: ProductInput!): ProductUpdate
  productTranslate(
    id: ID!
    input: TranslationInput!
    languageCode: LanguageCodeEnum!
  ): ProductTranslate
  productChannelListingUpdate(
    id: ID!
    input: ProductChannelListingUpdateInput!
  ): ProductChannelListingUpdate
  productImageCreate(input: ProductImageCreateInput!): ProductImageCreate
  productVariantReorder(
    moves: [ReorderInput]!
    productId: ID!
  ): ProductVariantReorder
  productImageDelete(id: ID!): ProductImageDelete
  productImageBulkDelete(ids: [ID]!): ProductImageBulkDelete
  productImageReorder(imagesIds: [ID]!, productId: ID!): ProductImageReorder
  productImageUpdate(
    id: ID!
    input: ProductImageUpdateInput!
  ): ProductImageUpdate
  productTypeCreate(input: ProductTypeInput!): ProductTypeCreate
  productTypeDelete(id: ID!): ProductTypeDelete
  productTypeBulkDelete(ids: [ID]!): ProductTypeBulkDelete
  productTypeUpdate(id: ID!, input: ProductTypeInput!): ProductTypeUpdate
  productTypeReorderAttributes(
    moves: [ReorderInput]!
    productTypeId: ID!
    type: ProductAttributeType!
  ): ProductTypeReorderAttributes
  productReorderAttributeValues(
    attributeId: ID!
    moves: [ReorderInput]!
    productId: ID!
  ): ProductReorderAttributeValues
  digitalContentCreate(
    input: DigitalContentUploadInput!
    variantId: ID!
  ): DigitalContentCreate
  digitalContentDelete(variantId: ID!): DigitalContentDelete
  digitalContentUpdate(
    input: DigitalContentInput!
    variantId: ID!
  ): DigitalContentUpdate
  digitalContentUrlCreate(
    input: DigitalContentUrlCreateInput!
  ): DigitalContentUrlCreate
  productVariantCreate(input: ProductVariantCreateInput!): ProductVariantCreate
  productVariantDelete(id: ID!): ProductVariantDelete
  productVariantBulkCreate(
    product: ID!
    variants: [ProductVariantBulkCreateInput]!
  ): ProductVariantBulkCreate
  productVariantBulkDelete(ids: [ID]!): ProductVariantBulkDelete
  productVariantStocksCreate(
    stocks: [StockInput!]!
    variantId: ID!
  ): ProductVariantStocksCreate
  productVariantStocksDelete(
    variantId: ID!
    warehouseIds: [ID!]
  ): ProductVariantStocksDelete
  productVariantStocksUpdate(
    stocks: [StockInput!]!
    variantId: ID!
  ): ProductVariantStocksUpdate
  productVariantUpdate(
    id: ID!
    input: ProductVariantInput!
  ): ProductVariantUpdate
  productVariantSetDefault(
    productId: ID!
    variantId: ID!
  ): ProductVariantSetDefault
  productVariantTranslate(
    id: ID!
    input: NameTranslationInput!
    languageCode: LanguageCodeEnum!
  ): ProductVariantTranslate
  productVariantChannelListingUpdate(
    id: ID!
    input: [ProductVariantChannelListingAddInput!]!
  ): ProductVariantChannelListingUpdate
  productVariantReorderAttributeValues(
    attributeId: ID!
    moves: [ReorderInput]!
    variantId: ID!
  ): ProductVariantReorderAttributeValues
  variantImageAssign(imageId: ID!, variantId: ID!): VariantImageAssign
  variantImageUnassign(imageId: ID!, variantId: ID!): VariantImageUnassign
  paymentCapture(amount: PositiveDecimal, paymentId: ID!): PaymentCapture
  paymentRefund(amount: PositiveDecimal, paymentId: ID!): PaymentRefund
  paymentVoid(paymentId: ID!): PaymentVoid
  paymentInitialize(
    gateway: String!
    paymentData: JSONString
  ): PaymentInitialize
  pageCreate(input: PageCreateInput!): PageCreate
  pageDelete(id: ID!): PageDelete
  pageBulkDelete(ids: [ID]!): PageBulkDelete
  pageBulkPublish(ids: [ID]!, isPublished: Boolean!): PageBulkPublish
  pageUpdate(id: ID!, input: PageInput!): PageUpdate
  pageTranslate(
    id: ID!
    input: PageTranslationInput!
    languageCode: LanguageCodeEnum!
  ): PageTranslate
  pageTypeCreate(input: PageTypeCreateInput!): PageTypeCreate
  pageTypeUpdate(id: ID, input: PageTypeUpdateInput!): PageTypeUpdate
  pageTypeDelete(id: ID!): PageTypeDelete
  pageTypeBulkDelete(ids: [ID!]!): PageTypeBulkDelete
  pageAttributeAssign(
    attributeIds: [ID!]!
    pageTypeId: ID!
  ): PageAttributeAssign
  pageAttributeUnassign(
    attributeIds: [ID!]!
    pageTypeId: ID!
  ): PageAttributeUnassign
  pageTypeReorderAttributes(
    moves: [ReorderInput!]!
    pageTypeId: ID!
  ): PageTypeReorderAttributes
  pageReorderAttributeValues(
    attributeId: ID!
    moves: [ReorderInput]!
    pageId: ID!
  ): PageReorderAttributeValues
  draftOrderComplete(id: ID!): DraftOrderComplete
  draftOrderCreate(input: DraftOrderCreateInput!): DraftOrderCreate
  draftOrderDelete(id: ID!): DraftOrderDelete
  draftOrderBulkDelete(ids: [ID]!): DraftOrderBulkDelete
  draftOrderLinesBulkDelete(ids: [ID]!): DraftOrderLinesBulkDelete
  draftOrderLinesCreate(
    id: ID!
    input: [OrderLineCreateInput]!
  ): DraftOrderLinesCreate
  draftOrderLineDelete(id: ID!): DraftOrderLineDelete
  draftOrderLineUpdate(id: ID!, input: OrderLineInput!): DraftOrderLineUpdate
  draftOrderUpdate(id: ID!, input: DraftOrderInput!): DraftOrderUpdate
  orderAddNote(order: ID!, input: OrderAddNoteInput!): OrderAddNote
  orderCancel(id: ID!): OrderCancel
  orderCapture(amount: PositiveDecimal!, id: ID!): OrderCapture
  orderConfirm(id: ID!): OrderConfirm
  orderFulfill(input: OrderFulfillInput!, order: ID): OrderFulfill
  orderFulfillmentCancel(
    id: ID!
    input: FulfillmentCancelInput!
  ): FulfillmentCancel
  orderFulfillmentUpdateTracking(
    id: ID!
    input: FulfillmentUpdateTrackingInput!
  ): FulfillmentUpdateTracking
  orderFulfillmentRefundProducts(
    input: OrderRefundProductsInput!
    order: ID!
  ): FulfillmentRefundProducts
  orderFulfillmentReturnProducts(
    input: OrderReturnProductsInput!
    order: ID!
  ): FulfillmentReturnProducts
  orderDiscountAdd(
    input: OrderDiscountCommonInput!
    orderId: ID!
  ): OrderDiscountAdd
  orderDiscountUpdate(
    discountId: ID!
    input: OrderDiscountCommonInput!
  ): OrderDiscountUpdate
  orderDiscountDelete(discountId: ID!): OrderDiscountDelete
  orderLineDiscountUpdate(
    input: OrderDiscountCommonInput!
    orderLineId: ID!
  ): OrderLineDiscountUpdate
  orderLineDiscountRemove(orderLineId: ID!): OrderLineDiscountRemove
  orderMarkAsPaid(id: ID!, transactionReference: String): OrderMarkAsPaid
  orderRefund(amount: PositiveDecimal!, id: ID!): OrderRefund
  orderUpdate(id: ID!, input: OrderUpdateInput!): OrderUpdate
  orderUpdateShipping(
    order: ID!
    input: OrderUpdateShippingInput
  ): OrderUpdateShipping
  orderVoid(id: ID!): OrderVoid
  orderBulkCancel(ids: [ID]!): OrderBulkCancel
  deleteMetadata(id: ID!, keys: [String!]!): DeleteMetadata
  deletePrivateMetadata(id: ID!, keys: [String!]!): DeletePrivateMetadata
  updateMetadata(id: ID!, input: [MetadataInput!]!): UpdateMetadata
  updatePrivateMetadata(
    id: ID!
    input: [MetadataInput!]!
  ): UpdatePrivateMetadata
  assignNavigation(menu: ID, navigationType: NavigationType!): AssignNavigation
  menuCreate(input: MenuCreateInput!): MenuCreate
  menuDelete(id: ID!): MenuDelete
  menuBulkDelete(ids: [ID]!): MenuBulkDelete
  menuUpdate(id: ID!, input: MenuInput!): MenuUpdate
  menuItemCreate(input: MenuItemCreateInput!): MenuItemCreate
  menuItemDelete(id: ID!): MenuItemDelete
  menuItemBulkDelete(ids: [ID]!): MenuItemBulkDelete
  menuItemUpdate(id: ID!, input: MenuItemInput!): MenuItemUpdate
  menuItemTranslate(
    id: ID!
    input: NameTranslationInput!
    languageCode: LanguageCodeEnum!
  ): MenuItemTranslate
  menuItemMove(menu: ID!, moves: [MenuItemMoveInput]!): MenuItemMove
  invoiceRequest(number: String, orderId: ID!): InvoiceRequest
  invoiceRequestDelete(id: ID!): InvoiceRequestDelete
  invoiceCreate(input: InvoiceCreateInput!, orderId: ID!): InvoiceCreate
  invoiceDelete(id: ID!): InvoiceDelete
  invoiceUpdate(id: ID!, input: UpdateInvoiceInput!): InvoiceUpdate
  invoiceSendEmail(id: ID!): InvoiceSendEmail
  giftCardActivate(id: ID!): GiftCardActivate
  giftCardCreate(input: GiftCardCreateInput!): GiftCardCreate
  giftCardDeactivate(id: ID!): GiftCardDeactivate
  giftCardUpdate(id: ID!, input: GiftCardUpdateInput!): GiftCardUpdate
  pluginUpdate(id: ID!, input: PluginUpdateInput!): PluginUpdate
  saleCreate(input: SaleInput!): SaleCreate
  saleDelete(id: ID!): SaleDelete
  saleBulkDelete(ids: [ID]!): SaleBulkDelete
  saleUpdate(id: ID!, input: SaleInput!): SaleUpdate
  saleCataloguesAdd(id: ID!, input: CatalogueInput!): SaleAddCatalogues
  saleCataloguesRemove(id: ID!, input: CatalogueInput!): SaleRemoveCatalogues
  saleTranslate(
    id: ID!
    input: NameTranslationInput!
    languageCode: LanguageCodeEnum!
  ): SaleTranslate
  saleChannelListingUpdate(
    id: ID!
    input: SaleChannelListingInput!
  ): SaleChannelListingUpdate
  voucherCreate(input: VoucherInput!): VoucherCreate
  voucherDelete(id: ID!): VoucherDelete
  voucherBulkDelete(ids: [ID]!): VoucherBulkDelete
  voucherUpdate(id: ID!, input: VoucherInput!): VoucherUpdate
  voucherCataloguesAdd(id: ID!, input: CatalogueInput!): VoucherAddCatalogues
  voucherCataloguesRemove(
    id: ID!
    input: CatalogueInput!
  ): VoucherRemoveCatalogues
  voucherTranslate(
    id: ID!
    input: NameTranslationInput!
    languageCode: LanguageCodeEnum!
  ): VoucherTranslate
  voucherChannelListingUpdate(
    id: ID!
    input: VoucherChannelListingInput!
  ): VoucherChannelListingUpdate
  exportProducts(input: ExportProductsInput!): ExportProducts
  fileUpload(file: Upload!): FileUpload
  checkoutAddPromoCode(
    checkoutId: ID!
    promoCode: String!
  ): CheckoutAddPromoCode
  checkoutBillingAddressUpdate(
    billingAddress: AddressInput!
    checkoutId: ID!
  ): CheckoutBillingAddressUpdate
  checkoutComplete(
    checkoutId: ID!
    paymentData: JSONString
    redirectUrl: String
    storeSource: Boolean = false
  ): CheckoutComplete
  checkoutCreate(input: CheckoutCreateInput!): CheckoutCreate
  checkoutCustomerAttach(
    checkoutId: ID!
    customerId: ID
  ): CheckoutCustomerAttach
  checkoutCustomerDetach(checkoutId: ID!): CheckoutCustomerDetach
  checkoutEmailUpdate(checkoutId: ID, email: String!): CheckoutEmailUpdate
  checkoutLineDelete(checkoutId: ID!, lineId: ID): CheckoutLineDelete
  checkoutLinesAdd(
    checkoutId: ID!
    lines: [CheckoutLineInput]!
  ): CheckoutLinesAdd
  checkoutLinesUpdate(
    checkoutId: ID!
    lines: [CheckoutLineInput]!
  ): CheckoutLinesUpdate
  checkoutRemovePromoCode(
    checkoutId: ID!
    promoCode: String!
  ): CheckoutRemovePromoCode
  checkoutPaymentCreate(
    checkoutId: ID!
    input: PaymentInput!
  ): CheckoutPaymentCreate
  checkoutShippingAddressUpdate(
    checkoutId: ID!
    shippingAddress: AddressInput!
  ): CheckoutShippingAddressUpdate
  checkoutShippingMethodUpdate(
    checkoutId: ID
    shippingMethodId: ID!
  ): CheckoutShippingMethodUpdate
  channelCreate(input: ChannelCreateInput!): ChannelCreate
  channelUpdate(id: ID!, input: ChannelUpdateInput!): ChannelUpdate
  channelDelete(id: ID!, input: ChannelDeleteInput): ChannelDelete
  channelActivate(id: ID!): ChannelActivate
  channelDeactivate(id: ID!): ChannelDeactivate
  attributeCreate(input: AttributeCreateInput!): AttributeCreate
  attributeDelete(id: ID!): AttributeDelete
  attributeUpdate(id: ID!, input: AttributeUpdateInput!): AttributeUpdate
  attributeTranslate(
    id: ID!
    input: NameTranslationInput!
    languageCode: LanguageCodeEnum!
  ): AttributeTranslate
  attributeBulkDelete(ids: [ID]!): AttributeBulkDelete
  attributeValueBulkDelete(ids: [ID]!): AttributeValueBulkDelete
  attributeValueCreate(
    attribute: ID!
    input: AttributeValueCreateInput!
  ): AttributeValueCreate
  attributeValueDelete(id: ID!): AttributeValueDelete
  attributeValueUpdate(
    id: ID!
    input: AttributeValueCreateInput!
  ): AttributeValueUpdate
  attributeValueTranslate(
    id: ID!
    input: NameTranslationInput!
    languageCode: LanguageCodeEnum!
  ): AttributeValueTranslate
  attributeReorderValues(
    attributeId: ID!
    moves: [ReorderInput]!
  ): AttributeReorderValues
  appCreate(input: AppInput!): AppCreate
  appUpdate(id: ID!, input: AppInput!): AppUpdate
  appDelete(id: ID!): AppDelete
  appTokenCreate(input: AppTokenInput!): AppTokenCreate
  appTokenDelete(id: ID!): AppTokenDelete
  appTokenVerify(token: String!): AppTokenVerify
  appInstall(input: AppInstallInput!): AppInstall
  appRetryInstall(
    activateAfterInstallation: Boolean = true
    id: ID!
  ): AppRetryInstall
  appDeleteFailedInstallation(id: ID!): AppDeleteFailedInstallation
  appFetchManifest(manifestUrl: String!): AppFetchManifest
  appActivate(id: ID!): AppActivate
  appDeactivate(id: ID!): AppDeactivate
  tokenCreate(email: String!, password: String!): CreateToken
  tokenRefresh(csrfToken: String, refreshToken: String): RefreshToken
  tokenVerify(token: String!): VerifyToken
  tokensDeactivateAll: DeactivateAllUserTokens
  externalAuthenticationUrl(
    input: JSONString!
    pluginId: String!
  ): ExternalAuthenticationUrl
  externalObtainAccessTokens(
    input: JSONString!
    pluginId: String!
  ): ExternalObtainAccessTokens
  externalRefresh(input: JSONString!, pluginId: String!): ExternalRefresh
  externalLogout(input: JSONString!, pluginId: String!): ExternalLogout
  externalVerify(input: JSONString!, pluginId: String!): ExternalVerify
  requestPasswordReset(
    email: String!
    redirectUrl: String!
  ): RequestPasswordReset
  confirmAccount(email: String!, token: String!): ConfirmAccount
  setPassword(email: String!, password: String!, token: String!): SetPassword
  passwordChange(newPassword: String!, oldPassword: String!): PasswordChange
  requestEmailChange(
    newEmail: String!
    password: String!
    redirectUrl: String!
  ): RequestEmailChange
  confirmEmailChange(token: String!): ConfirmEmailChange
  accountAddressCreate(
    input: AddressInput!
    type: AddressTypeEnum
  ): AccountAddressCreate
  accountAddressUpdate(id: ID!, input: AddressInput!): AccountAddressUpdate
  accountAddressDelete(id: ID!): AccountAddressDelete
  accountSetDefaultAddress(
    id: ID!
    type: AddressTypeEnum!
  ): AccountSetDefaultAddress
  accountRegister(input: AccountRegisterInput!): AccountRegister
  accountUpdate(input: AccountInput!): AccountUpdate
  accountRequestDeletion(redirectUrl: String!): AccountRequestDeletion
  accountDelete(token: String!): AccountDelete
  addressCreate(input: AddressInput!, userId: ID!): AddressCreate
  addressUpdate(id: ID!, input: AddressInput!): AddressUpdate
  addressDelete(id: ID!): AddressDelete
  addressSetDefault(
    addressId: ID!
    type: AddressTypeEnum!
    userId: ID!
  ): AddressSetDefault
  customerCreate(input: UserCreateInput!): CustomerCreate
  customerUpdate(id: ID!, input: CustomerInput!): CustomerUpdate
  customerDelete(id: ID!): CustomerDelete
  customerBulkDelete(ids: [ID]!): CustomerBulkDelete
  staffCreate(input: StaffCreateInput!): StaffCreate
  staffUpdate(id: ID!, input: StaffUpdateInput!): StaffUpdate
  staffDelete(id: ID!): StaffDelete
  staffBulkDelete(ids: [ID]!): StaffBulkDelete
  userAvatarUpdate(image: Upload!): UserAvatarUpdate
  userAvatarDelete: UserAvatarDelete
  userBulkSetActive(ids: [ID]!, isActive: Boolean!): UserBulkSetActive
  permissionGroupCreate(
    input: PermissionGroupCreateInput!
  ): PermissionGroupCreate
  permissionGroupUpdate(
    id: ID!
    input: PermissionGroupUpdateInput!
  ): PermissionGroupUpdate
  permissionGroupDelete(id: ID!): PermissionGroupDelete
}

input NameTranslationInput {
  name: String
}

type Navigation {
  main: Menu
  secondary: Menu
}

enum NavigationType {
  MAIN
  SECONDARY
}

interface Node {
  id: ID!
}

interface ObjectWithMetadata {
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
}

type Order implements Node & ObjectWithMetadata {
  id: ID!
  created: DateTime!
  status: OrderStatus!
  user: User
  languageCode: String!
  trackingClientId: String!
  billingAddress: Address
  shippingAddress: Address
  shippingMethod: ShippingMethod
  shippingMethodName: String
  channel: Channel!
  shippingPrice: TaxedMoney!
  shippingTaxRate: Float!
  token: String!
  voucher: Voucher
  giftCards: [GiftCard]
  displayGrossPrices: Boolean!
  customerNote: String!
  weight: Weight
  redirectUrl: String
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  fulfillments: [Fulfillment]!
  lines: [OrderLine]!
  actions: [OrderAction]!
  availableShippingMethods: [ShippingMethod]
  invoices: [Invoice]
  number: String
  isPaid: Boolean!
  paymentStatus: PaymentChargeStatusEnum!
  paymentStatusDisplay: String!
  payments: [Payment]
  total: TaxedMoney!
  undiscountedTotal: TaxedMoney!
  subtotal: TaxedMoney!
  statusDisplay: String
  canFinalize: Boolean!
  totalAuthorized: Money!
  totalCaptured: Money!
  events: [OrderEvent]
  totalBalance: Money!
  userEmail: String
  isShippingRequired: Boolean!
  discount: Money
    @deprecated(
      reason: "Use discounts field. This field will be removed after 2021-08-01"
    )
  discountName: String
    @deprecated(
      reason: "Use discounts field. This field will be removed after 2021-08-01"
    )
  translatedDiscountName: String
    @deprecated(
      reason: "Use discounts field. This field will be removed after 2021-08-01"
    )
  discounts: [OrderDiscount!]
}

enum OrderAction {
  CAPTURE
  MARK_AS_PAID
  REFUND
  VOID
}

type OrderAddNote {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  event: OrderEvent
  orderErrors: [OrderError!]!
}

input OrderAddNoteInput {
  message: String!
}

type OrderBulkCancel {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  orderErrors: [OrderError!]!
}

type OrderCancel {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

type OrderCapture {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

type OrderConfirm {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

type OrderCountableConnection {
  pageInfo: PageInfo!
  edges: [OrderCountableEdge!]!
  totalCount: Int
}

type OrderCountableEdge {
  node: Order!
  cursor: String!
}

enum OrderDirection {
  ASC
  DESC
}

type OrderDiscount implements Node {
  id: ID!
  type: OrderDiscountType!
  valueType: DiscountValueTypeEnum!
  value: PositiveDecimal!
  name: String
  translatedName: String
  reason: String
  amount: Money!
}

type OrderDiscountAdd {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

input OrderDiscountCommonInput {
  valueType: DiscountValueTypeEnum!
  value: PositiveDecimal!
  reason: String
}

type OrderDiscountDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

enum OrderDiscountType {
  VOUCHER
  MANUAL
}

type OrderDiscountUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

input OrderDraftFilterInput {
  customer: String
  created: DateRangeInput
  search: String
  channels: [ID]
}

type OrderError {
  field: String
  message: String
  code: OrderErrorCode!
  warehouse: ID
  orderLine: ID
  variants: [ID!]
}

enum OrderErrorCode {
  BILLING_ADDRESS_NOT_SET
  CANNOT_CANCEL_FULFILLMENT
  CANNOT_CANCEL_ORDER
  CANNOT_DELETE
  CANNOT_DISCOUNT
  CANNOT_REFUND
  CAPTURE_INACTIVE_PAYMENT
  NOT_EDITABLE
  FULFILL_ORDER_LINE
  GRAPHQL_ERROR
  INVALID
  PRODUCT_NOT_PUBLISHED
  PRODUCT_UNAVAILABLE_FOR_PURCHASE
  NOT_FOUND
  ORDER_NO_SHIPPING_ADDRESS
  PAYMENT_ERROR
  PAYMENT_MISSING
  REQUIRED
  SHIPPING_METHOD_NOT_APPLICABLE
  SHIPPING_METHOD_REQUIRED
  TAX_ERROR
  UNIQUE
  VOID_INACTIVE_PAYMENT
  ZERO_QUANTITY
  INVALID_QUANTITY
  INSUFFICIENT_STOCK
  DUPLICATED_INPUT_ITEM
  NOT_AVAILABLE_IN_CHANNEL
  CHANNEL_INACTIVE
}

type OrderEvent implements Node {
  id: ID!
  date: DateTime
  type: OrderEventsEnum
  user: User
  message: String
  email: String
  emailType: OrderEventsEmailsEnum
  amount: Float
  paymentId: String
  paymentGateway: String
  quantity: Int
  composedId: String
  orderNumber: String
  invoiceNumber: String
  oversoldItems: [String]
  lines: [OrderEventOrderLineObject]
  fulfilledItems: [FulfillmentLine]
  warehouse: Warehouse
  transactionReference: String
  shippingCostsIncluded: Boolean
  relatedOrder: Order
  discount: OrderEventDiscountObject
}

type OrderEventCountableConnection {
  pageInfo: PageInfo!
  edges: [OrderEventCountableEdge!]!
  totalCount: Int
}

type OrderEventCountableEdge {
  node: OrderEvent!
  cursor: String!
}

type OrderEventDiscountObject {
  valueType: DiscountValueTypeEnum!
  value: PositiveDecimal!
  reason: String
  amount: Money
  oldValueType: DiscountValueTypeEnum
  oldValue: PositiveDecimal
  oldAmount: Money
}

type OrderEventOrderLineObject {
  quantity: Int
  orderLine: OrderLine
  itemName: String
  discount: OrderEventDiscountObject
}

enum OrderEventsEmailsEnum {
  PAYMENT_CONFIRMATION
  CONFIRMED
  SHIPPING_CONFIRMATION
  TRACKING_UPDATED
  ORDER_CONFIRMATION
  ORDER_CANCEL
  ORDER_REFUND
  FULFILLMENT_CONFIRMATION
  DIGITAL_LINKS
}

enum OrderEventsEnum {
  DRAFT_CREATED
  DRAFT_CREATED_FROM_REPLACE
  DRAFT_ADDED_PRODUCTS
  DRAFT_REMOVED_PRODUCTS
  PLACED
  PLACED_FROM_DRAFT
  OVERSOLD_ITEMS
  CANCELED
  ORDER_MARKED_AS_PAID
  ORDER_FULLY_PAID
  ORDER_REPLACEMENT_CREATED
  ORDER_DISCOUNT_ADDED
  ORDER_DISCOUNT_UPDATED
  ORDER_DISCOUNT_DELETED
  ORDER_DISCOUNT_AUTOMATICALLY_UPDATED
  ORDER_LINE_DISCOUNT_UPDATED
  ORDER_LINE_DISCOUNT_REMOVED
  UPDATED_ADDRESS
  EMAIL_SENT
  CONFIRMED
  PAYMENT_AUTHORIZED
  PAYMENT_CAPTURED
  EXTERNAL_SERVICE_NOTIFICATION
  PAYMENT_REFUNDED
  PAYMENT_VOIDED
  PAYMENT_FAILED
  INVOICE_REQUESTED
  INVOICE_GENERATED
  INVOICE_UPDATED
  INVOICE_SENT
  FULFILLMENT_CANCELED
  FULFILLMENT_RESTOCKED_ITEMS
  FULFILLMENT_FULFILLED_ITEMS
  FULFILLMENT_REFUNDED
  FULFILLMENT_RETURNED
  FULFILLMENT_REPLACED
  TRACKING_UPDATED
  NOTE_ADDED
  OTHER
}

input OrderFilterInput {
  paymentStatus: [PaymentChargeStatusEnum]
  status: [OrderStatusFilter]
  customer: String
  created: DateRangeInput
  search: String
  channels: [ID]
}

type OrderFulfill {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  fulfillments: [Fulfillment]
  order: Order
  orderErrors: [OrderError!]!
}

input OrderFulfillInput {
  lines: [OrderFulfillLineInput!]!
  notifyCustomer: Boolean
}

input OrderFulfillLineInput {
  orderLineId: ID
  stocks: [OrderFulfillStockInput!]!
}

input OrderFulfillStockInput {
  quantity: Int!
  warehouse: ID!
}

type OrderLine implements Node {
  id: ID!
  productName: String!
  variantName: String!
  productSku: String!
  isShippingRequired: Boolean!
  quantity: Int!
  quantityFulfilled: Int!
  unitDiscountReason: String
  taxRate: Float!
  digitalContentUrl: DigitalContentUrl
  thumbnail(size: Int): Image
  unitPrice: TaxedMoney!
  undiscountedUnitPrice: TaxedMoney!
  unitDiscount: Money!
  unitDiscountValue: PositiveDecimal!
  totalPrice: TaxedMoney!
  variant: ProductVariant
  translatedProductName: String!
  translatedVariantName: String!
  allocations: [Allocation!]
  unitDiscountType: DiscountValueTypeEnum
}

input OrderLineCreateInput {
  quantity: Int!
  variantId: ID!
}

type OrderLineDiscountRemove {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  orderLine: OrderLine
  order: Order
  orderErrors: [OrderError!]!
}

type OrderLineDiscountUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  orderLine: OrderLine
  order: Order
  orderErrors: [OrderError!]!
}

input OrderLineInput {
  quantity: Int!
}

type OrderMarkAsPaid {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

type OrderRefund {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

input OrderRefundFulfillmentLineInput {
  fulfillmentLineId: ID!
  quantity: Int!
}

input OrderRefundLineInput {
  orderLineId: ID!
  quantity: Int!
}

input OrderRefundProductsInput {
  orderLines: [OrderRefundLineInput!]
  fulfillmentLines: [OrderRefundFulfillmentLineInput!]
  amountToRefund: PositiveDecimal
  includeShippingCosts: Boolean = false
}

input OrderReturnFulfillmentLineInput {
  fulfillmentLineId: ID!
  quantity: Int!
  replace: Boolean = false
}

input OrderReturnLineInput {
  orderLineId: ID!
  quantity: Int!
  replace: Boolean = false
}

input OrderReturnProductsInput {
  orderLines: [OrderReturnLineInput!]
  fulfillmentLines: [OrderReturnFulfillmentLineInput!]
  amountToRefund: PositiveDecimal
  includeShippingCosts: Boolean = false
  refund: Boolean = false
}

type OrderSettings {
  automaticallyConfirmAllNewOrders: Boolean!
}

type OrderSettingsError {
  field: String
  message: String
  code: OrderSettingsErrorCode!
}

enum OrderSettingsErrorCode {
  INVALID
}

type OrderSettingsUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  orderSettings: OrderSettings
  orderSettingsErrors: [OrderSettingsError!]!
}

input OrderSettingsUpdateInput {
  automaticallyConfirmAllNewOrders: Boolean!
}

enum OrderSortField {
  NUMBER
  CREATION_DATE
  CUSTOMER
  PAYMENT
  FULFILLMENT_STATUS
}

input OrderSortingInput {
  direction: OrderDirection!
  field: OrderSortField!
}

enum OrderStatus {
  DRAFT
  UNCONFIRMED
  UNFULFILLED
  PARTIALLY_FULFILLED
  PARTIALLY_RETURNED
  RETURNED
  FULFILLED
  CANCELED
}

enum OrderStatusFilter {
  READY_TO_FULFILL
  READY_TO_CAPTURE
  UNFULFILLED
  UNCONFIRMED
  PARTIALLY_FULFILLED
  FULFILLED
  CANCELED
}

type OrderUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  orderErrors: [OrderError!]!
  order: Order
}

input OrderUpdateInput {
  billingAddress: AddressInput
  userEmail: String
  shippingAddress: AddressInput
}

type OrderUpdateShipping {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

input OrderUpdateShippingInput {
  shippingMethod: ID
}

type OrderVoid {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  order: Order
  orderErrors: [OrderError!]!
}

type Page implements Node & ObjectWithMetadata {
  seoTitle: String
  seoDescription: String
  id: ID!
  title: String!
  content: JSONString
  publicationDate: Date
  isPublished: Boolean!
  slug: String!
  pageType: PageType!
  created: DateTime!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  contentJson: JSONString!
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `content` field instead."
    )
  translation(languageCode: LanguageCodeEnum!): PageTranslation
  attributes: [SelectedAttribute!]!
}

type PageAttributeAssign {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  pageType: PageType
  pageErrors: [PageError!]!
}

type PageAttributeUnassign {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  pageType: PageType
  pageErrors: [PageError!]!
}

type PageBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  pageErrors: [PageError!]!
}

type PageBulkPublish {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  pageErrors: [PageError!]!
}

type PageCountableConnection {
  pageInfo: PageInfo!
  edges: [PageCountableEdge!]!
  totalCount: Int
}

type PageCountableEdge {
  node: Page!
  cursor: String!
}

type PageCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  pageErrors: [PageError!]!
  page: Page
}

input PageCreateInput {
  slug: String
  title: String
  content: JSONString
  attributes: [AttributeValueInput!]
  isPublished: Boolean
  publicationDate: String
  seo: SeoInput
  pageType: ID!
}

type PageDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  pageErrors: [PageError!]!
  page: Page
}

type PageError {
  field: String
  message: String
  code: PageErrorCode!
  attributes: [ID!]
  values: [ID!]
}

enum PageErrorCode {
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
  DUPLICATED_INPUT_ITEM
  ATTRIBUTE_ALREADY_ASSIGNED
}

input PageFilterInput {
  search: String
}

type PageInfo {
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
  endCursor: String
}

input PageInput {
  slug: String
  title: String
  content: JSONString
  attributes: [AttributeValueInput!]
  isPublished: Boolean
  publicationDate: String
  seo: SeoInput
}

type PageReorderAttributeValues {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  page: Page
  pageErrors: [PageError!]!
}

enum PageSortField {
  TITLE
  SLUG
  VISIBILITY
  CREATION_DATE
  PUBLICATION_DATE
}

input PageSortingInput {
  direction: OrderDirection!
  field: PageSortField!
}

type PageTranslatableContent implements Node {
  seoTitle: String
  seoDescription: String
  id: ID!
  title: String!
  content: JSONString
  contentJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `content` field instead."
    )
  translation(languageCode: LanguageCodeEnum!): PageTranslation
  page: Page
}

type PageTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  page: PageTranslatableContent
}

type PageTranslation implements Node {
  seoTitle: String
  seoDescription: String
  id: ID!
  title: String!
  content: JSONString
  language: LanguageDisplay!
  contentJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `content` field instead."
    )
}

input PageTranslationInput {
  seoTitle: String
  seoDescription: String
  title: String
  content: JSONString
}

type PageType implements Node & ObjectWithMetadata {
  id: ID!
  name: String!
  slug: String!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  attributes: [Attribute]
  availableAttributes(
    filter: AttributeFilterInput
    before: String
    after: String
    first: Int
    last: Int
  ): AttributeCountableConnection
  hasPages: Boolean
}

type PageTypeBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  pageErrors: [PageError!]!
}

type PageTypeCountableConnection {
  pageInfo: PageInfo!
  edges: [PageTypeCountableEdge!]!
  totalCount: Int
}

type PageTypeCountableEdge {
  node: PageType!
  cursor: String!
}

type PageTypeCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  pageErrors: [PageError!]!
  pageType: PageType
}

input PageTypeCreateInput {
  name: String
  slug: String
  addAttributes: [ID!]
}

type PageTypeDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  pageErrors: [PageError!]!
  pageType: PageType
}

input PageTypeFilterInput {
  search: String
}

type PageTypeReorderAttributes {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  pageType: PageType
  pageErrors: [PageError!]!
}

enum PageTypeSortField {
  NAME
  SLUG
}

input PageTypeSortingInput {
  direction: OrderDirection!
  field: PageTypeSortField!
}

type PageTypeUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  pageErrors: [PageError!]!
  pageType: PageType
}

input PageTypeUpdateInput {
  name: String
  slug: String
  addAttributes: [ID!]
  removeAttributes: [ID!]
}

type PageUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  pageErrors: [PageError!]!
  page: Page
}

type PasswordChange {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
}

type Payment implements Node {
  id: ID!
  gateway: String!
  isActive: Boolean!
  created: DateTime!
  modified: DateTime!
  token: String!
  checkout: Checkout
  order: Order
  customerIpAddress: String
  chargeStatus: PaymentChargeStatusEnum!
  actions: [OrderAction]!
  total: Money
  capturedAmount: Money
  transactions: [Transaction]
  availableCaptureAmount: Money
  availableRefundAmount: Money
  creditCard: CreditCard
}

type PaymentCapture {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  payment: Payment
  paymentErrors: [PaymentError!]!
}

enum PaymentChargeStatusEnum {
  NOT_CHARGED
  PENDING
  PARTIALLY_CHARGED
  FULLY_CHARGED
  PARTIALLY_REFUNDED
  FULLY_REFUNDED
  REFUSED
  CANCELLED
}

type PaymentCountableConnection {
  pageInfo: PageInfo!
  edges: [PaymentCountableEdge!]!
  totalCount: Int
}

type PaymentCountableEdge {
  node: Payment!
  cursor: String!
}

type PaymentError {
  field: String
  message: String
  code: PaymentErrorCode!
}

enum PaymentErrorCode {
  BILLING_ADDRESS_NOT_SET
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
  PARTIAL_PAYMENT_NOT_ALLOWED
  SHIPPING_ADDRESS_NOT_SET
  INVALID_SHIPPING_METHOD
  SHIPPING_METHOD_NOT_SET
  PAYMENT_ERROR
  NOT_SUPPORTED_GATEWAY
}

type PaymentGateway {
  name: String!
  id: ID!
  config: [GatewayConfigLine!]!
  currencies: [String]!
}

type PaymentInitialize {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  initializedPayment: PaymentInitialized
  paymentErrors: [PaymentError!]!
}

type PaymentInitialized {
  gateway: String!
  name: String!
  data: JSONString
}

input PaymentInput {
  gateway: String!
  token: String
  amount: PositiveDecimal
  returnUrl: String
}

type PaymentRefund {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  payment: Payment
  paymentErrors: [PaymentError!]!
}

type PaymentSource {
  gateway: String!
  creditCardInfo: CreditCard
}

type PaymentVoid {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  payment: Payment
  paymentErrors: [PaymentError!]!
}

type Permission {
  code: PermissionEnum!
  name: String!
}

enum PermissionEnum {
  MANAGE_USERS
  MANAGE_STAFF
  MANAGE_APPS
  MANAGE_CHANNELS
  MANAGE_DISCOUNTS
  MANAGE_PLUGINS
  MANAGE_GIFT_CARD
  MANAGE_MENUS
  MANAGE_ORDERS
  MANAGE_PAGES
  MANAGE_PAGE_TYPES_AND_ATTRIBUTES
  MANAGE_PRODUCTS
  MANAGE_PRODUCT_TYPES_AND_ATTRIBUTES
  MANAGE_SHIPPING
  MANAGE_SETTINGS
  MANAGE_TRANSLATIONS
  MANAGE_CHECKOUTS
}

type PermissionGroupCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  permissionGroupErrors: [PermissionGroupError!]!
  group: Group
}

input PermissionGroupCreateInput {
  addPermissions: [PermissionEnum!]
  addUsers: [ID!]
  name: String!
}

type PermissionGroupDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  permissionGroupErrors: [PermissionGroupError!]!
  group: Group
}

type PermissionGroupError {
  field: String
  message: String
  code: PermissionGroupErrorCode!
  permissions: [PermissionEnum!]
  users: [ID!]
}

enum PermissionGroupErrorCode {
  ASSIGN_NON_STAFF_MEMBER
  DUPLICATED_INPUT_ITEM
  CANNOT_REMOVE_FROM_LAST_GROUP
  LEFT_NOT_MANAGEABLE_PERMISSION
  OUT_OF_SCOPE_PERMISSION
  OUT_OF_SCOPE_USER
  REQUIRED
  UNIQUE
}

input PermissionGroupFilterInput {
  search: String
}

enum PermissionGroupSortField {
  NAME
}

input PermissionGroupSortingInput {
  direction: OrderDirection!
  field: PermissionGroupSortField!
}

type PermissionGroupUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  permissionGroupErrors: [PermissionGroupError!]!
  group: Group
}

input PermissionGroupUpdateInput {
  addPermissions: [PermissionEnum!]
  addUsers: [ID!]
  name: String
  removePermissions: [PermissionEnum!]
  removeUsers: [ID!]
}

type Plugin implements Node {
  id: ID!
  name: String!
  description: String!
  active: Boolean!
  configuration: [ConfigurationItem]
}

type PluginCountableConnection {
  pageInfo: PageInfo!
  edges: [PluginCountableEdge!]!
  totalCount: Int
}

type PluginCountableEdge {
  node: Plugin!
  cursor: String!
}

type PluginError {
  field: String
  message: String
  code: PluginErrorCode!
}

enum PluginErrorCode {
  GRAPHQL_ERROR
  INVALID
  PLUGIN_MISCONFIGURED
  NOT_FOUND
  REQUIRED
  UNIQUE
}

input PluginFilterInput {
  active: Boolean
  search: String
}

enum PluginSortField {
  NAME
  IS_ACTIVE
}

input PluginSortingInput {
  direction: OrderDirection!
  field: PluginSortField!
}

type PluginUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  plugin: Plugin
  pluginsErrors: [PluginError!]!
}

input PluginUpdateInput {
  active: Boolean
  configuration: [ConfigurationItemInput]
}

scalar PositiveDecimal

enum PostalCodeRuleInclusionTypeEnum {
  INCLUDE
  EXCLUDE
}

input PriceRangeInput {
  gte: Float
  lte: Float
}

type Product implements Node & ObjectWithMetadata {
  id: ID!
  seoTitle: String
  seoDescription: String
  name: String!
  description: JSONString
  productType: ProductType!
  slug: String!
  category: Category
  updatedAt: DateTime
  chargeTaxes: Boolean!
  weight: Weight
  defaultVariant: ProductVariant
  rating: Float
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  descriptionJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `description` field instead."
    )
  url: String!
    @deprecated(reason: "This field will be removed after 2020-07-31.")
  thumbnail(size: Int): Image
  pricing(address: AddressInput): ProductPricingInfo
  isAvailable(address: AddressInput): Boolean
  taxType: TaxType
  attributes: [SelectedAttribute!]!
  channelListings: [ProductChannelListing!]
  imageById(id: ID): ProductImage
  variants: [ProductVariant]
  images: [ProductImage]
  collections: [Collection]
  translation(languageCode: LanguageCodeEnum!): ProductTranslation
  availableForPurchase: Date
  isAvailableForPurchase: Boolean
}

type ProductAttributeAssign {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productType: ProductType
  productErrors: [ProductError!]!
}

input ProductAttributeAssignInput {
  id: ID!
  type: ProductAttributeType!
}

enum ProductAttributeType {
  PRODUCT
  VARIANT
}

type ProductAttributeUnassign {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productType: ProductType
  productErrors: [ProductError!]!
}

type ProductBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  productErrors: [ProductError!]!
}

type ProductChannelListing implements Node {
  id: ID!
  publicationDate: Date
  isPublished: Boolean!
  channel: Channel!
  visibleInListings: Boolean!
  availableForPurchase: Date
  discountedPrice: Money
  purchaseCost: MoneyRange
  margin: Margin
  isAvailableForPurchase: Boolean
  pricing(address: AddressInput): ProductPricingInfo
}

input ProductChannelListingAddInput {
  channelId: ID!
  isPublished: Boolean
  publicationDate: Date
  visibleInListings: Boolean
  isAvailableForPurchase: Boolean
  availableForPurchaseDate: Date
}

type ProductChannelListingError {
  field: String
  message: String
  code: ProductErrorCode!
  attributes: [ID!]
  values: [ID!]
  channels: [ID!]
}

type ProductChannelListingUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  product: Product
  productChannelListingErrors: [ProductChannelListingError!]!
}

input ProductChannelListingUpdateInput {
  addChannels: [ProductChannelListingAddInput!]
  removeChannels: [ID!]
}

type ProductCountableConnection {
  pageInfo: PageInfo!
  edges: [ProductCountableEdge!]!
  totalCount: Int
}

type ProductCountableEdge {
  node: Product!
  cursor: String!
}

type ProductCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  product: Product
}

input ProductCreateInput {
  attributes: [AttributeValueInput]
  category: ID
  chargeTaxes: Boolean
  collections: [ID]
  description: JSONString
  name: String
  slug: String
  taxCode: String
  seo: SeoInput
  weight: WeightScalar
  rating: Float
  productType: ID!
}

type ProductDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  product: Product
}

type ProductError {
  field: String
  message: String
  code: ProductErrorCode!
  attributes: [ID!]
  values: [ID!]
}

enum ProductErrorCode {
  ALREADY_EXISTS
  ATTRIBUTE_ALREADY_ASSIGNED
  ATTRIBUTE_CANNOT_BE_ASSIGNED
  ATTRIBUTE_VARIANTS_DISABLED
  DUPLICATED_INPUT_ITEM
  GRAPHQL_ERROR
  INVALID
  PRODUCT_WITHOUT_CATEGORY
  NOT_PRODUCTS_IMAGE
  NOT_PRODUCTS_VARIANT
  NOT_FOUND
  REQUIRED
  UNIQUE
  VARIANT_NO_DIGITAL_CONTENT
  CANNOT_MANAGE_PRODUCT_WITHOUT_VARIANT
  PRODUCT_NOT_ASSIGNED_TO_CHANNEL
}

enum ProductFieldEnum {
  NAME
  DESCRIPTION
  PRODUCT_TYPE
  CATEGORY
  VISIBLE
  PRODUCT_WEIGHT
  COLLECTIONS
  CHARGE_TAXES
  PRODUCT_IMAGES
  VARIANT_SKU
  VARIANT_WEIGHT
  VARIANT_IMAGES
}

input ProductFilterInput {
  isPublished: Boolean
  collections: [ID]
  categories: [ID]
  hasCategory: Boolean
  attributes: [AttributeInput]
  stockAvailability: StockAvailability
  productType: ID
  stocks: ProductStockFilterInput
  search: String
  price: PriceRangeInput
  minimalPrice: PriceRangeInput
  productTypes: [ID]
  ids: [ID]
  channel: String
}

type ProductImage implements Node {
  id: ID!
  sortOrder: Int
  alt: String!
  url(size: Int): String!
}

type ProductImageBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  productErrors: [ProductError!]!
}

type ProductImageCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  product: Product
  image: ProductImage
  productErrors: [ProductError!]!
}

input ProductImageCreateInput {
  alt: String
  image: Upload!
  product: ID!
}

type ProductImageDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  product: Product
  image: ProductImage
  productErrors: [ProductError!]!
}

type ProductImageReorder {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  product: Product
  images: [ProductImage]
  productErrors: [ProductError!]!
}

type ProductImageUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  product: Product
  image: ProductImage
  productErrors: [ProductError!]!
}

input ProductImageUpdateInput {
  alt: String
}

input ProductInput {
  attributes: [AttributeValueInput]
  category: ID
  chargeTaxes: Boolean
  collections: [ID]
  description: JSONString
  name: String
  slug: String
  taxCode: String
  seo: SeoInput
  weight: WeightScalar
  rating: Float
}

input ProductOrder {
  direction: OrderDirection!
  channel: String
  attributeId: ID
  field: ProductOrderField
}

enum ProductOrderField {
  NAME
  RANK
  PRICE
  MINIMAL_PRICE
  DATE
  TYPE
  PUBLISHED
  PUBLICATION_DATE
  COLLECTION
  RATING
}

type ProductPricingInfo {
  onSale: Boolean
  discount: TaxedMoney
  discountLocalCurrency: TaxedMoney
  priceRange: TaxedMoneyRange
  priceRangeUndiscounted: TaxedMoneyRange
  priceRangeLocalCurrency: TaxedMoneyRange
}

type ProductReorderAttributeValues {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  product: Product
  productErrors: [ProductError!]!
}

input ProductStockFilterInput {
  warehouseIds: [ID!]
  quantity: IntRangeInput
}

type ProductTranslatableContent implements Node {
  id: ID!
  seoTitle: String
  seoDescription: String
  name: String!
  description: JSONString
  descriptionJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `description` field instead."
    )
  translation(languageCode: LanguageCodeEnum!): ProductTranslation
  product: Product
}

type ProductTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  product: Product
}

type ProductTranslation implements Node {
  id: ID!
  seoTitle: String
  seoDescription: String
  name: String!
  description: JSONString
  language: LanguageDisplay!
  descriptionJson: JSONString
    @deprecated(
      reason: "Will be removed in Saleor 4.0. Use the `description` field instead."
    )
}

type ProductType implements Node & ObjectWithMetadata {
  id: ID!
  name: String!
  slug: String!
  hasVariants: Boolean!
  isShippingRequired: Boolean!
  isDigital: Boolean!
  weight: Weight
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  products(
    channel: String
    before: String
    after: String
    first: Int
    last: Int
  ): ProductCountableConnection
    @deprecated(
      reason: "Use the top-level `products` query with the `productTypes` filter."
    )
  taxType: TaxType
  variantAttributes(variantSelection: VariantAttributeScope): [Attribute]
  productAttributes: [Attribute]
  availableAttributes(
    filter: AttributeFilterInput
    before: String
    after: String
    first: Int
    last: Int
  ): AttributeCountableConnection
}

type ProductTypeBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  productErrors: [ProductError!]!
}

enum ProductTypeConfigurable {
  CONFIGURABLE
  SIMPLE
}

type ProductTypeCountableConnection {
  pageInfo: PageInfo!
  edges: [ProductTypeCountableEdge!]!
  totalCount: Int
}

type ProductTypeCountableEdge {
  node: ProductType!
  cursor: String!
}

type ProductTypeCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  productType: ProductType
}

type ProductTypeDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  productType: ProductType
}

enum ProductTypeEnum {
  DIGITAL
  SHIPPABLE
}

input ProductTypeFilterInput {
  search: String
  configurable: ProductTypeConfigurable
  productType: ProductTypeEnum
  ids: [ID]
}

input ProductTypeInput {
  name: String
  slug: String
  hasVariants: Boolean
  productAttributes: [ID]
  variantAttributes: [ID]
  isShippingRequired: Boolean
  isDigital: Boolean
  weight: WeightScalar
  taxCode: String
}

type ProductTypeReorderAttributes {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productType: ProductType
  productErrors: [ProductError!]!
}

enum ProductTypeSortField {
  NAME
  DIGITAL
  SHIPPING_REQUIRED
}

input ProductTypeSortingInput {
  direction: OrderDirection!
  field: ProductTypeSortField!
}

type ProductTypeUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  productType: ProductType
}

type ProductUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  product: Product
}

type ProductVariant implements Node & ObjectWithMetadata {
  id: ID!
  name: String!
  sku: String!
  product: Product!
  trackInventory: Boolean!
  weight: Weight
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  channelListings: [ProductVariantChannelListing!]
  pricing(address: AddressInput): VariantPricingInfo
  attributes(variantSelection: VariantAttributeScope): [SelectedAttribute!]!
  costPrice: Money
  margin: Int
  quantityOrdered: Int
  revenue(period: ReportingPeriod): TaxedMoney
  images: [ProductImage]
  translation(languageCode: LanguageCodeEnum!): ProductVariantTranslation
  digitalContent: DigitalContent
  stocks(address: AddressInput, countryCode: CountryCode): [Stock]
  quantityAvailable(address: AddressInput, countryCode: CountryCode): Int!
}

type ProductVariantBulkCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  productVariants: [ProductVariant!]!
  bulkProductErrors: [BulkProductError!]!
}

input ProductVariantBulkCreateInput {
  attributes: [BulkAttributeValueInput]!
  sku: String!
  trackInventory: Boolean
  weight: WeightScalar
  stocks: [StockInput!]
  channelListings: [ProductVariantChannelListingAddInput!]
}

type ProductVariantBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  productErrors: [ProductError!]!
}

type ProductVariantChannelListing implements Node {
  id: ID!
  channel: Channel!
  price: Money
  costPrice: Money
  margin: Int
}

input ProductVariantChannelListingAddInput {
  channelId: ID!
  price: PositiveDecimal!
  costPrice: PositiveDecimal
}

type ProductVariantChannelListingUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  variant: ProductVariant
  productChannelListingErrors: [ProductChannelListingError!]!
}

type ProductVariantCountableConnection {
  pageInfo: PageInfo!
  edges: [ProductVariantCountableEdge!]!
  totalCount: Int
}

type ProductVariantCountableEdge {
  node: ProductVariant!
  cursor: String!
}

type ProductVariantCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  productVariant: ProductVariant
}

input ProductVariantCreateInput {
  attributes: [AttributeValueInput]!
  sku: String
  trackInventory: Boolean
  weight: WeightScalar
  product: ID!
  stocks: [StockInput!]
}

type ProductVariantDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  productVariant: ProductVariant
}

input ProductVariantFilterInput {
  search: String
  sku: [String]
}

input ProductVariantInput {
  attributes: [AttributeValueInput]
  sku: String
  trackInventory: Boolean
  weight: WeightScalar
}

type ProductVariantReorder {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  product: Product
  productErrors: [ProductError!]!
}

type ProductVariantReorderAttributeValues {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productVariant: ProductVariant
  productErrors: [ProductError!]!
}

type ProductVariantSetDefault {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  product: Product
  productErrors: [ProductError!]!
}

type ProductVariantStocksCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productVariant: ProductVariant
  bulkStockErrors: [BulkStockError!]!
}

type ProductVariantStocksDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productVariant: ProductVariant
  stockErrors: [StockError!]!
}

type ProductVariantStocksUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productVariant: ProductVariant
  bulkStockErrors: [BulkStockError!]!
}

type ProductVariantTranslatableContent implements Node {
  id: ID!
  name: String!
  translation(languageCode: LanguageCodeEnum!): ProductVariantTranslation
  productVariant: ProductVariant
}

type ProductVariantTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  productVariant: ProductVariant
}

type ProductVariantTranslation implements Node {
  id: ID!
  name: String!
  language: LanguageDisplay!
}

type ProductVariantUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productErrors: [ProductError!]!
  productVariant: ProductVariant
}

input PublishableChannelListingInput {
  channelId: ID!
  isPublished: Boolean
  publicationDate: Date
}

type Query {
  webhook(id: ID!): Webhook
  webhookEvents: [WebhookEvent]
  webhookSamplePayload(eventType: WebhookSampleEventTypeEnum!): JSONString
  warehouse(id: ID!): Warehouse
  warehouses(
    filter: WarehouseFilterInput
    sortBy: WarehouseSortingInput
    before: String
    after: String
    first: Int
    last: Int
  ): WarehouseCountableConnection
  translations(
    kind: TranslatableKinds!
    before: String
    after: String
    first: Int
    last: Int
  ): TranslatableItemConnection
  translation(id: ID!, kind: TranslatableKinds!): TranslatableItem
  stock(id: ID!): Stock
  stocks(
    filter: StockFilterInput
    before: String
    after: String
    first: Int
    last: Int
  ): StockCountableConnection
  shop: Shop!
  orderSettings: OrderSettings
  shippingZone(id: ID!, channel: String): ShippingZone
  shippingZones(
    channel: String
    before: String
    after: String
    first: Int
    last: Int
  ): ShippingZoneCountableConnection
  digitalContent(id: ID!): DigitalContent
  digitalContents(
    before: String
    after: String
    first: Int
    last: Int
  ): DigitalContentCountableConnection
  categories(
    filter: CategoryFilterInput
    sortBy: CategorySortingInput
    level: Int
    before: String
    after: String
    first: Int
    last: Int
  ): CategoryCountableConnection
  category(id: ID, slug: String): Category
  collection(id: ID, slug: String, channel: String): Collection
  collections(
    filter: CollectionFilterInput
    sortBy: CollectionSortingInput
    channel: String
    before: String
    after: String
    first: Int
    last: Int
  ): CollectionCountableConnection
  product(id: ID, slug: String, channel: String): Product
  products(
    filter: ProductFilterInput
    sortBy: ProductOrder
    stockAvailability: StockAvailability
    channel: String
    before: String
    after: String
    first: Int
    last: Int
  ): ProductCountableConnection
  productType(id: ID!): ProductType
  productTypes(
    filter: ProductTypeFilterInput
    sortBy: ProductTypeSortingInput
    before: String
    after: String
    first: Int
    last: Int
  ): ProductTypeCountableConnection
  productVariant(id: ID, sku: String, channel: String): ProductVariant
  productVariants(
    ids: [ID]
    channel: String
    filter: ProductVariantFilterInput
    before: String
    after: String
    first: Int
    last: Int
  ): ProductVariantCountableConnection
  reportProductSales(
    period: ReportingPeriod!
    channel: String!
    before: String
    after: String
    first: Int
    last: Int
  ): ProductVariantCountableConnection
  payment(id: ID!): Payment
  payments(
    before: String
    after: String
    first: Int
    last: Int
  ): PaymentCountableConnection
  page(id: ID, slug: String): Page
  pages(
    sortBy: PageSortingInput
    filter: PageFilterInput
    before: String
    after: String
    first: Int
    last: Int
  ): PageCountableConnection
  pageType(id: ID!): PageType
  pageTypes(
    sortBy: PageTypeSortingInput
    filter: PageTypeFilterInput
    before: String
    after: String
    first: Int
    last: Int
  ): PageTypeCountableConnection
  homepageEvents(
    before: String
    after: String
    first: Int
    last: Int
  ): OrderEventCountableConnection
  order(id: ID!): Order
  orders(
    sortBy: OrderSortingInput
    filter: OrderFilterInput
    created: ReportingPeriod
    status: OrderStatusFilter
    channel: String
    before: String
    after: String
    first: Int
    last: Int
  ): OrderCountableConnection
  draftOrders(
    sortBy: OrderSortingInput
    filter: OrderDraftFilterInput
    created: ReportingPeriod
    before: String
    after: String
    first: Int
    last: Int
  ): OrderCountableConnection
  ordersTotal(period: ReportingPeriod, channel: String): TaxedMoney
  orderByToken(token: UUID!): Order
  menu(channel: String, id: ID, name: String, slug: String): Menu
  menus(
    channel: String
    sortBy: MenuSortingInput
    filter: MenuFilterInput
    before: String
    after: String
    first: Int
    last: Int
  ): MenuCountableConnection
  menuItem(id: ID!, channel: String): MenuItem
  menuItems(
    channel: String
    sortBy: MenuItemSortingInput
    filter: MenuItemFilterInput
    before: String
    after: String
    first: Int
    last: Int
  ): MenuItemCountableConnection
  giftCard(id: ID!): GiftCard
  giftCards(
    before: String
    after: String
    first: Int
    last: Int
  ): GiftCardCountableConnection
  plugin(id: ID!): Plugin
  plugins(
    filter: PluginFilterInput
    sortBy: PluginSortingInput
    before: String
    after: String
    first: Int
    last: Int
  ): PluginCountableConnection
  sale(id: ID!, channel: String): Sale
  sales(
    filter: SaleFilterInput
    sortBy: SaleSortingInput
    query: String
    channel: String
    before: String
    after: String
    first: Int
    last: Int
  ): SaleCountableConnection
  voucher(id: ID!, channel: String): Voucher
  vouchers(
    filter: VoucherFilterInput
    sortBy: VoucherSortingInput
    query: String
    channel: String
    before: String
    after: String
    first: Int
    last: Int
  ): VoucherCountableConnection
  exportFile(id: ID!): ExportFile
  exportFiles(
    filter: ExportFileFilterInput
    sortBy: ExportFileSortingInput
    before: String
    after: String
    first: Int
    last: Int
  ): ExportFileCountableConnection
  taxTypes: [TaxType]
  checkout(token: UUID): Checkout
  checkouts(
    channel: String
    before: String
    after: String
    first: Int
    last: Int
  ): CheckoutCountableConnection
  checkoutLine(id: ID): CheckoutLine
  checkoutLines(
    before: String
    after: String
    first: Int
    last: Int
  ): CheckoutLineCountableConnection
  channel(id: ID): Channel
  channels: [Channel!]
  attributes(
    filter: AttributeFilterInput
    sortBy: AttributeSortingInput
    before: String
    after: String
    first: Int
    last: Int
  ): AttributeCountableConnection
  attribute(id: ID, slug: String): Attribute
  appsInstallations: [AppInstallation!]!
  apps(
    filter: AppFilterInput
    sortBy: AppSortingInput
    before: String
    after: String
    first: Int
    last: Int
  ): AppCountableConnection
  app(id: ID!): App
  addressValidationRules(
    countryCode: CountryCode!
    countryArea: String
    city: String
    cityArea: String
  ): AddressValidationData
  address(id: ID!): Address
  customers(
    filter: CustomerFilterInput
    sortBy: UserSortingInput
    before: String
    after: String
    first: Int
    last: Int
  ): UserCountableConnection
  permissionGroups(
    filter: PermissionGroupFilterInput
    sortBy: PermissionGroupSortingInput
    before: String
    after: String
    first: Int
    last: Int
  ): GroupCountableConnection
  permissionGroup(id: ID!): Group
  me: User
  staffUsers(
    filter: StaffUserInput
    sortBy: UserSortingInput
    before: String
    after: String
    first: Int
    last: Int
  ): UserCountableConnection
  user(id: ID, email: String): User
  _entities(representations: [_Any]): [_Entity]
  _service: _Service
}

type ReducedRate {
  rate: Float!
  rateType: TaxRateType!
}

type RefreshToken {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  token: String
  user: User
  accountErrors: [AccountError!]!
}

input ReorderInput {
  id: ID!
  sortOrder: Int
}

enum ReportingPeriod {
  TODAY
  THIS_MONTH
}

type RequestEmailChange {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
}

type RequestPasswordReset {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  accountErrors: [AccountError!]!
}

type Sale implements Node {
  id: ID!
  name: String!
  type: SaleType!
  startDate: DateTime!
  endDate: DateTime
  categories(
    before: String
    after: String
    first: Int
    last: Int
  ): CategoryCountableConnection
  collections(
    before: String
    after: String
    first: Int
    last: Int
  ): CollectionCountableConnection
  products(
    before: String
    after: String
    first: Int
    last: Int
  ): ProductCountableConnection
  translation(languageCode: LanguageCodeEnum!): SaleTranslation
  channelListings: [SaleChannelListing!]
  discountValue: Float
  currency: String
}

type SaleAddCatalogues {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  sale: Sale
  discountErrors: [DiscountError!]!
}

type SaleBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  discountErrors: [DiscountError!]!
}

type SaleChannelListing implements Node {
  id: ID!
  channel: Channel!
  discountValue: Float!
  currency: String!
}

input SaleChannelListingAddInput {
  channelId: ID!
  discountValue: PositiveDecimal!
}

input SaleChannelListingInput {
  addChannels: [SaleChannelListingAddInput!]
  removeChannels: [ID!]
}

type SaleChannelListingUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  sale: Sale
  discountErrors: [DiscountError!]!
}

type SaleCountableConnection {
  pageInfo: PageInfo!
  edges: [SaleCountableEdge!]!
  totalCount: Int
}

type SaleCountableEdge {
  node: Sale!
  cursor: String!
}

type SaleCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  discountErrors: [DiscountError!]!
  sale: Sale
}

type SaleDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  discountErrors: [DiscountError!]!
  sale: Sale
}

input SaleFilterInput {
  status: [DiscountStatusEnum]
  saleType: DiscountValueTypeEnum
  started: DateTimeRangeInput
  search: String
}

input SaleInput {
  name: String
  type: DiscountValueTypeEnum
  value: PositiveDecimal
  products: [ID]
  categories: [ID]
  collections: [ID]
  startDate: DateTime
  endDate: DateTime
}

type SaleRemoveCatalogues {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  sale: Sale
  discountErrors: [DiscountError!]!
}

enum SaleSortField {
  NAME
  START_DATE
  END_DATE
  VALUE
  TYPE
}

input SaleSortingInput {
  direction: OrderDirection!
  channel: String
  field: SaleSortField!
}

type SaleTranslatableContent implements Node {
  id: ID!
  name: String!
  translation(languageCode: LanguageCodeEnum!): SaleTranslation
  sale: Sale
}

type SaleTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  sale: Sale
}

type SaleTranslation implements Node {
  id: ID!
  name: String
  language: LanguageDisplay!
}

enum SaleType {
  FIXED
  PERCENTAGE
}

type SaleUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  discountErrors: [DiscountError!]!
  sale: Sale
}

type SelectedAttribute {
  attribute: Attribute!
  values: [AttributeValue]!
}

input SeoInput {
  title: String
  description: String
}

type SetPassword {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  token: String
  refreshToken: String
  csrfToken: String
  user: User
  accountErrors: [AccountError!]!
}

type ShippingError {
  field: String
  message: String
  code: ShippingErrorCode!
  warehouses: [ID!]
  channels: [ID!]
}

enum ShippingErrorCode {
  ALREADY_EXISTS
  GRAPHQL_ERROR
  INVALID
  MAX_LESS_THAN_MIN
  NOT_FOUND
  REQUIRED
  UNIQUE
  DUPLICATED_INPUT_ITEM
}

type ShippingMethod implements Node & ObjectWithMetadata {
  id: ID!
  name: String!
  minimumOrderWeight: Weight
  maximumOrderWeight: Weight
  maximumDeliveryDays: Int
  minimumDeliveryDays: Int
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  type: ShippingMethodTypeEnum
  translation(languageCode: LanguageCodeEnum!): ShippingMethodTranslation
  channelListings: [ShippingMethodChannelListing!]
  price: Money
  maximumOrderPrice: Money
  minimumOrderPrice: Money
  postalCodeRules: [ShippingMethodPostalCodeRule]
  excludedProducts(
    before: String
    after: String
    first: Int
    last: Int
  ): ProductCountableConnection
}

type ShippingMethodChannelListing implements Node {
  id: ID!
  channel: Channel!
  minimumOrderPrice: Money
  maximumOrderPrice: Money
  price: Money
}

input ShippingMethodChannelListingAddInput {
  channelId: ID!
  price: PositiveDecimal
  minimumOrderPrice: PositiveDecimal
  maximumOrderPrice: PositiveDecimal
}

input ShippingMethodChannelListingInput {
  addChannels: [ShippingMethodChannelListingAddInput!]
  removeChannels: [ID!]
}

type ShippingMethodChannelListingUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shippingMethod: ShippingMethod
  shippingErrors: [ShippingError!]!
}

type ShippingMethodPostalCodeRule implements Node {
  start: String
  end: String
  inclusionType: PostalCodeRuleInclusionTypeEnum
  id: ID!
}

type ShippingMethodTranslatableContent implements Node {
  id: ID!
  name: String!
  translation(languageCode: LanguageCodeEnum!): ShippingMethodTranslation
  shippingMethod: ShippingMethod
}

type ShippingMethodTranslation implements Node {
  id: ID!
  name: String
  language: LanguageDisplay!
}

enum ShippingMethodTypeEnum {
  PRICE
  WEIGHT
}

input ShippingPostalCodeRulesCreateInputRange {
  start: String!
  end: String
}

type ShippingPriceBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  shippingErrors: [ShippingError!]!
}

type ShippingPriceCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shippingZone: ShippingZone
  shippingMethod: ShippingMethod
  shippingErrors: [ShippingError!]!
}

type ShippingPriceDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shippingMethod: ShippingMethod
  shippingZone: ShippingZone
  shippingErrors: [ShippingError!]!
}

type ShippingPriceExcludeProducts {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shippingMethod: ShippingMethod
  shippingErrors: [ShippingError!]!
}

input ShippingPriceExcludeProductsInput {
  products: [ID]!
}

input ShippingPriceInput {
  name: String
  minimumOrderWeight: WeightScalar
  maximumOrderWeight: WeightScalar
  maximumDeliveryDays: Int
  minimumDeliveryDays: Int
  type: ShippingMethodTypeEnum
  shippingZone: ID
  addPostalCodeRules: [ShippingPostalCodeRulesCreateInputRange!]
  deletePostalCodeRules: [ID!]
  inclusionType: PostalCodeRuleInclusionTypeEnum
}

type ShippingPriceRemoveProductFromExclude {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shippingMethod: ShippingMethod
  shippingErrors: [ShippingError!]!
}

type ShippingPriceTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  shippingMethod: ShippingMethod
}

type ShippingPriceUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shippingZone: ShippingZone
  shippingMethod: ShippingMethod
  shippingErrors: [ShippingError!]!
}

type ShippingZone implements Node & ObjectWithMetadata {
  id: ID!
  name: String!
  default: Boolean!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  priceRange: MoneyRange
  countries: [CountryDisplay]
  shippingMethods: [ShippingMethod]
  warehouses: [Warehouse]
  description: String
}

type ShippingZoneBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  shippingErrors: [ShippingError!]!
}

type ShippingZoneCountableConnection {
  pageInfo: PageInfo!
  edges: [ShippingZoneCountableEdge!]!
  totalCount: Int
}

type ShippingZoneCountableEdge {
  node: ShippingZone!
  cursor: String!
}

type ShippingZoneCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shippingErrors: [ShippingError!]!
  shippingZone: ShippingZone
}

input ShippingZoneCreateInput {
  name: String
  description: String
  countries: [String]
  default: Boolean
  addWarehouses: [ID]
}

type ShippingZoneDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shippingErrors: [ShippingError!]!
  shippingZone: ShippingZone
}

type ShippingZoneUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shippingErrors: [ShippingError!]!
  shippingZone: ShippingZone
}

input ShippingZoneUpdateInput {
  name: String
  description: String
  countries: [String]
  default: Boolean
  addWarehouses: [ID]
  removeWarehouses: [ID]
}

type Shop {
  availablePaymentGateways(currency: String): [PaymentGateway!]!
  availableExternalAuthentications: [ExternalAuthentication!]!
  availableShippingMethods(
    channel: String!
    address: AddressInput
  ): [ShippingMethod]
  countries(languageCode: LanguageCodeEnum): [CountryDisplay!]!
  defaultCountry: CountryDisplay
  defaultMailSenderName: String
  defaultMailSenderAddress: String
  description: String
  domain: Domain!
  languages: [LanguageDisplay]!
  name: String!
  navigation: Navigation
    @deprecated(
      reason: "Fetch menus using the `menu` query with `slug` parameter."
    )
  permissions: [Permission]!
  phonePrefixes: [String]!
  headerText: String
  includeTaxesInPrices: Boolean!
  displayGrossPrices: Boolean!
  chargeTaxesOnShipping: Boolean!
  trackInventoryByDefault: Boolean
  defaultWeightUnit: WeightUnitsEnum
  translation(languageCode: LanguageCodeEnum!): ShopTranslation
  automaticFulfillmentDigitalProducts: Boolean
  defaultDigitalMaxDownloads: Int
  defaultDigitalUrlValidDays: Int
  companyAddress: Address
  customerSetPasswordUrl: String
  staffNotificationRecipients: [StaffNotificationRecipient]
}

type ShopAddressUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shop: Shop
  shopErrors: [ShopError!]!
}

type ShopDomainUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shop: Shop
  shopErrors: [ShopError!]!
}

type ShopError {
  field: String
  message: String
  code: ShopErrorCode!
}

enum ShopErrorCode {
  ALREADY_EXISTS
  CANNOT_FETCH_TAX_RATES
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
}

type ShopFetchTaxRates {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shop: Shop
  shopErrors: [ShopError!]!
}

input ShopSettingsInput {
  headerText: String
  description: String
  includeTaxesInPrices: Boolean
  displayGrossPrices: Boolean
  chargeTaxesOnShipping: Boolean
  trackInventoryByDefault: Boolean
  defaultWeightUnit: WeightUnitsEnum
  automaticFulfillmentDigitalProducts: Boolean
  defaultDigitalMaxDownloads: Int
  defaultDigitalUrlValidDays: Int
  defaultMailSenderName: String
  defaultMailSenderAddress: String
  customerSetPasswordUrl: String
}

type ShopSettingsTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shop: Shop
  translationErrors: [TranslationError!]!
}

input ShopSettingsTranslationInput {
  headerText: String
  description: String
}

type ShopSettingsUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shop: Shop
  shopErrors: [ShopError!]!
}

type ShopTranslation implements Node {
  id: ID!
  headerText: String!
  description: String!
  language: LanguageDisplay!
}

input SiteDomainInput {
  domain: String
  name: String
}

type StaffBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  staffErrors: [StaffError!]!
}

type StaffCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  staffErrors: [StaffError!]!
  user: User
}

input StaffCreateInput {
  firstName: String
  lastName: String
  email: String
  isActive: Boolean
  note: String
  addGroups: [ID!]
  redirectUrl: String
}

type StaffDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  staffErrors: [StaffError!]!
  user: User
}

type StaffError {
  field: String
  message: String
  code: AccountErrorCode!
  permissions: [PermissionEnum!]
  groups: [ID!]
  users: [ID!]
}

enum StaffMemberStatus {
  ACTIVE
  DEACTIVATED
}

type StaffNotificationRecipient implements Node {
  user: User
  active: Boolean
  id: ID!
  email: String
}

type StaffNotificationRecipientCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shopErrors: [ShopError!]!
  staffNotificationRecipient: StaffNotificationRecipient
}

type StaffNotificationRecipientDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shopErrors: [ShopError!]!
  staffNotificationRecipient: StaffNotificationRecipient
}

input StaffNotificationRecipientInput {
  user: ID
  email: String
  active: Boolean
}

type StaffNotificationRecipientUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  shopErrors: [ShopError!]!
  staffNotificationRecipient: StaffNotificationRecipient
}

type StaffUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  staffErrors: [StaffError!]!
  user: User
}

input StaffUpdateInput {
  firstName: String
  lastName: String
  email: String
  isActive: Boolean
  note: String
  addGroups: [ID!]
  removeGroups: [ID!]
}

input StaffUserInput {
  status: StaffMemberStatus
  search: String
}

type Stock implements Node {
  warehouse: Warehouse!
  productVariant: ProductVariant!
  quantity: Int!
  id: ID!
  quantityAllocated: Int!
}

enum StockAvailability {
  IN_STOCK
  OUT_OF_STOCK
}

type StockCountableConnection {
  pageInfo: PageInfo!
  edges: [StockCountableEdge!]!
  totalCount: Int
}

type StockCountableEdge {
  node: Stock!
  cursor: String!
}

type StockError {
  field: String
  message: String
  code: StockErrorCode!
}

enum StockErrorCode {
  ALREADY_EXISTS
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
}

input StockFilterInput {
  quantity: Float
  search: String
}

input StockInput {
  warehouse: ID!
  quantity: Int
}

enum TaxRateType {
  ACCOMMODATION
  ADMISSION_TO_CULTURAL_EVENTS
  ADMISSION_TO_ENTERTAINMENT_EVENTS
  ADMISSION_TO_SPORTING_EVENTS
  ADVERTISING
  AGRICULTURAL_SUPPLIES
  BABY_FOODSTUFFS
  BIKES
  BOOKS
  CHILDRENS_CLOTHING
  DOMESTIC_FUEL
  DOMESTIC_SERVICES
  E_BOOKS
  FOODSTUFFS
  HOTELS
  MEDICAL
  NEWSPAPERS
  PASSENGER_TRANSPORT
  PHARMACEUTICALS
  PROPERTY_RENOVATIONS
  RESTAURANTS
  SOCIAL_HOUSING
  STANDARD
  WATER
  WINE
}

type TaxType {
  description: String
  taxCode: String
}

type TaxedMoney {
  currency: String!
  gross: Money!
  net: Money!
  tax: Money!
}

type TaxedMoneyRange {
  start: TaxedMoney
  stop: TaxedMoney
}

type Transaction implements Node {
  id: ID!
  created: DateTime!
  payment: Payment!
  token: String!
  kind: TransactionKind!
  isSuccess: Boolean!
  error: TransactionError
  amount: Money
}

enum TransactionError {
  TRANSACTIONERROR_INCORRECT_NUMBER
  TRANSACTIONERROR_INVALID_NUMBER
  TRANSACTIONERROR_INCORRECT_CVV
  TRANSACTIONERROR_INVALID_CVV
  TRANSACTIONERROR_INCORRECT_ZIP
  TRANSACTIONERROR_INCORRECT_ADDRESS
  TRANSACTIONERROR_INVALID_EXPIRY_DATE
  TRANSACTIONERROR_EXPIRED
  TRANSACTIONERROR_PROCESSING_ERROR
  TRANSACTIONERROR_DECLINED
}

enum TransactionKind {
  EXTERNAL
  AUTH
  PENDING
  ACTION_TO_CONFIRM
  REFUND
  REFUND_ONGOING
  CAPTURE
  VOID
  CONFIRM
  CANCEL
}

union TranslatableItem =
    ProductTranslatableContent
  | CollectionTranslatableContent
  | CategoryTranslatableContent
  | AttributeTranslatableContent
  | AttributeValueTranslatableContent
  | ProductVariantTranslatableContent
  | PageTranslatableContent
  | ShippingMethodTranslatableContent
  | SaleTranslatableContent
  | VoucherTranslatableContent
  | MenuItemTranslatableContent

type TranslatableItemConnection {
  pageInfo: PageInfo!
  edges: [TranslatableItemEdge!]!
  totalCount: Int
}

type TranslatableItemEdge {
  node: TranslatableItem!
  cursor: String!
}

enum TranslatableKinds {
  ATTRIBUTE
  ATTRIBUTE_VALUE
  CATEGORY
  COLLECTION
  MENU_ITEM
  PAGE
  PRODUCT
  SALE
  SHIPPING_METHOD
  VARIANT
  VOUCHER
}

type TranslationError {
  field: String
  message: String
  code: TranslationErrorCode!
}

enum TranslationErrorCode {
  GRAPHQL_ERROR
  NOT_FOUND
  REQUIRED
}

input TranslationInput {
  seoTitle: String
  seoDescription: String
  name: String
  description: JSONString
}

scalar UUID

input UpdateInvoiceInput {
  number: String
  url: String
}

type UpdateMetadata {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  metadataErrors: [MetadataError!]!
  item: ObjectWithMetadata
}

type UpdatePrivateMetadata {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  metadataErrors: [MetadataError!]!
  item: ObjectWithMetadata
}

scalar Upload

type UploadError {
  field: String
  message: String
  code: UploadErrorCode!
}

enum UploadErrorCode {
  GRAPHQL_ERROR
}

type User implements Node & ObjectWithMetadata {
  id: ID!
  lastLogin: DateTime
  email: String!
  firstName: String!
  lastName: String!
  isStaff: Boolean!
  isActive: Boolean!
  note: String
  dateJoined: DateTime!
  defaultShippingAddress: Address
  defaultBillingAddress: Address
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
  addresses: [Address]
  checkout: Checkout
    @deprecated(
      reason: "Use the `checkout_tokens` field to fetch the user checkouts."
    )
  checkoutTokens(channel: String): [UUID!]
  giftCards(
    before: String
    after: String
    first: Int
    last: Int
  ): GiftCardCountableConnection
  orders(
    before: String
    after: String
    first: Int
    last: Int
  ): OrderCountableConnection
  permissions: [Permission]
    @deprecated(
      reason: "Will be removed in Saleor 2.11.Use the `userPermissions` instead."
    )
  userPermissions: [UserPermission]
  permissionGroups: [Group]
  editableGroups: [Group]
  avatar(size: Int): Image
  events: [CustomerEvent]
  storedPaymentSources: [PaymentSource]
}

type UserAvatarDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
}

type UserAvatarUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  accountErrors: [AccountError!]!
}

type UserBulkSetActive {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  accountErrors: [AccountError!]!
}

type UserCountableConnection {
  pageInfo: PageInfo!
  edges: [UserCountableEdge!]!
  totalCount: Int
}

type UserCountableEdge {
  node: User!
  cursor: String!
}

input UserCreateInput {
  defaultBillingAddress: AddressInput
  defaultShippingAddress: AddressInput
  firstName: String
  lastName: String
  email: String
  isActive: Boolean
  note: String
  redirectUrl: String
}

type UserPermission {
  code: PermissionEnum!
  name: String!
  sourcePermissionGroups(userId: ID!): [Group!]
}

enum UserSortField {
  FIRST_NAME
  LAST_NAME
  EMAIL
  ORDER_COUNT
}

input UserSortingInput {
  direction: OrderDirection!
  field: UserSortField!
}

type VAT {
  countryCode: String!
  standardRate: Float
  reducedRates: [ReducedRate]!
}

enum VariantAttributeScope {
  ALL
  VARIANT_SELECTION
  NOT_VARIANT_SELECTION
}

type VariantImageAssign {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productVariant: ProductVariant
  image: ProductImage
  productErrors: [ProductError!]!
}

type VariantImageUnassign {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  productVariant: ProductVariant
  image: ProductImage
  productErrors: [ProductError!]!
}

type VariantPricingInfo {
  onSale: Boolean
  discount: TaxedMoney
  discountLocalCurrency: TaxedMoney
  price: TaxedMoney
  priceUndiscounted: TaxedMoney
  priceLocalCurrency: TaxedMoney
}

type VerifyToken {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  user: User
  isValid: Boolean!
  payload: GenericScalar
  accountErrors: [AccountError!]!
}

type Voucher implements Node {
  id: ID!
  name: String
  type: VoucherTypeEnum!
  code: String!
  usageLimit: Int
  used: Int!
  startDate: DateTime!
  endDate: DateTime
  applyOncePerOrder: Boolean!
  applyOncePerCustomer: Boolean!
  discountValueType: DiscountValueTypeEnum!
  minCheckoutItemsQuantity: Int
  categories(
    before: String
    after: String
    first: Int
    last: Int
  ): CategoryCountableConnection
  collections(
    before: String
    after: String
    first: Int
    last: Int
  ): CollectionCountableConnection
  products(
    before: String
    after: String
    first: Int
    last: Int
  ): ProductCountableConnection
  countries: [CountryDisplay]
  translation(languageCode: LanguageCodeEnum!): VoucherTranslation
  discountValue: Float
  currency: String
  minSpent: Money
  channelListings: [VoucherChannelListing!]
}

type VoucherAddCatalogues {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  voucher: Voucher
  discountErrors: [DiscountError!]!
}

type VoucherBulkDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  count: Int!
  discountErrors: [DiscountError!]!
}

type VoucherChannelListing implements Node {
  id: ID!
  channel: Channel!
  discountValue: Float!
  currency: String!
  minSpent: Money
}

input VoucherChannelListingAddInput {
  channelId: ID!
  discountValue: PositiveDecimal
  minAmountSpent: PositiveDecimal
}

input VoucherChannelListingInput {
  addChannels: [VoucherChannelListingAddInput!]
  removeChannels: [ID!]
}

type VoucherChannelListingUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  voucher: Voucher
  discountErrors: [DiscountError!]!
}

type VoucherCountableConnection {
  pageInfo: PageInfo!
  edges: [VoucherCountableEdge!]!
  totalCount: Int
}

type VoucherCountableEdge {
  node: Voucher!
  cursor: String!
}

type VoucherCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  discountErrors: [DiscountError!]!
  voucher: Voucher
}

type VoucherDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  discountErrors: [DiscountError!]!
  voucher: Voucher
}

enum VoucherDiscountType {
  FIXED
  PERCENTAGE
  SHIPPING
}

input VoucherFilterInput {
  status: [DiscountStatusEnum]
  timesUsed: IntRangeInput
  discountType: [VoucherDiscountType]
  started: DateTimeRangeInput
  search: String
}

input VoucherInput {
  type: VoucherTypeEnum
  name: String
  code: String
  startDate: DateTime
  endDate: DateTime
  discountValueType: DiscountValueTypeEnum
  products: [ID]
  collections: [ID]
  categories: [ID]
  minCheckoutItemsQuantity: Int
  countries: [String]
  applyOncePerOrder: Boolean
  applyOncePerCustomer: Boolean
  usageLimit: Int
}

type VoucherRemoveCatalogues {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  voucher: Voucher
  discountErrors: [DiscountError!]!
}

enum VoucherSortField {
  CODE
  START_DATE
  END_DATE
  VALUE
  TYPE
  USAGE_LIMIT
  MINIMUM_SPENT_AMOUNT
}

input VoucherSortingInput {
  direction: OrderDirection!
  channel: String
  field: VoucherSortField!
}

type VoucherTranslatableContent implements Node {
  id: ID!
  name: String
  translation(languageCode: LanguageCodeEnum!): VoucherTranslation
  voucher: Voucher
}

type VoucherTranslate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  translationErrors: [TranslationError!]!
  voucher: Voucher
}

type VoucherTranslation implements Node {
  id: ID!
  name: String
  language: LanguageDisplay!
}

enum VoucherTypeEnum {
  SHIPPING
  ENTIRE_ORDER
  SPECIFIC_PRODUCT
}

type VoucherUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  discountErrors: [DiscountError!]!
  voucher: Voucher
}

type Warehouse implements Node & ObjectWithMetadata {
  id: ID!
  name: String!
  slug: String!
  companyName: String!
  shippingZones(
    before: String
    after: String
    first: Int
    last: Int
  ): ShippingZoneCountableConnection!
  address: Address!
  email: String!
  privateMetadata: [MetadataItem]!
  metadata: [MetadataItem]!
}

input WarehouseAddressInput {
  streetAddress1: String!
  streetAddress2: String
  city: String!
  cityArea: String
  postalCode: String
  country: CountryCode!
  countryArea: String
  phone: String
}

type WarehouseCountableConnection {
  pageInfo: PageInfo!
  edges: [WarehouseCountableEdge!]!
  totalCount: Int
}

type WarehouseCountableEdge {
  node: Warehouse!
  cursor: String!
}

type WarehouseCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  warehouseErrors: [WarehouseError!]!
  warehouse: Warehouse
}

input WarehouseCreateInput {
  slug: String
  companyName: String
  email: String
  name: String!
  address: WarehouseAddressInput!
  shippingZones: [ID]
}

type WarehouseDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  warehouseErrors: [WarehouseError!]!
  warehouse: Warehouse
}

type WarehouseError {
  field: String
  message: String
  code: WarehouseErrorCode!
}

enum WarehouseErrorCode {
  ALREADY_EXISTS
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
}

input WarehouseFilterInput {
  search: String
  ids: [ID]
}

type WarehouseShippingZoneAssign {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  warehouseErrors: [WarehouseError!]!
  warehouse: Warehouse
}

type WarehouseShippingZoneUnassign {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  warehouseErrors: [WarehouseError!]!
  warehouse: Warehouse
}

enum WarehouseSortField {
  NAME
}

input WarehouseSortingInput {
  direction: OrderDirection!
  field: WarehouseSortField!
}

type WarehouseUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  warehouseErrors: [WarehouseError!]!
  warehouse: Warehouse
}

input WarehouseUpdateInput {
  slug: String
  companyName: String
  email: String
  name: String
  address: WarehouseAddressInput
}

type Webhook implements Node {
  name: String!
  targetUrl: String!
  isActive: Boolean!
  secretKey: String
  id: ID!
  events: [WebhookEvent!]!
  app: App!
}

type WebhookCreate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  webhookErrors: [WebhookError!]!
  webhook: Webhook
}

input WebhookCreateInput {
  name: String
  targetUrl: String
  events: [WebhookEventTypeEnum]
  app: ID
  isActive: Boolean
  secretKey: String
}

type WebhookDelete {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  webhookErrors: [WebhookError!]!
  webhook: Webhook
}

type WebhookError {
  field: String
  message: String
  code: WebhookErrorCode!
}

enum WebhookErrorCode {
  GRAPHQL_ERROR
  INVALID
  NOT_FOUND
  REQUIRED
  UNIQUE
}

type WebhookEvent {
  eventType: WebhookEventTypeEnum!
  name: String!
}

enum WebhookEventTypeEnum {
  ANY_EVENTS
  ORDER_CREATED
  ORDER_CONFIRMED
  ORDER_FULLY_PAID
  ORDER_UPDATED
  ORDER_CANCELLED
  ORDER_FULFILLED
  INVOICE_REQUESTED
  INVOICE_DELETED
  INVOICE_SENT
  CUSTOMER_CREATED
  CUSTOMER_UPDATED
  PRODUCT_CREATED
  PRODUCT_UPDATED
  PRODUCT_DELETED
  CHECKOUT_CREATED
  CHECKOUT_UPDATED
  FULFILLMENT_CREATED
  PAGE_CREATED
  PAGE_UPDATED
  PAGE_DELETED
}

enum WebhookSampleEventTypeEnum {
  ORDER_CREATED
  ORDER_CONFIRMED
  ORDER_FULLY_PAID
  ORDER_UPDATED
  ORDER_CANCELLED
  ORDER_FULFILLED
  INVOICE_REQUESTED
  INVOICE_DELETED
  INVOICE_SENT
  CUSTOMER_CREATED
  CUSTOMER_UPDATED
  PRODUCT_CREATED
  PRODUCT_UPDATED
  PRODUCT_DELETED
  CHECKOUT_CREATED
  CHECKOUT_UPDATED
  FULFILLMENT_CREATED
  PAGE_CREATED
  PAGE_UPDATED
  PAGE_DELETED
}

type WebhookUpdate {
  errors: [Error!]!
    @deprecated(
      reason: "Use typed errors with error codes. This field will be removed after 2020-07-31."
    )
  webhookErrors: [WebhookError!]!
  webhook: Webhook
}

input WebhookUpdateInput {
  name: String
  targetUrl: String
  events: [WebhookEventTypeEnum]
  app: ID
  isActive: Boolean
  secretKey: String
}

type Weight {
  unit: WeightUnitsEnum!
  value: Float!
}

scalar WeightScalar

enum WeightUnitsEnum {
  KG
  LB
  OZ
  G
}

scalar _Any

union _Entity =
    Address
  | User
  | Group
  | App
  | ProductVariant
  | Product
  | ProductType
  | Collection
  | Category
  | ProductImage
  | PageType

type _Service {
  sdl: String
}