Storefront-API/prod.graphql

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

directive @join__field(graph: join__Graph!, requires: join__FieldSet, provides: join__FieldSet, type: String, external: Boolean, override: String, usedOverridden: Boolean) repeatable on FIELD_DEFINITION | INPUT_FIELD_DEFINITION

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

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

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

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

type Collection implements HasMetafields & Node & OnlineStorePublishable
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "OnlineStorePublishable")
  @join__type(graph: PRODUCT)
{
  description(truncateAt: Int): String!
  descriptionHtml: HTML!
  handle: String!
  id: ID!
  image: Image
  metafield(key: String!, namespace: String!): Metafield
  metafields(identifiers: [HasMetafieldsIdentifier!]!): [Metafield]!
  onlineStoreUrl: URL
  products(after: String, before: String, filters: [ProductFilter!], first: Int, last: Int, reverse: Boolean = false, sortKey: ProductCollectionSortKeys = COLLECTION_DEFAULT): ProductConnection!
  seo: SEO!
  title: String!
  updatedAt: DateTime!
}

type CollectionConnection
  @join__type(graph: PRODUCT)
{
  edges: [CollectionEdge!]!
  nodes: [Collection!]!
  pageInfo: PageInfo!
}

type CollectionEdge
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: Collection!
}

enum CollectionSortKeys
  @join__type(graph: PRODUCT)
{
  ID
  RELEVANCE
  TITLE
  UPDATED_AT
}

enum CollectionSortOrder
  @join__type(graph: PRODUCT)
{
  ALPHA_ASC
  ALPHA_DESC
  BEST_SELLING
  CREATED
  CREATED_DESC
  MANUAL
  PRICE_ASC
  PRICE_DESC
}

enum CountryCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
  @join__type(graph: SHOP)
{
  AF
  AX
  AL
  DZ
  AD
  AO
  AI
  AG
  AR
  AM
  AW
  AC
  AU
  AT
  AZ
  BS
  BH
  BD
  BB
  BY
  BE
  BZ
  BJ
  BM
  BT
  BO
  BA
  BW
  BV
  BR
  IO
  BN
  BG
  BF
  BI
  KH
  CA
  CV
  BQ
  KY
  CF
  TD
  CL
  CN
  CX
  CC
  CO
  KM
  CG
  CD
  CK
  CR
  HR
  CU
  CW
  CY
  CZ
  CI
  DK
  DJ
  DM
  DO
  EC
  EG
  SV
  GQ
  ER
  EE
  SZ
  ET
  FK
  FO
  FJ
  FI
  FR
  GF
  PF
  TF
  GA
  GM
  GE
  DE
  GH
  GI
  GR
  GL
  GD
  GP
  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
  KP
  XK
  KW
  KG
  LA
  LV
  LB
  LS
  LR
  LY
  LI
  LT
  LU
  MO
  MG
  MW
  MY
  MV
  ML
  MT
  MQ
  MR
  MU
  YT
  MX
  MD
  MC
  MN
  ME
  MS
  MA
  MZ
  MM
  NA
  NR
  NP
  NL
  AN
  NC
  NZ
  NI
  NE
  NG
  NU
  NF
  MK
  NO
  OM
  PK
  PS
  PA
  PG
  PY
  PE
  PH
  PN
  PL
  PT
  QA
  CM
  RE
  RO
  RU
  RW
  BL
  SH
  KN
  LC
  MF
  PM
  WS
  SM
  ST
  SA
  SN
  RS
  SC
  SL
  SG
  SX
  SK
  SI
  SB
  SO
  ZA
  GS
  KR
  SS
  ES
  LK
  VC
  SD
  SR
  SJ
  SE
  CH
  SY
  TW
  TJ
  TZ
  TH
  TL
  TG
  TK
  TO
  TT
  TA
  TN
  TR
  TM
  TC
  TV
  UG
  UA
  AE
  GB
  US
  UM
  UY
  UZ
  VU
  VE
  VN
  VG
  WF
  EH
  YE
  ZM
  ZW
  ZZ
}

enum CropRegion
  @join__type(graph: PRODUCT)
{
  CENTER
  TOP
  BOTTOM
  LEFT
  RIGHT
}

enum CurrencyCode
  @join__type(graph: PRODUCT)
{
  AED
  AFN
  ALL
  AMD
  ANG
  AOA
  ARS
  AUD
  AWG
  AZN
  BAM
  BBD
  BDT
  BGN
  BHD
  BIF
  BMD
  BND
  BOB
  BRL
  BSD
  BTN
  BWP
  BYN
  BZD
  CAD
  CDF
  CHF
  CLP
  CNY
  COP
  CRC
  CVE
  CZK
  DJF
  DKK
  DOP
  DZD
  EGP
  ERN
  ETB
  EUR
  FJD
  FKP
  GBP
  GEL
  GHS
  GIP
  GMD
  GNF
  GTQ
  GYD
  HKD
  HNL
  HRK
  HTG
  HUF
  IDR
  ILS
  INR
  IQD
  IRR
  ISK
  JEP
  JMD
  JOD
  JPY
  KES
  KGS
  KHR
  KID
  KMF
  KRW
  KWD
  KYD
  KZT
  LAK
  LBP
  LKR
  LRD
  LSL
  LTL
  LVL
  LYD
  MAD
  MDL
  MGA
  MKD
  MMK
  MNT
  MOP
  MRU
  MUR
  MVR
  MWK
  MXN
  MYR
  MZN
  NAD
  NGN
  NIO
  NOK
  NPR
  NZD
  OMR
  PAB
  PEN
  PGK
  PHP
  PKR
  PLN
  PYG
  QAR
  RON
  RSD
  RUB
  RWF
  SAR
  SBD
  SCR
  SDG
  SEK
  SGD
  SHP
  SLL
  SOS
  SRD
  SSP
  STN
  SYP
  SZL
  THB
  TJS
  TMT
  TND
  TOP
  TRY
  TTD
  TWD
  TZS
  UAH
  UGX
  USD
  UYU
  UZS
  VED
  VES
  VND
  VUV
  WST
  XAF
  XCD
  XOF
  XPF
  XXX
  YER
  ZAR
  ZMW
  BYR @deprecated
}

type Customer implements HasMetafields
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__type(graph: CUSTOMER)
{
  acceptsMarketing: Boolean!
  addresses(after: String, before: String, first: Int, last: Int, reverse: Boolean = false): MailingAddressConnection!
  createdAt: DateTime!
  defaultAddress: MailingAddress
  displayName: String!
  email: String
  firstName: String
  id: ID!
  lastName: String
  metafield(key: String!, namespace: String!): Metafield
  metafields(identifiers: [HasMetafieldsIdentifier!]!): [Metafield]!
  numberOfOrders: UnsignedInt64!
  phone: String
  tags: [String!]!
  updatedAt: DateTime!
}

type CustomerAccessToken
  @join__type(graph: CUSTOMER)
{
  accessToken: String!
  expiresAt: DateTime!
}

input CustomerAccessTokenCreateInput
  @join__type(graph: CUSTOMER)
{
  email: String!
  password: String!
}

type CustomerAccessTokenCreatePayload
  @join__type(graph: CUSTOMER)
{
  customerAccessToken: CustomerAccessToken
  customerUserErrors: [CustomerUserError!]!
}

type CustomerAccessTokenDeletePayload
  @join__type(graph: CUSTOMER)
{
  deletedAccessToken: String
  deletedCustomerAccessTokenId: String
  userErrors: [UserError!]!
}

type CustomerAccessTokenRenewPayload
  @join__type(graph: CUSTOMER)
{
  customerAccessToken: CustomerAccessToken
  userErrors: [UserError!]!
}

input CustomerCreateInput
  @join__type(graph: CUSTOMER)
{
  firstName: String
  lastName: String
  email: String!
  phone: String
  password: String!
  acceptsMarketing: Boolean
}

type CustomerCreatePayload
  @join__type(graph: CUSTOMER)
{
  customer: Customer
  customerUserErrors: [CustomerUserError!]!
}

enum CustomerErrorCode
  @join__type(graph: CUSTOMER)
{
  BLANK
  INVALID
  TAKEN
  TOO_LONG
  TOO_SHORT
  UNIDENTIFIED_CUSTOMER
  CUSTOMER_DISABLED
  PASSWORD_STARTS_OR_ENDS_WITH_WHITESPACE
  CONTAINS_HTML_TAGS
  CONTAINS_URL
  TOKEN_INVALID
  ALREADY_ENABLED
  NOT_FOUND
  BAD_DOMAIN
  INVALID_MULTIPASS_REQUEST
}

input CustomerUpdateInput
  @join__type(graph: CUSTOMER)
{
  firstName: String
  lastName: String
  email: String
  phone: String
  password: String
  acceptsMarketing: Boolean
}

type CustomerUpdatePayload
  @join__type(graph: CUSTOMER)
{
  customer: Customer
  customerAccessToken: CustomerAccessToken
  customerUserErrors: [CustomerUserError!]!
}

type CustomerUserError implements DisplayableError
  @join__implements(graph: CUSTOMER, interface: "DisplayableError")
  @join__type(graph: CUSTOMER)
{
  code: CustomerErrorCode
  field: [String!]
  message: String!
}

scalar DateTime
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)

scalar Decimal
  @join__type(graph: PRODUCT)

interface DisplayableError
  @join__type(graph: CUSTOMER)
{
  field: [String!]
  message: String!
}

type Filter
  @join__type(graph: PRODUCT)
{
  id: String!
  label: String!
  type: FilterType!
}

enum FilterType
  @join__type(graph: PRODUCT)
{
  LIST
  PRICE_RANGE
  BOOLEAN
}

input GeoCoordinateInput
  @join__type(graph: SHOP)
{
  latitude: Float!
  longitude: Float!
}

interface HasMetafields
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  metafield(namespace: String!, key: String!): Metafield
  metafields(identifiers: [HasMetafieldsIdentifier!]!): [Metafield]!
}

input HasMetafieldsIdentifier
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  namespace: String!
  key: String!
}

scalar HTML
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)

type Image
  @join__type(graph: PRODUCT)
{
  altText: String
  height: Int
  id: ID
  url(transform: ImageTransformInput): URL!
  width: Int
  originalSrc: URL! @deprecated
  src: URL! @deprecated
  transformedSrc: URL! @deprecated
}

type ImageConnection
  @join__type(graph: PRODUCT)
{
  edges: [ImageEdge!]!
  nodes: [Image!]!
  pageInfo: PageInfo!
}

enum ImageContentType
  @join__type(graph: PRODUCT)
{
  PNG
  JPG
  WEBP
}

type ImageEdge
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: Image!
}

input ImageTransformInput
  @join__type(graph: PRODUCT)
{
  crop: CropRegion
  maxWidth: Int
  maxHeight: Int
  scale: Int = 1
  preferredContentType: ImageContentType
}

scalar join__FieldSet

enum join__Graph {
  CUSTOMER @join__graph(name: "customer", url: "https://customer.api.gshopper.com/")
  PRODUCT @join__graph(name: "product", url: "https://product.api.gshopper.com/")
  SHOP @join__graph(name: "shop", url: "https://shop.api.gshopper.com/")
}

scalar JSON
  @join__type(graph: PRODUCT)

enum LanguageCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
  @join__type(graph: SHOP)
{
  AF
  AK
  AM
  AR
  AS
  AZ
  BE
  BG
  BM
  BN
  BO
  BR
  BS
  CA
  CE
  CS
  CU
  CY
  DA
  DE
  DZ
  EE
  EL
  EN
  EO
  ES
  ET
  EU
  FA
  FF
  FI
  FO
  FR
  FY
  GA
  GD
  GL
  GU
  GV
  HA
  HE
  HI
  HR
  HU
  HY
  IA
  ID
  IG
  II
  IS
  IT
  JA
  JV
  KA
  KI
  KK
  KL
  KM
  KN
  KO
  KS
  KU
  KW
  KY
  LB
  LG
  LN
  LO
  LT
  LU
  LV
  MG
  MI
  MK
  ML
  MN
  MR
  MS
  MT
  MY
  NB
  ND
  NE
  NL
  NN
  NO
  OM
  OR
  OS
  PA
  PL
  PS
  PT_BR
  PT_PT
  QU
  RM
  RN
  RO
  RU
  RW
  SD
  SE
  SG
  SI
  SK
  SL
  SN
  SO
  SQ
  SR
  SU
  SV
  SW
  TA
  TE
  TG
  TH
  TI
  TK
  TO
  TR
  TT
  UG
  UK
  UR
  UZ
  VI
  WO
  XH
  YI
  YO
  ZH_CN
  ZH_TW
  ZU
  ZH
  PT
  VO
}

scalar link__Import

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

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

type Location implements Node
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__implements(graph: SHOP, interface: "Node")
  @join__type(graph: PRODUCT)
  @join__type(graph: SHOP, key: "id")
{
  id: ID!
  address: LocationAddress! @join__field(graph: SHOP)
  name: String! @join__field(graph: SHOP)
}

type LocationAddress
  @join__type(graph: PRODUCT)
  @join__type(graph: SHOP)
{
  address1: String
  address2: String
  city: String
  country: String
  countryCode: String
  formatted: [String!]!
  latitude: Float
  longitude: Float
  phone: String
  province: String
  provinceCode: String
  zip: String
}

type LocationConnection
  @join__type(graph: SHOP)
{
  edges: [LocationEdge!]!
  nodes: [Location!]!
  pageInfo: PageInfo!
}

type LocationEdge
  @join__type(graph: SHOP)
{
  cursor: String!
  node: Location!
}

enum LocationSortKeys
  @join__type(graph: SHOP)
{
  ID
  NAME
  CITY
  DISTANCE
}

type MailingAddress implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__type(graph: CUSTOMER)
{
  address1: String
  address2: String
  city: String
  company: String
  country: String
  countryCodeV2: CountryCode
  firstName: String
  formatted(withName: Boolean = false, withCompany: Boolean = true): [String!]!
  formattedArea: String
  id: ID!
  lastName: String
  latitude: Float
  longitude: Float
  name: String
  phone: String
  province: String
  provinceCode: String
  zip: String
  countryCode: String @deprecated(reason: "Use `countryCodeV2` instead.")
}

type MailingAddressConnection
  @join__type(graph: CUSTOMER)
{
  edges: [MailingAddressEdge!]!
  nodes: [MailingAddress!]!
  pageInfo: PageInfo!
}

type MailingAddressEdge
  @join__type(graph: CUSTOMER)
{
  cursor: String!
  node: MailingAddress!
}

interface Media
  @join__type(graph: PRODUCT)
{
  alt: String
  mediaContentType: MediaContentType!
  previewImage: Image
}

type MediaConnection
  @join__type(graph: PRODUCT)
{
  edges: [MediaEdge!]!
  nodes: [Media!]!
  pageInfo: PageInfo!
}

enum MediaContentType
  @join__type(graph: PRODUCT)
{
  EXTERNAL_VIDEO
  IMAGE
  MODEL_3D
  VIDEO
}

type MediaEdge
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: Media!
}

type Metafield implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  createdAt: DateTime!
  description: String
  id: ID!
  key: String!
  namespace: String!
  parentResource: MetafieldParentResource!
  reference: MetafieldReference
  references(first: Int, after: String, last: Int, before: String): MetafieldReferenceConnection
  type: String!
  updatedAt: DateTime!
  value: String!
}

input MetafieldFilter
  @join__type(graph: PRODUCT)
{
  namespace: String!
  key: String!
  value: String!
}

union MetafieldParentResource
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = Customer | Collection | Product | ProductVariant

union MetafieldReference
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = Page | Collection | Product | ProductVariant

type MetafieldReferenceConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [MetafieldReferenceEdge!]!
  nodes: [MetafieldReference!]!
  pageInfo: PageInfo!
}

type MetafieldReferenceEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: MetafieldReference!
}

type MoneyV2
  @join__type(graph: PRODUCT)
{
  amount: Decimal!
  currencyCode: CurrencyCode!
}

type Mutation
  @inContext
  @join__type(graph: CUSTOMER)
{
  customerAccessTokenCreate(input: CustomerAccessTokenCreateInput!): CustomerAccessTokenCreatePayload
  customerAccessTokenRenew(customerAccessToken: String!): CustomerAccessTokenRenewPayload
  customerAccessTokenDelete(customerAccessToken: String!): CustomerAccessTokenDeletePayload
  customerCreate(input: CustomerCreateInput!): CustomerCreatePayload
  customerUpdate(customerAccessToken: String!, customer: CustomerUpdateInput!): CustomerUpdatePayload
}

interface Node
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
  @join__type(graph: SHOP)
{
  id: ID!
}

interface OnlineStorePublishable
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  onlineStoreUrl: URL
}

type Page implements Node & HasMetafields & OnlineStorePublishable
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: CUSTOMER, interface: "OnlineStorePublishable")
  @join__type(graph: CUSTOMER)
{
  body: HTML!
  bodySummary: String!
  createdAt: DateTime!
  handle: String!
  id: ID!
  metafield(namespace: String!, key: String!): Metafield
  metafields(identifiers: [HasMetafieldsIdentifier!]!): [Metafield]!
  onlineStoreUrl: URL
  seo: SEO
  title: String!
  updatedAt: DateTime!
}

type PageInfo
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
  @join__type(graph: SHOP)
{
  endCursor: String
  hasNextPage: Boolean!
  hasPreviousPage: Boolean!
  startCursor: String
}

input PriceRangeFilter
  @join__type(graph: PRODUCT)
{
  min: Float = 0
  max: Float
}

type Product implements HasMetafields & Node & OnlineStorePublishable
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "OnlineStorePublishable")
  @join__type(graph: PRODUCT)
{
  availableForSale: Boolean!
  collections(after: String, before: String, first: Int, last: Int, reverse: Boolean = false): CollectionConnection!
  compareAtPriceRange: ProductPriceRange!
  createdAt: DateTime!
  description(truncateAt: Int): String!
  descriptionHtml: HTML!
  featuredImage: Image
  handle: String!
  id: ID!
  images(after: String, before: String, first: Int, last: Int, reverse: Boolean = false, sortKey: ProductImageSortKeys = POSITION): ImageConnection!
  isGiftCard: Boolean!
  media(after: String, before: String, first: Int, last: Int, reverse: Boolean = false, sortKey: ProductMediaSortKeys = POSITION): MediaConnection!
  metafield(key: String!, namespace: String!): Metafield
  metafields(identifiers: [HasMetafieldsIdentifier!]!): [Metafield]!
  onlineStoreUrl: URL
  options(first: Int): [ProductOption!]!
  priceRange: ProductPriceRange!
  productType: String!
  publishedAt: DateTime!
  requiresSellingPlan: Boolean!
  sellingPlanGroups(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SellingPlanGroupConnection!
  seo: SEO!
  tags: [String!]!
  title: String!
  totalInventory: Int
  updatedAt: DateTime!
  variantBySelectedOptions(selectedOptions: [SelectedOptionInput!]!): ProductVariant
  variants(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: ProductVariantSortKeys = POSITION): ProductVariantConnection!
  vendor: String!
}

enum ProductCollectionSortKeys
  @join__type(graph: PRODUCT)
{
  BEST_SELLING
  COLLECTION_DEFAULT
  CREATED
  ID
  MANUAL
  PRICE
  RELEVANCE
  TITLE
}

type ProductConnection
  @join__type(graph: PRODUCT)
{
  edges: [ProductEdge!]!
  filters: [Filter!]!
  nodes: [Product!]!
  pageInfo: PageInfo!
}

type ProductEdge
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: Product!
}

input ProductFilter
  @join__type(graph: PRODUCT)
{
  available: Boolean
  variantOption: VariantOptionFilter
  productType: String
  productVendor: String
  price: PriceRangeFilter
  productMetafield: MetafieldFilter
  variantMetafield: MetafieldFilter
}

enum ProductImageSortKeys
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  ID
  POSITION
  RELEVANCE
}

enum ProductMediaSortKeys
  @join__type(graph: PRODUCT)
{
  ID
  POSITION
  RELEVANCE
}

type ProductOption implements Node
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: PRODUCT)
{
  id: ID!
  name: String!
  values: [String!]!
}

type ProductPriceRange
  @join__type(graph: PRODUCT)
{
  maxVariantPrice: MoneyV2!
  minVariantPrice: MoneyV2!
}

enum ProductSortKeys
  @join__type(graph: PRODUCT)
{
  TITLE
  PRODUCT_TYPE
  VENDOR
  UPDATED_AT
  CREATED_AT
  BEST_SELLING
  PRICE
  ID
  RELEVANCE
}

type ProductVariant implements Node & HasMetafields
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__type(graph: PRODUCT)
{
  availableForSale: Boolean!
  barcode: String
  compareAtPrice: MoneyV2
  currentlyNotInStock: Boolean!
  id: ID!
  image: Image
  metafield(namespace: String!, key: String!): Metafield
  metafields(identifiers: [HasMetafieldsIdentifier!]!): [Metafield]!
  price: MoneyV2!
  product: Product!
  quantityAvailable: Int
  requiresShipping: Boolean!
  selectedOptions: [SelectedOption!]!
  sellingPlanAllocations(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SellingPlanAllocationConnection!
  sku: String
  storeAvailability(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): StoreAvailabilityConnection!
  title: String!
  unitPrice: MoneyV2
  unitPriceMeasurement: UnitPriceMeasurement
  weight: Float
  weightUnit: WeightUnit!
}

type ProductVariantConnection
  @join__type(graph: PRODUCT)
{
  edges: [ProductVariantEdge!]!
  nodes: [ProductVariant!]!
  pageInfo: PageInfo!
}

type ProductVariantEdge
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: ProductVariant!
}

enum ProductVariantSortKeys
  @join__type(graph: PRODUCT)
{
  TITLE
  SKU
  POSITION
  ID
  RELEVANCE
}

type Query
  @inContext
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
  @join__type(graph: SHOP)
{
  customer(customerAccessToken: String!): Customer @join__field(graph: CUSTOMER)
  collection(handle: String, id: ID): Collection @join__field(graph: PRODUCT)
  collections(after: String, before: String, first: Int, last: Int, query: String, reverse: Boolean = false, sortKey: CollectionSortKeys = ID): CollectionConnection! @join__field(graph: PRODUCT)
  product(handle: String, id: ID): Product @join__field(graph: PRODUCT)
  products(after: String, before: String, first: Int, last: Int, query: String, reverse: Boolean = false, sortKey: ProductSortKeys = ID): ProductConnection! @join__field(graph: PRODUCT)
  productTags(first: Int!): StringConnection! @join__field(graph: PRODUCT)
  productTypes(first: Int!): StringConnection! @join__field(graph: PRODUCT)
  productRecommendations(productId: ID!): [Product!] @join__field(graph: PRODUCT)
  locations(after: String, before: String, first: Int, last: Int, near: GeoCoordinateInput, reverse: Boolean = false, sortKey: LocationSortKeys = ID): LocationConnection! @join__field(graph: SHOP)
}

type SelectedOption
  @join__type(graph: PRODUCT)
{
  name: String!
  value: String!
}

input SelectedOptionInput
  @join__type(graph: PRODUCT)
{
  name: String!
  value: String!
}

type SellingPlan implements Node
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: PRODUCT)
{
  checkoutCharge: SellingPlanCheckoutCharge!
  description: String
  id: ID!
  name: String!
  options: [SellingPlanOption!]!
  priceAdjustments: [SellingPlanPriceAdjustment!]!
  recurringDeliveries: Boolean!
}

type SellingPlanAllocation
  @join__type(graph: PRODUCT)
{
  checkoutChargeAmount: MoneyV2!
  priceAdjustments: [SellingPlanAllocationPriceAdjustment!]!
  remainingBalanceChargeAmount: MoneyV2!
  sellingPlan: SellingPlan!
}

type SellingPlanAllocationConnection
  @join__type(graph: PRODUCT)
{
  edges: [SellingPlanAllocationEdge!]!
  nodes: [SellingPlanAllocation!]!
  pageInfo: PageInfo!
}

type SellingPlanAllocationEdge
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: SellingPlanAllocation!
}

type SellingPlanAllocationPriceAdjustment
  @join__type(graph: PRODUCT)
{
  compareAtPrice: MoneyV2!
  perDeliveryPrice: MoneyV2!
  price: MoneyV2!
  unitPrice: MoneyV2
}

type SellingPlanCheckoutCharge
  @join__type(graph: PRODUCT)
{
  type: SellingPlanCheckoutChargeType!
  value: SellingPlanCheckoutChargeValue!
}

type SellingPlanCheckoutChargePercentageValue
  @join__type(graph: PRODUCT)
{
  percentage: Float!
}

enum SellingPlanCheckoutChargeType
  @join__type(graph: PRODUCT)
{
  PERCENTAGE
  PRICE
}

union SellingPlanCheckoutChargeValue
  @join__type(graph: PRODUCT)
 = MoneyV2 | SellingPlanCheckoutChargePercentageValue

type SellingPlanConnection
  @join__type(graph: PRODUCT)
{
  edges: [SellingPlanEdge!]!
  nodes: [SellingPlan!]!
  pageInfo: PageInfo!
}

type SellingPlanEdge
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: SellingPlan!
}

type SellingPlanFixedAmountPriceAdjustment
  @join__type(graph: PRODUCT)
{
  adjustmentAmount: MoneyV2!
}

type SellingPlanFixedPriceAdjustment
  @join__type(graph: PRODUCT)
{
  price: MoneyV2!
}

type SellingPlanGroup
  @join__type(graph: PRODUCT)
{
  appName: String
  name: String!
  options: [SellingPlanGroupOption!]!
  sellingPlans(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SellingPlanConnection!
}

type SellingPlanGroupConnection
  @join__type(graph: PRODUCT)
{
  edges: [SellingPlanGroupEdge!]!
  nodes: [SellingPlanGroup!]!
  pageInfo: PageInfo!
}

type SellingPlanGroupEdge
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: SellingPlanGroup!
}

type SellingPlanGroupOption
  @join__type(graph: PRODUCT)
{
  name: String!
  values: [String!]!
}

type SellingPlanOption
  @join__type(graph: PRODUCT)
{
  name: String
  value: String
}

type SellingPlanPercentagePriceAdjustment
  @join__type(graph: PRODUCT)
{
  adjustmentPercentage: Int!
}

type SellingPlanPriceAdjustment
  @join__type(graph: PRODUCT)
{
  adjustmentValue: SellingPlanPriceAdjustmentValue!
  orderCount: Int
}

union SellingPlanPriceAdjustmentValue
  @join__type(graph: PRODUCT)
 = SellingPlanFixedAmountPriceAdjustment | SellingPlanFixedPriceAdjustment | SellingPlanPercentagePriceAdjustment

type SEO
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  description: String
  title: String
}

type StoreAvailability
  @join__type(graph: PRODUCT)
{
  available: Boolean!
  location: Location!
  pickUpTime: String!
}

type StoreAvailabilityConnection
  @join__type(graph: PRODUCT)
{
  edges: [StoreAvailabilityEdge!]!
  nodes: [StoreAvailability!]!
  pageInfo: PageInfo!
}

type StoreAvailabilityEdge
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: StoreAvailability!
}

type StringConnection
  @join__type(graph: PRODUCT)
{
  edges: [StringEdge!]!
  pageInfo: PageInfo!
}

type StringEdge
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: String!
}

type UnitPriceMeasurement
  @join__type(graph: PRODUCT)
{
  measuredType: UnitPriceMeasurementMeasuredType
  quantityUnit: UnitPriceMeasurementMeasuredUnit
  quantityValue: Float!
  referenceUnit: UnitPriceMeasurementMeasuredUnit
  referenceValue: Int!
}

enum UnitPriceMeasurementMeasuredType
  @join__type(graph: PRODUCT)
{
  AREA
  LENGTH
  VOLUME
  WEIGHT
}

enum UnitPriceMeasurementMeasuredUnit
  @join__type(graph: PRODUCT)
{
  CL
  CM
  G
  KG
  L
  M
  M2
  M3
  MG
  ML
  MM
}

scalar UnsignedInt64
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)

scalar URL
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)

type UserError implements DisplayableError
  @join__implements(graph: CUSTOMER, interface: "DisplayableError")
  @join__type(graph: CUSTOMER)
{
  field: [String!]
  message: String!
}

input VariantOptionFilter
  @join__type(graph: PRODUCT)
{
  name: String!
  value: String!
}

enum WeightUnit
  @join__type(graph: PRODUCT)
{
  KILOGRAMS
  GRAMS
  POUNDS
  OUNCES
}

directive @inContext(
    language: LanguageCode,
    country: CountryCode
) on QUERY | MUTATION | OBJECT