Admin-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 AccessScope
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  description: String!
  handle: String!
}

type App implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  apiKey: String!
  appStoreAppUrl: URL
  appStoreDeveloperUrl: URL
  availableAccessScopes: [AccessScope!]!
  banner: Image!
  description: String
  developerName: String
  developerType: AppDeveloperType!
  embedded: Boolean!
  failedRequirements: [FailedRequirement!]!
  features: [String!]!
  feedback: AppFeedback
  handle: String
  icon: Image!
  id: ID!
  installUrl: URL
  installation: AppInstallation
  isPostPurchaseAppInUse: Boolean!
  previouslyInstalled: Boolean!
  pricingDetails: String
  pricingDetailsSummary: String!
  privacyPolicyUrl: URL
  publicCategory: AppPublicCategory!
  published: Boolean!
  requestedAccessScopes: [AccessScope!]!
  screenshots: [Image!]!
  shopifyDeveloped: Boolean!
  title: String!
  uninstallMessage: String!
  webhookApiVersion: String!
}

type AppConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [AppEdge!]!
  nodes: [App!]!
  pageInfo: PageInfo!
}

type AppCredit implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amount: MoneyV2!
  createdAt: DateTime!
  description: String!
  id: ID!
  test: Boolean!
}

type AppCreditConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [AppCreditEdge!]!
  nodes: [AppCredit!]!
  pageInfo: PageInfo!
}

type AppCreditEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: AppCredit!
}

enum AppDeveloperType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SHOPIFY
  PARTNER
  MERCHANT
  UNKNOWN
}

type AppEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: App!
}

type AppFeedback
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  app: App!
  link: Link
  messages: [UserError!]!
}

type AppInstallation implements HasMetafields & Node
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  accessScopes: [AccessScope!]!
  activeSubscriptions: [AppSubscription!]!
  allSubscriptions(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: AppSubscriptionSortKeys = CREATED_AT): AppSubscriptionConnection!
  app: App!
  credits(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: AppTransactionSortKeys = CREATED_AT): AppCreditConnection!
  id: ID!
  launchUrl: URL!
  metafield(namespace: String!, key: String!): Metafield
  metafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  oneTimePurchases(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: AppTransactionSortKeys = CREATED_AT): AppPurchaseOneTimeConnection!
  privateMetafield(namespace: String!, key: String!): PrivateMetafield
  privateMetafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PrivateMetafieldConnection!
  publication: Publication
  revenueAttributionRecords(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: AppRevenueAttributionRecordSortKeys = CREATED_AT): AppRevenueAttributionRecordConnection!
  uninstallUrl: URL
}

type AppPlanV2
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  pricingDetails: AppPricingDetails!
}

union AppPricingDetails
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = AppRecurringPricing | AppUsagePricing

enum AppPricingInterval
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ANNUAL
  EVERY_30_DAYS
}

enum AppPublicCategory
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PRIVATE
  PUBLIC
  CUSTOM
  OTHER
}

interface AppPurchase
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  createdAt: DateTime!
  name: String!
  price: MoneyV2!
  status: AppPurchaseStatus!
  test: Boolean!
}

type AppPurchaseOneTime implements AppPurchase & Node
  @join__implements(graph: CUSTOMER, interface: "AppPurchase")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "AppPurchase")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  createdAt: DateTime!
  id: ID!
  name: String!
  price: MoneyV2!
  status: AppPurchaseStatus!
  test: Boolean!
}

type AppPurchaseOneTimeConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [AppPurchaseOneTimeEdge!]!
  nodes: [AppPurchaseOneTime!]!
  pageInfo: PageInfo!
}

type AppPurchaseOneTimeEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: AppPurchaseOneTime!
}

enum AppPurchaseStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ACTIVE
  DECLINED
  EXPIRED
  PENDING
}

type AppRecurringPricing
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  discount: AppSubscriptionDiscount
  interval: AppPricingInterval!
  price: MoneyV2!
}

type AppRevenueAttributionRecord implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amount: MoneyV2!
  capturedAt: DateTime!
  createdAt: DateTime!
  id: ID!
  idempotencyKey: String!
  test: Boolean!
  type: AppRevenueAttributionType!
}

type AppRevenueAttributionRecordConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [AppRevenueAttributionRecordEdge!]!
  nodes: [AppRevenueAttributionRecord!]!
  pageInfo: PageInfo!
}

type AppRevenueAttributionRecordEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: AppRevenueAttributionRecord!
}

enum AppRevenueAttributionRecordSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  ID
  RELEVANCE
}

enum AppRevenueAttributionType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  APPLICATION_PURCHASE
  APPLICATION_SUBSCRIPTION
  APPLICATION_USAGE
  OTHER
}

type AppSubscription implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  createdAt: DateTime!
  currentPeriodEnd: DateTime
  id: ID!
  lineItems: [AppSubscriptionLineItem!]!
  name: String!
  returnUrl: URL!
  status: AppSubscriptionStatus!
  test: Boolean!
  trialDays: Int!
}

type AppSubscriptionConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [AppSubscriptionEdge!]!
  nodes: [AppSubscription!]!
  pageInfo: PageInfo!
}

type AppSubscriptionDiscount
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  durationLimitInIntervals: Int
  priceAfterDiscount: MoneyV2!
  remainingDurationInIntervals: Int
  value: AppSubscriptionDiscountValue!
}

type AppSubscriptionDiscountAmount
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amount: MoneyV2!
}

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

union AppSubscriptionDiscountValue
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = AppSubscriptionDiscountAmount | AppSubscriptionDiscountPercentage

type AppSubscriptionEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: AppSubscription!
}

type AppSubscriptionLineItem
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  plan: AppPlanV2!
  usageRecords(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: AppUsageRecordSortKeys = CREATED_AT): AppUsageRecordConnection!
}

enum AppSubscriptionSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  ID
  RELEVANCE
}

enum AppSubscriptionStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PENDING
  ACTIVE
  DECLINED
  EXPIRED
  FROZEN
  CANCELLED
}

enum AppTransactionSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  ID
  RELEVANCE
}

type AppUsagePricing
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  balanceUsed: MoneyV2!
  cappedAmount: MoneyV2!
  interval: AppPricingInterval!
  terms: String!
}

type AppUsageRecord 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!
  price: MoneyV2!
  subscriptionLineItem: AppSubscriptionLineItem!
}

type AppUsageRecordConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [AppUsageRecordEdge!]!
  nodes: [AppUsageRecord!]!
  pageInfo: PageInfo!
}

type AppUsageRecordEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: AppUsageRecord!
}

enum AppUsageRecordSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  ID
  RELEVANCE
}

type Attribute
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  key: String!
  value: String
}

type AutomaticDiscountApplication implements DiscountApplication
  @join__implements(graph: CUSTOMER, interface: "DiscountApplication")
  @join__implements(graph: PRODUCT, interface: "DiscountApplication")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  allocationMethod: DiscountApplicationAllocationMethod!
  index: Int!
  targetSelection: DiscountApplicationTargetSelection!
  targetType: DiscountApplicationTargetType!
  title: String!
  value: PricingValue!
}

type AvailableChannelDefinitionsByChannel
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  channelDefinitions: [ChannelDefinition!]!
  channelName: String!
}

type BasicEvent implements Event & Node
  @join__implements(graph: CUSTOMER, interface: "Event")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Event")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  appTitle: String
  attributeToApp: Boolean!
  attributeToUser: Boolean!
  createdAt: DateTime!
  criticalAlert: Boolean!
  id: ID!
  message: FormattedString!
}

type BuyerExperienceConfiguration
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  checkoutToDraft: Boolean!
  payNowOnly: Boolean!
  paymentTermsTemplate: PaymentTermsTemplate
}

type ChannelDefinition implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  channelName: String!
  handle: String!
  id: ID!
  subChannelName: String!
  svgIcon: String
}

type ChannelInformation implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  app: App!
  channelDefinition: ChannelDefinition
  channelId: ID!
  id: ID!
}

type Collection implements HasMetafieldDefinitions & HasMetafields & HasPublishedTranslations & Node & Publishable
  @join__implements(graph: CUSTOMER, interface: "HasMetafieldDefinitions")
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: CUSTOMER, interface: "HasPublishedTranslations")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: CUSTOMER, interface: "Publishable")
  @join__implements(graph: PRODUCT, interface: "HasMetafieldDefinitions")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "HasPublishedTranslations")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Publishable")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  availablePublicationCount: Int!
  description(truncateAt: Int): String!
  descriptionHtml: HTML!
  feedback: ResourceFeedback
  handle: String!
  hasProduct(id: ID!): Boolean!
  id: ID!
  image: Image
  legacyResourceId: UnsignedInt64!
  metafield(namespace: String!, key: String!): Metafield
  metafieldDefinitions(namespace: String, pinnedStatus: MetafieldDefinitionPinnedStatus = ANY, first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: MetafieldDefinitionSortKeys = ID, query: String): MetafieldDefinitionConnection!
  metafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  privateMetafield(namespace: String!, key: String!): PrivateMetafield
  privateMetafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PrivateMetafieldConnection!
  products(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: ProductCollectionSortKeys = COLLECTION_DEFAULT): ProductConnection!
  productsCount: Int!
  publicationCount(onlyPublished: Boolean = true): Int!
  publishedOnCurrentPublication: Boolean!
  publishedOnPublication(publicationId: ID!): Boolean!
  resourcePublications(onlyPublished: Boolean = true, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ResourcePublicationConnection!
  resourcePublicationsV2(onlyPublished: Boolean = true, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ResourcePublicationV2Connection!
  ruleSet: CollectionRuleSet
  seo: SEO!
  sortOrder: CollectionSortOrder!
  templateSuffix: String
  title: String!
  translations(locale: String!, marketId: ID): [PublishedTranslation!]!
  unpublishedPublications(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PublicationConnection!
  updatedAt: DateTime!
}

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

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

type CollectionRule
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  appliedDisjunctively: Boolean!
  rules: [CollectionRule!]!
}

type CollectionRuleSet
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  appliedDisjunctively: Boolean!
  rules: [CollectionRule!]!
}

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

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

type CommentEvent implements Event & Node
  @join__implements(graph: CUSTOMER, interface: "Event")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Event")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  appTitle: String
  attachments: [CommentEventAttachment!]!
  attributeToApp: Boolean!
  attributeToUser: Boolean!
  author: StaffMember!
  canDelete: Boolean!
  canEdit: Boolean!
  createdAt: DateTime!
  criticalAlert: Boolean!
  edited: Boolean!
  embed: CommentEventEmbed
  id: ID!
  message: FormattedString!
  rawMessage: String!
  subject: CommentEventSubject!
}

type CommentEventAttachment
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  fileExtension: String
  id: ID!
  image: Image
  name: String!
  size: Int!
  url: URL!
}

union CommentEventEmbed
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = Customer | DraftOrder | Order | Product | ProductVariant

interface CommentEventSubject
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  hasTimelineComment: Boolean!
}

type Company implements CommentEventSubject & HasEvents & Navigable & Node
  @join__implements(graph: CUSTOMER, interface: "CommentEventSubject")
  @join__implements(graph: CUSTOMER, interface: "HasEvents")
  @join__implements(graph: CUSTOMER, interface: "Navigable")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "CommentEventSubject")
  @join__implements(graph: PRODUCT, interface: "HasEvents")
  @join__implements(graph: PRODUCT, interface: "Navigable")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  contactCount: Int!
  contactRoles(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: CompanyContactRoleSortKeys = ID): CompanyContactRoleConnection!
  contacts(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: CompanyContactSortKeys = ID, query: String): CompanyContactConnection!
  createdAt: DateTime!
  customerSince: DateTime!
  defaultCursor: String!
  defaultRole: CompanyContactRole
  draftOrders(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: DraftOrderSortKeys = ID, query: String): DraftOrderConnection!
  events(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: EventSortKeys = ID, query: String): EventConnection!
  externalId: String
  hasTimelineComment: Boolean!
  id: ID!
  lifetimeDuration: String!
  locationCount: Int!
  locations(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: CompanyLocationSortKeys = ID, query: String): CompanyLocationConnection!
  mainContact: CompanyContact
  name: String!
  note: String
  orderCount: Int!
  orders(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: OrderSortKeys = ID): OrderConnection!
  totalSpent: MoneyV2!
  updatedAt: DateTime!
}

type CompanyAddress implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address1: String!
  address2: String
  city: String
  companyName: String!
  country: String
  countryCode: CountryCode!
  createdAt: DateTime!
  formattedArea: String
  id: ID!
  phone: String
  province: String
  recipient: String
  updatedAt: DateTime!
  zip: String
  zoneCode: String
}

type CompanyContact implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  company: Company!
  createdAt: DateTime!
  customer: Customer!
  draftOrders(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: DraftOrderSortKeys = ID, query: String): DraftOrderConnection!
  id: ID!
  isMainContact: Boolean!
  lifetimeDuration: String!
  locale: String
  orders(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: OrderSortKeys = ID): OrderConnection!
  roleAssignments(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: CompanyContactRoleAssignmentSortKeys = ID, query: String): CompanyContactRoleAssignmentConnection!
  title: String
  updatedAt: DateTime!
}

type CompanyContactConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [CompanyContactEdge!]!
  nodes: [CompanyContact!]!
  pageInfo: PageInfo!
}

type CompanyContactEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: CompanyContact!
}

type CompanyContactRole implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  name: String!
  note: String
}

type CompanyContactRoleAssignment implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  company: Company!
  companyContact: CompanyContact!
  companyLocation: CompanyLocation!
  createdAt: DateTime!
  id: ID!
  role: CompanyContactRole!
  updatedAt: DateTime!
}

type CompanyContactRoleAssignmentConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [CompanyContactRoleAssignmentEdge!]!
  nodes: [CompanyContactRoleAssignment!]!
  pageInfo: PageInfo!
}

type CompanyContactRoleAssignmentEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: CompanyContactRoleAssignment!
}

enum CompanyContactRoleAssignmentSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  UPDATED_AT
  LOCATION_NAME
  ID
  RELEVANCE
}

type CompanyContactRoleConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [CompanyContactRoleEdge!]!
  nodes: [CompanyContactRole!]!
  pageInfo: PageInfo!
}

type CompanyContactRoleEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: CompanyContactRole!
}

enum CompanyContactRoleSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  UPDATED_AT
  ID
  RELEVANCE
}

enum CompanyContactSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  UPDATED_AT
  TITLE
  COMPANY_ID
  NAME
  EMAIL
  NAME_EMAIL
  ID
  RELEVANCE
}

type CompanyLocation implements CommentEventSubject & HasEvents & Navigable & Node
  @join__implements(graph: CUSTOMER, interface: "CommentEventSubject")
  @join__implements(graph: CUSTOMER, interface: "HasEvents")
  @join__implements(graph: CUSTOMER, interface: "Navigable")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "CommentEventSubject")
  @join__implements(graph: PRODUCT, interface: "HasEvents")
  @join__implements(graph: PRODUCT, interface: "Navigable")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  billingAddress: CompanyAddress
  buyerExperienceConfiguration: BuyerExperienceConfiguration
  company: Company!
  createdAt: DateTime!
  currency: CurrencyCode!
  defaultCursor: String!
  draftOrders(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: DraftOrderSortKeys = ID, query: String): DraftOrderConnection!
  events(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: EventSortKeys = ID, query: String): EventConnection!
  externalId: String
  hasTimelineComment: Boolean!
  id: ID!
  locale: String
  market: Market!
  name: String!
  note: String
  orderCount: Int!
  orders(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: OrderSortKeys = ID): OrderConnection!
  phone: String
  roleAssignments(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: CompanyContactRoleAssignmentSortKeys = ID, query: String): CompanyContactRoleAssignmentConnection!
  shippingAddress: CompanyAddress
  taxExemptions: [TaxExemption!]!
  taxRegistrationId: String
  totalSpent: MoneyV2!
  updatedAt: DateTime!
}

type CompanyLocationConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [CompanyLocationEdge!]!
  nodes: [CompanyLocation!]!
  pageInfo: PageInfo!
}

type CompanyLocationEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: CompanyLocation!
}

enum CompanyLocationSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  UPDATED_AT
  NAME
  COMPANY_ID
  COMPANY_AND_LOCATION_NAME
  ID
  RELEVANCE
}

input ContextualPricingContext
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  country: CountryCode
  companyLocationId: ID
}

type CountriesInShippingZones
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countryCodes: [CountryCode!]!
  includeRestOfWorld: Boolean!
}

enum CountryCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  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
}

type CountryHarmonizedSystemCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countryCode: CountryCode!
  harmonizedSystemCode: String!
}

type CountryHarmonizedSystemCodeConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [CountryHarmonizedSystemCodeEdge!]!
  nodes: [CountryHarmonizedSystemCode!]!
  pageInfo: PageInfo!
}

type CountryHarmonizedSystemCodeEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: CountryHarmonizedSystemCode!
}

input CreateMediaInput
  @join__type(graph: PRODUCT)
{
  originalSource: String!
  alt: String
  mediaContentType: MediaContentType!
}

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

enum CurrencyCode
  @join__type(graph: CUSTOMER)
  @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 CurrencyFormats
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  moneyFormat: FormattedString!
  moneyInEmailsFormat: String!
  moneyWithCurrencyFormat: FormattedString!
  moneyWithCurrencyInEmailsFormat: String!
}

type CurrencySetting
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  currencyCode: CurrencyCode!
  currencyName: String!
  enabled: Boolean!
  rateUpdatedAt: DateTime
}

type CurrencySettingConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [CurrencySettingEdge!]!
  nodes: [CurrencySetting!]!
  pageInfo: PageInfo!
}

type CurrencySettingEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: CurrencySetting!
}

type Customer implements CommentEventSubject & HasEvents & HasMetafieldDefinitions & HasMetafields & LegacyInteroperability & Node
  @join__implements(graph: CUSTOMER, interface: "CommentEventSubject")
  @join__implements(graph: CUSTOMER, interface: "HasEvents")
  @join__implements(graph: CUSTOMER, interface: "HasMetafieldDefinitions")
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "CommentEventSubject")
  @join__implements(graph: PRODUCT, interface: "HasEvents")
  @join__implements(graph: PRODUCT, interface: "HasMetafieldDefinitions")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  addresses(first: Int): [MailingAddress!]!
  amountSpent: MoneyV2!
  averageOrderAmountV2: MoneyV2
  canDelete: Boolean!
  companyContactProfiles: [CompanyContact!]!
  createdAt: DateTime!
  defaultAddress: MailingAddress
  displayName: String!
  email: String
  emailMarketingConsent: CustomerEmailMarketingConsentState
  events(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: EventSortKeys = ID, query: String): EventConnection!
  firstName: String
  hasTimelineComment: Boolean!
  id: ID!
  image: Image!
  lastName: String
  lastOrder: Order
  legacyResourceId: UnsignedInt64!
  lifetimeDuration: String!
  locale: String!
  market: Market
  metafield(namespace: String!, key: String!): Metafield
  metafieldDefinitions(namespace: String, pinnedStatus: MetafieldDefinitionPinnedStatus = ANY, first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: MetafieldDefinitionSortKeys = ID, query: String): MetafieldDefinitionConnection!
  metafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  multipassIdentifier: String
  note: String
  numberOfOrders: UnsignedInt64!
  orders(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: OrderSortKeys = ID, query: String): OrderConnection!
  paymentMethods(showRevoked: Boolean = false, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): CustomerPaymentMethodConnection!
  phone: String
  privateMetafield(namespace: String!, key: String!): PrivateMetafield
  privateMetafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PrivateMetafieldConnection!
  productSubscriberStatus: CustomerProductSubscriberStatus!
  smsMarketingConsent: CustomerSmsMarketingConsentState
  state: CustomerState!
  statistics: CustomerStatistics!
  subscriptionContracts(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SubscriptionContractConnection!
  tags: [String!]!
  taxExempt: Boolean!
  taxExemptions: [TaxExemption!]!
  unsubscribeUrl: URL!
  updatedAt: DateTime!
  validEmailAddress: Boolean!
  verifiedEmail: Boolean!
}

enum CustomerConsentCollectedFrom
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SHOPIFY
  OTHER
}

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

type CustomerCreditCard
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  billingAddress: CustomerCreditCardBillingAddress
  brand: String!
  expiresSoon: Boolean!
  expiryMonth: Int!
  expiryYear: Int!
  firstDigits: String
  isRevocable: Boolean!
  lastDigits: String!
  maskedNumber: String!
  name: String!
  source: String
  virtualLastDigits: String
}

type CustomerCreditCardBillingAddress
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address1: String
  city: String
  country: String
  countryCode: CountryCode
  province: String
  provinceCode: String
  zip: String
}

type CustomerEmailMarketingConsentState
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  consentUpdatedAt: DateTime
  marketingOptInLevel: CustomerMarketingOptInLevel
  marketingState: CustomerEmailMarketingState!
}

enum CustomerEmailMarketingState
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  NOT_SUBSCRIBED
  PENDING
  SUBSCRIBED
  UNSUBSCRIBED
  REDACTED
  INVALID
}

input CustomerInput
  @join__type(graph: CUSTOMER)
{
  addresses: [MailingAddressInput!]
  email: String
  firstName: String
  id: ID
  lastName: String
  locale: String
  metafields: [MetafieldInput!]
  note: String
  phone: String
  privateMetafields: [PrivateMetafieldInput!]
  tags: [String!]
}

type CustomerJourneySummary
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  customerOrderIndex: Int
  daysToConversion: Int
  firstVisit: CustomerVisit
  lastVisit: CustomerVisit
  moments(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): CustomerMomentConnection
  momentsCount: Int
  ready: Boolean!
}

enum CustomerMarketingOptInLevel
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SINGLE_OPT_IN
  CONFIRMED_OPT_IN
  UNKNOWN
}

interface CustomerMoment
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  occurredAt: DateTime!
}

type CustomerMomentConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [CustomerMomentEdge!]!
  nodes: [CustomerMoment!]!
  pageInfo: PageInfo!
}

type CustomerMomentEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: CustomerMoment!
}

union CustomerPaymentInstrument
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = CustomerCreditCard | CustomerPaypalBillingAgreement | CustomerShopPayAgreement

type CustomerPaymentInstrumentBillingAddress
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address1: String
  city: String
  country: String
  countryCode: CountryCode
  name: String
  province: String
  provinceCode: String
  zip: String
}

type CustomerPaymentMethod implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  customer: Customer
  id: ID!
  instrument: CustomerPaymentInstrument
  revokedAt: DateTime
  revokedReason: CustomerPaymentMethodRevocationReason
  subscriptionContracts(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SubscriptionContractConnection!
}

type CustomerPaymentMethodConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [CustomerPaymentMethodEdge!]!
  nodes: [CustomerPaymentMethod!]!
  pageInfo: PageInfo!
}

type CustomerPaymentMethodEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: CustomerPaymentMethod!
}

enum CustomerPaymentMethodRevocationReason
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  AUTHORIZE_NET_GATEWAY_NOT_ENABLED
  AUTHORIZE_NET_RETURNED_NO_PAYMENT_METHOD
  FAILED_TO_UPDATE_CREDIT_CARD
  STRIPE_API_AUTHENTICATION_ERROR
  STRIPE_API_INVALID_REQUEST_ERROR
  STRIPE_GATEWAY_NOT_ENABLED
  STRIPE_RETURNED_NO_PAYMENT_METHOD
  STRIPE_PAYMENT_METHOD_NOT_CARD
  BRAINTREE_API_AUTHENTICATION_ERROR
  BRAINTREE_GATEWAY_NOT_ENABLED
  BRAINTREE_RETURNED_NO_PAYMENT_METHOD
  BRAINTREE_PAYMENT_METHOD_NOT_CARD
  MANUALLY_REVOKED
  MERGED
}

type CustomerPaypalBillingAgreement
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  billingAddress: CustomerPaymentInstrumentBillingAddress
  inactive: Boolean!
  isRevocable: Boolean!
  paypalAccountEmail: String
}

enum CustomerPredictedSpendTier
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  HIGH
  MEDIUM
  LOW
}

enum CustomerProductSubscriberStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ACTIVE
  CANCELLED
  EXPIRED
  FAILED
  NEVER_SUBSCRIBED
  PAUSED
}

type CustomerShopPayAgreement
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  expiresSoon: Boolean!
  expiryMonth: Int!
  expiryYear: Int!
  inactive: Boolean!
  isRevocable: Boolean!
  lastDigits: String!
  maskedNumber: String!
  name: String!
}

type CustomerSmsMarketingConsentState
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  consentCollectedFrom: CustomerConsentCollectedFrom
  consentUpdatedAt: DateTime
  marketingOptInLevel: CustomerMarketingOptInLevel!
  marketingState: CustomerSmsMarketingState!
}

enum CustomerSmsMarketingState
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  NOT_SUBSCRIBED
  PENDING
  SUBSCRIBED
  UNSUBSCRIBED
  REDACTED
}

enum CustomerState
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  DECLINED
  DISABLED
  ENABLED
  INVITED
}

type CustomerStatistics
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  predictedSpendTier: CustomerPredictedSpendTier
}

type CustomerVisit implements CustomerMoment & Node
  @join__implements(graph: CUSTOMER, interface: "CustomerMoment")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "CustomerMoment")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  landingPage: URL
  landingPageHtml: HTML
  marketingEvent: MarketingEvent
  occurredAt: DateTime!
  referralCode: String
  referralInfoHtml: FormattedString!
  referrerUrl: URL
  source: String!
  sourceDescription: String
  sourceType: MarketingTactic
  utmParameters: UTMParameters
}

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

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

type DeliveryAvailableService
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countries: DeliveryCountryCodesOrRestOfWorld!
  name: String!
}

type DeliveryCarrierService implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  availableServicesForCountries(origins: [ID!], countryCodes: [CountryCode!], restOfWorld: Boolean!): [DeliveryAvailableService!]!
  formattedName: String
  icon: Image!
  id: ID!
  name: String
}

type DeliveryCondition implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  conditionCriteria: DeliveryConditionCriteria!
  field: DeliveryConditionField!
  id: ID!
  operator: DeliveryConditionOperator!
}

union DeliveryConditionCriteria
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = MoneyV2 | Weight

enum DeliveryConditionField
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  TOTAL_WEIGHT
  TOTAL_PRICE
}

enum DeliveryConditionOperator
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  GREATER_THAN_OR_EQUAL_TO
  LESS_THAN_OR_EQUAL_TO
}

type DeliveryCountry implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  code: DeliveryCountryCodeOrRestOfWorld!
  id: ID!
  name: String!
  provinces: [DeliveryProvince!]!
  translatedName: String!
}

type DeliveryCountryAndZone
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  country: DeliveryCountry!
  zone: String!
}

type DeliveryCountryCodeOrRestOfWorld
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countryCode: CountryCode
  restOfWorld: Boolean!
}

type DeliveryCountryCodesOrRestOfWorld
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countryCodes: [CountryCode!]!
  restOfWorld: Boolean!
}

type DeliveryLocationGroup implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  locations(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: LocationSortKeys = NAME, query: String, includeLegacy: Boolean = false, includeInactive: Boolean = false): LocationConnection!
}

type DeliveryLocationGroupZone
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  methodDefinitionCounts: DeliveryMethodDefinitionCounts!
  methodDefinitions(eligible: Boolean, type: DeliveryMethodDefinitionType, first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: MethodDefinitionSortKeys = ID): DeliveryMethodDefinitionConnection!
  zone: DeliveryZone!
}

type DeliveryLocationGroupZoneConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [DeliveryLocationGroupZoneEdge!]!
  nodes: [DeliveryLocationGroupZone!]!
  pageInfo: PageInfo!
}

type DeliveryLocationGroupZoneEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: DeliveryLocationGroupZone!
}

type DeliveryMethod implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  maxDeliveryDateTime: DateTime
  methodType: DeliveryMethodType!
  minDeliveryDateTime: DateTime
}

type DeliveryMethodDefinition implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  active: Boolean!
  description: String
  id: ID!
  methodConditions: [DeliveryCondition!]!
  name: String!
  rateProvider: DeliveryRateProvider!
}

type DeliveryMethodDefinitionConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [DeliveryMethodDefinitionEdge!]!
  nodes: [DeliveryMethodDefinition!]!
  pageInfo: PageInfo!
}

type DeliveryMethodDefinitionCounts
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  participantDefinitionsCount: Int!
  rateDefinitionsCount: Int!
}

type DeliveryMethodDefinitionEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: DeliveryMethodDefinition!
}

enum DeliveryMethodDefinitionType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  MERCHANT
  PARTICIPANT
}

enum DeliveryMethodType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SHIPPING
  PICK_UP
  NONE
  RETAIL
  LOCAL
}

type DeliveryParticipant implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  adaptToNewServicesFlag: Boolean!
  carrierService: DeliveryCarrierService!
  fixedFee: MoneyV2
  id: ID!
  participantServices: [DeliveryParticipantService!]!
  percentageOfRateFee: Float!
}

type DeliveryParticipantService
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  active: Boolean!
  name: String!
}

type DeliveryProductVariantsCount
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  capped: Boolean!
  count: Int!
}

type DeliveryProfile implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  activeMethodDefinitionsCount: Int!
  default: Boolean!
  id: ID!
  legacyMode: Boolean!
  locationsWithoutRatesCount: Int!
  name: String!
  originLocationCount: Int!
  productVariantsCountV2: DeliveryProductVariantsCount!
  profileItems(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): DeliveryProfileItemConnection!
  profileLocationGroups: [DeliveryProfileLocationGroup!]!
  sellingPlanGroups(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SellingPlanGroupConnection!
  unassignedLocations: [Location!]!
  zoneCountryCount: Int!
}

type DeliveryProfileItem implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  product: Product!
  variants(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ProductVariantConnection!
}

type DeliveryProfileItemConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [DeliveryProfileItemEdge!]!
  nodes: [DeliveryProfileItem!]!
  pageInfo: PageInfo!
}

type DeliveryProfileItemEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: DeliveryProfileItem!
}

type DeliveryProfileLocationGroup
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countriesInAnyZone: [DeliveryCountryAndZone!]!
  locationGroup: DeliveryLocationGroup!
  locationGroupZones(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): DeliveryLocationGroupZoneConnection!
}

type DeliveryProvince implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  code: String!
  id: ID!
  name: String!
  translatedName: String!
}

type DeliveryRateDefinition implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  price: MoneyV2!
}

union DeliveryRateProvider
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = DeliveryParticipant | DeliveryRateDefinition

type DeliveryZone implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countries: [DeliveryCountry!]!
  id: ID!
  name: String!
}

enum DigitalWallet
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  APPLE_PAY
  ANDROID_PAY
  GOOGLE_PAY
  SHOPIFY_PAY
}

type DiscountAllocation
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  allocatedAmountSet: MoneyBag!
  discountApplication: DiscountApplication!
}

interface DiscountApplication
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  allocationMethod: DiscountApplicationAllocationMethod!
  index: Int!
  targetSelection: DiscountApplicationTargetSelection!
  targetType: DiscountApplicationTargetType!
  value: PricingValue!
}

enum DiscountApplicationAllocationMethod
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ACROSS
  EACH
}

type DiscountApplicationConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [DiscountApplicationEdge!]!
  nodes: [DiscountApplication!]!
  pageInfo: PageInfo!
}

type DiscountApplicationEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: DiscountApplication!
}

enum DiscountApplicationTargetSelection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ALL
  ENTITLED
  EXPLICIT
}

enum DiscountApplicationTargetType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  LINE_ITEM
  SHIPPING_LINE
}

type DiscountCodeApplication implements DiscountApplication
  @join__implements(graph: CUSTOMER, interface: "DiscountApplication")
  @join__implements(graph: PRODUCT, interface: "DiscountApplication")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  allocationMethod: DiscountApplicationAllocationMethod!
  code: String!
  index: Int!
  targetSelection: DiscountApplicationTargetSelection!
  targetType: DiscountApplicationTargetType!
  value: PricingValue!
}

enum DiscountTargetType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  LINE_ITEM
  SHIPPING_LINE
}

enum DiscountType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  MANUAL
  CODE_DISCOUNT
}

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

enum DisputeStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  NEEDS_RESPONSE
  UNDER_REVIEW
  CHARGE_REFUNDED
  ACCEPTED
  WON
  LOST
}

enum DisputeType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CHARGEBACK
  INQUIRY
}

type Domain implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  host: String!
  id: ID!
  localization: DomainLocalization
  marketWebPresence: MarketWebPresence
  sslEnabled: Boolean!
  url: URL!
}

type DomainLocalization
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  alternateLocales: [String!]!
  country: String
  defaultLocale: String!
}

type DraftOrder implements CommentEventSubject & HasEvents & HasLocalizationExtensions & HasMetafields & LegacyInteroperability & Navigable & Node
  @join__implements(graph: CUSTOMER, interface: "CommentEventSubject")
  @join__implements(graph: CUSTOMER, interface: "HasEvents")
  @join__implements(graph: CUSTOMER, interface: "HasLocalizationExtensions")
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Navigable")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "CommentEventSubject")
  @join__implements(graph: PRODUCT, interface: "HasEvents")
  @join__implements(graph: PRODUCT, interface: "HasLocalizationExtensions")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Navigable")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  appliedDiscount: DraftOrderAppliedDiscount
  billingAddress: MailingAddress
  billingAddressMatchesShippingAddress: Boolean!
  completedAt: DateTime
  createdAt: DateTime!
  currencyCode: CurrencyCode!
  customAttributes: [Attribute!]!
  customer: Customer
  defaultCursor: String!
  email: String
  events(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: EventSortKeys = ID, query: String): EventConnection!
  hasTimelineComment: Boolean!
  id: ID!
  invoiceEmailTemplateSubject: String!
  invoiceSentAt: DateTime
  invoiceUrl: URL
  legacyResourceId: UnsignedInt64!
  lineItems(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): DraftOrderLineItemConnection!
  lineItemsSubtotalPrice: MoneyBag!
  localizationExtensions(countryCodes: [CountryCode!], purposes: [LocalizationExtensionPurpose!], first: Int, after: String, last: Int, before: String, reverse: Boolean = false): LocalizationExtensionConnection!
  marketName: String!
  marketRegionCountryCode: CountryCode!
  metafield(namespace: String!, key: String!): Metafield
  metafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  name: String!
  note2: String
  order: Order
  paymentTerms: PaymentTerms
  phone: String
  presentmentCurrencyCode: CurrencyCode!
  privateMetafield(namespace: String!, key: String!): PrivateMetafield
  privateMetafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PrivateMetafieldConnection!
  purchasingEntity: PurchasingEntity
  ready: Boolean!
  reserveInventoryUntil: DateTime
  shippingAddress: MailingAddress
  shippingLine: ShippingLine
  status: DraftOrderStatus!
  subtotalPrice: Money!
  subtotalPriceSet: MoneyBag!
  tags: [String!]!
  taxExempt: Boolean!
  taxLines: [TaxLine!]!
  taxesIncluded: Boolean!
  totalDiscountsSet: MoneyBag!
  totalLineItemsPriceSet: MoneyBag!
  totalPrice: Money!
  totalPriceSet: MoneyBag!
  totalShippingPrice: Money!
  totalShippingPriceSet: MoneyBag!
  totalTax: Money!
  totalTaxSet: MoneyBag!
  totalWeight: UnsignedInt64!
  updatedAt: DateTime!
  visibleToCustomer: Boolean!
}

type DraftOrderAppliedDiscount
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amountSet: MoneyBag!
  amountV2: MoneyV2!
  description: String!
  title: String
  value: Float!
  valueType: DraftOrderAppliedDiscountType!
}

enum DraftOrderAppliedDiscountType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  FIXED_AMOUNT
  PERCENTAGE
}

type DraftOrderConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [DraftOrderEdge!]!
  nodes: [DraftOrder!]!
  pageInfo: PageInfo!
}

type DraftOrderEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: DraftOrder!
}

type DraftOrderLineItem implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  appliedDiscount: DraftOrderAppliedDiscount
  custom: Boolean!
  customAttributes: [Attribute!]!
  customAttributesV2: [TypedAttribute!]!
  discountedTotal: Money!
  discountedTotalSet: MoneyBag!
  discountedUnitPrice: Money!
  discountedUnitPriceSet: MoneyBag!
  fulfillmentService: FulfillmentService
  id: ID!
  image: Image
  isGiftCard: Boolean!
  name: String!
  originalTotal: Money!
  originalTotalSet: MoneyBag!
  originalUnitPrice: Money!
  originalUnitPriceSet: MoneyBag!
  product: Product
  quantity: Int!
  requiresShipping: Boolean!
  sku: String
  taxLines: [TaxLine!]!
  taxable: Boolean!
  title: String!
  totalDiscount: Money!
  totalDiscountSet: MoneyBag!
  variant: ProductVariant
  variantTitle: String
  vendor: String
  weight: Weight
}

type DraftOrderLineItemConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [DraftOrderLineItemEdge!]!
  nodes: [DraftOrderLineItem!]!
  pageInfo: PageInfo!
}

type DraftOrderLineItemEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: DraftOrderLineItem!
}

enum DraftOrderSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  NUMBER
  UPDATED_AT
  STATUS
  TOTAL_PRICE
  CUSTOMER_NAME
  ID
  RELEVANCE
}

enum DraftOrderStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  COMPLETED
  INVOICE_SENT
  OPEN
}

type Duty implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countryCodeOfOrigin: CountryCode
  harmonizedSystemCode: String
  id: ID!
  price: MoneyBag!
  taxLines: [TaxLine!]!
}

type EditableProperty
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  locked: Boolean!
  reason: FormattedString
}

interface Event
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  appTitle: String
  attributeToApp: Boolean!
  attributeToUser: Boolean!
  createdAt: DateTime!
  criticalAlert: Boolean!
  id: ID!
  message: FormattedString!
}

type EventConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [EventEdge!]!
  nodes: [Event!]!
  pageInfo: PageInfo!
}

type EventEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: Event!
}

enum EventSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  ID
  RELEVANCE
}

type FailedRequirement
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  action: NavigationItem
  message: String!
}

interface File
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  alt: String
  createdAt: DateTime!
  fileErrors: [FileError!]!
  fileStatus: FileStatus!
  preview: MediaPreviewImage
}

type FileError
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  code: FileErrorCode!
  details: String
  message: String!
}

enum FileErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  UNKNOWN
  INVALID_SIGNED_URL
  IMAGE_DOWNLOAD_FAILURE
  IMAGE_PROCESSING_FAILURE
  MEDIA_TIMEOUT_ERROR
  EXTERNAL_VIDEO_NOT_FOUND
  EXTERNAL_VIDEO_UNLISTED
  EXTERNAL_VIDEO_INVALID_ASPECT_RATIO
  EXTERNAL_VIDEO_EMBED_DISABLED
  EXTERNAL_VIDEO_EMBED_NOT_FOUND_OR_TRANSCODING
  GENERIC_FILE_DOWNLOAD_FAILURE
  GENERIC_FILE_INVALID_SIZE
  VIDEO_METADATA_READ_ERROR
  VIDEO_INVALID_FILETYPE_ERROR
  VIDEO_MIN_WIDTH_ERROR
  VIDEO_MAX_WIDTH_ERROR
  VIDEO_MIN_HEIGHT_ERROR
  VIDEO_MAX_HEIGHT_ERROR
  VIDEO_MIN_DURATION_ERROR
  VIDEO_MAX_DURATION_ERROR
  VIDEO_VALIDATION_ERROR
  MODEL3D_VALIDATION_ERROR
  MODEL3D_THUMBNAIL_GENERATION_ERROR
  MODEL3D_GLB_TO_USDZ_CONVERSION_ERROR
  MODEL3D_GLB_OUTPUT_CREATION_ERROR
  MODEL3D_PROCESSING_FAILURE
  UNSUPPORTED_IMAGE_FILE_TYPE
  INVALID_IMAGE_FILE_SIZE
  INVALID_IMAGE_ASPECT_RATIO
  INVALID_IMAGE_RESOLUTION
  FILE_STORAGE_LIMIT_EXCEEDED
}

enum FileStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  UPLOADED
  PROCESSING
  READY
  FAILED
}

type FilterOption
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  label: String!
  value: String!
}

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

type Fulfillment implements LegacyInteroperability & Node
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  createdAt: DateTime!
  deliveredAt: DateTime
  displayStatus: FulfillmentDisplayStatus
  estimatedDeliveryAt: DateTime
  events(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: FulfillmentEventSortKeys = HAPPENED_AT): FulfillmentEventConnection!
  fulfillmentLineItems(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): FulfillmentLineItemConnection!
  fulfillmentOrders(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): FulfillmentOrderConnection!
  id: ID!
  inTransitAt: DateTime
  legacyResourceId: UnsignedInt64!
  location: Location
  name: String!
  order: Order!
  originAddress: FulfillmentOriginAddress
  requiresShipping: Boolean!
  service: FulfillmentService
  status: FulfillmentStatus!
  totalQuantity: Int!
  trackingInfo(first: Int): [FulfillmentTrackingInfo!]!
  updatedAt: DateTime!
}

type FulfillmentConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [FulfillmentEdge!]!
  nodes: [Fulfillment!]!
  pageInfo: PageInfo!
}

enum FulfillmentDisplayStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ATTEMPTED_DELIVERY
  CANCELED
  CONFIRMED
  DELIVERED
  FAILURE
  FULFILLED
  IN_TRANSIT
  LABEL_PRINTED
  LABEL_PURCHASED
  LABEL_VOIDED
  MARKED_AS_FULFILLED
  NOT_DELIVERED
  OUT_FOR_DELIVERY
  READY_FOR_PICKUP
  PICKED_UP
  SUBMITTED
}

type FulfillmentEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: Fulfillment!
}

type FulfillmentEvent implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  happenedAt: DateTime!
  id: ID!
  status: FulfillmentEventStatus!
}

type FulfillmentEventConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [FulfillmentEventEdge!]!
  nodes: [FulfillmentEvent!]!
  pageInfo: PageInfo!
}

type FulfillmentEventEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: FulfillmentEvent!
}

enum FulfillmentEventSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  HAPPENED_AT
  ID
  RELEVANCE
}

enum FulfillmentEventStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  LABEL_PURCHASED
  LABEL_PRINTED
  READY_FOR_PICKUP
  CONFIRMED
  IN_TRANSIT
  OUT_FOR_DELIVERY
  ATTEMPTED_DELIVERY
  DELIVERED
  FAILURE
}

type FulfillmentHold
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  reason: FulfillmentHoldReason!
  reasonNotes: String
}

enum FulfillmentHoldReason
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  AWAITING_PAYMENT
  HIGH_RISK_OF_FRAUD
  INCORRECT_ADDRESS
  INVENTORY_OUT_OF_STOCK
  UNKNOWN_DELIVERY_DATE
  OTHER
}

type FulfillmentLineItem implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  discountedTotalSet: MoneyBag!
  id: ID!
  lineItem: LineItem!
  originalTotalSet: MoneyBag!
  quantity: Int
}

type FulfillmentLineItemConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [FulfillmentLineItemEdge!]!
  nodes: [FulfillmentLineItem!]!
  pageInfo: PageInfo!
}

type FulfillmentLineItemEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: FulfillmentLineItem!
}

type FulfillmentOrder implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  assignedLocation: FulfillmentOrderAssignedLocation!
  deliveryMethod: DeliveryMethod
  destination: FulfillmentOrderDestination
  fulfillAt: DateTime
  fulfillBy: DateTime
  fulfillmentHolds: [FulfillmentHold!]!
  fulfillments(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): FulfillmentConnection!
  id: ID!
  internationalDuties: FulfillmentOrderInternationalDuties
  lineItems(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): FulfillmentOrderLineItemConnection!
  locationsForMove(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): FulfillmentOrderLocationForMoveConnection!
  merchantRequests(kind: FulfillmentOrderMerchantRequestKind, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): FulfillmentOrderMerchantRequestConnection!
  order: Order!
  requestStatus: FulfillmentOrderRequestStatus!
  status: FulfillmentOrderStatus!
  supportedActions: [FulfillmentOrderSupportedAction!]!
}

enum FulfillmentOrderAction
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATE_FULFILLMENT
  REQUEST_FULFILLMENT
  CANCEL_FULFILLMENT_ORDER
  MOVE
  REQUEST_CANCELLATION
  MARK_AS_OPEN
  RELEASE_HOLD
  HOLD
  EXTERNAL
}

type FulfillmentOrderAssignedLocation
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address1: String
  address2: String
  city: String
  countryCode: CountryCode!
  location: Location
  name: String!
  phone: String
  province: String
  zip: String
}

enum FulfillmentOrderAssignmentStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CANCELLATION_REQUESTED
  FULFILLMENT_REQUESTED
  FULFILLMENT_ACCEPTED
}

type FulfillmentOrderConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [FulfillmentOrderEdge!]!
  nodes: [FulfillmentOrder!]!
  pageInfo: PageInfo!
}

type FulfillmentOrderDestination implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address1: String
  address2: String
  city: String
  company: String
  countryCode: CountryCode
  email: String
  firstName: String
  id: ID!
  lastName: String
  phone: String
  province: String
  zip: String
}

type FulfillmentOrderEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: FulfillmentOrder!
}

type FulfillmentOrderInternationalDuties
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  incoterm: String!
}

type FulfillmentOrderLineItem implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  lineItem: LineItem!
  remainingQuantity: Int!
  totalQuantity: Int!
  warnings: [FulfillmentOrderLineItemWarning!]!
}

type FulfillmentOrderLineItemConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [FulfillmentOrderLineItemEdge!]!
  nodes: [FulfillmentOrderLineItem!]!
  pageInfo: PageInfo!
}

type FulfillmentOrderLineItemEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: FulfillmentOrderLineItem!
}

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

type FulfillmentOrderLocationForMove
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  location: Location!
  message: String
  movable: Boolean!
}

type FulfillmentOrderLocationForMoveConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [FulfillmentOrderLocationForMoveEdge!]!
  nodes: [FulfillmentOrderLocationForMove!]!
  pageInfo: PageInfo!
}

type FulfillmentOrderLocationForMoveEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: FulfillmentOrderLocationForMove!
}

type FulfillmentOrderMerchantRequest implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  kind: FulfillmentOrderMerchantRequestKind!
  message: String
  requestOptions: JSON
  responseData: JSON
  sentAt: DateTime!
}

type FulfillmentOrderMerchantRequestConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [FulfillmentOrderMerchantRequestEdge!]!
  nodes: [FulfillmentOrderMerchantRequest!]!
  pageInfo: PageInfo!
}

type FulfillmentOrderMerchantRequestEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: FulfillmentOrderMerchantRequest!
}

enum FulfillmentOrderMerchantRequestKind
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  FULFILLMENT_REQUEST
  CANCELLATION_REQUEST
}

enum FulfillmentOrderRequestStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  UNSUBMITTED
  SUBMITTED
  ACCEPTED
  REJECTED
  CANCELLATION_REQUESTED
  CANCELLATION_ACCEPTED
  CANCELLATION_REJECTED
  CLOSED
}

enum FulfillmentOrderSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ID
  RELEVANCE
}

enum FulfillmentOrderStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  OPEN
  IN_PROGRESS
  CANCELLED
  INCOMPLETE
  CLOSED
  SCHEDULED
  ON_HOLD
}

type FulfillmentOrderSupportedAction
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  action: FulfillmentOrderAction!
  externalUrl: URL
}

type FulfillmentOriginAddress
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address1: String
  address2: String
  city: String
  countryCode: String!
  provinceCode: String
  zip: String
}

type FulfillmentService
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  callbackUrl: URL
  fulfillmentOrdersOptIn: Boolean!
  handle: String!
  id: ID!
  inventoryManagement: Boolean!
  location: Location
  permitsSkuSharing: Boolean!
  productBased: Boolean!
  serviceName: String!
  type: FulfillmentServiceType!
}

enum FulfillmentServiceType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  GIFT_CARD
  MANUAL
  THIRD_PARTY
}

enum FulfillmentStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SUCCESS
  CANCELLED
  ERROR
  FAILURE
}

type FulfillmentTrackingInfo
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  company: String
  number: String
  url: URL
}

type GenericFile implements File & Node
  @join__implements(graph: CUSTOMER, interface: "File")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "File")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  alt: String
  createdAt: DateTime!
  fileErrors: [FileError!]!
  fileStatus: FileStatus!
  id: ID!
  mimeType: String
  originalFileSize: Int
  preview: MediaPreviewImage
  url: URL
}

interface HasEvents
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  events(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: EventSortKeys = ID, query: String): EventConnection!
}

interface HasLocalizationExtensions
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  localizationExtensions(countryCodes: [CountryCode!], purposes: [LocalizationExtensionPurpose!], first: Int, after: String, last: Int, before: String, reverse: Boolean = false): LocalizationExtensionConnection!
}

interface HasMetafieldDefinitions
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  metafieldDefinitions(namespace: String, pinnedStatus: MetafieldDefinitionPinnedStatus = ANY, first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: MetafieldDefinitionSortKeys = ID, query: String): MetafieldDefinitionConnection!
}

interface HasMetafields
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  metafield(namespace: String!, key: String!): Metafield
  metafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  privateMetafield(namespace: String!, key: String!): PrivateMetafield
  privateMetafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PrivateMetafieldConnection!
}

interface HasPublishedTranslations
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  translations(locale: String!, marketId: ID): [PublishedTranslation!]!
}

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

type Image implements HasMetafields
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  altText: String
  height: Int
  id: ID
  metafield(namespace: String!, key: String!): Metafield
  metafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  privateMetafield(namespace: String!, key: String!): PrivateMetafield
  privateMetafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PrivateMetafieldConnection!
  url(transform: ImageTransformInput): URL!
  width: Int
}

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

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

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

input ImageInput
  @join__type(graph: PRODUCT)
{
  id: ID
  altText: String
  src: String
}

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

type InventoryItem implements LegacyInteroperability & Node
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countryCodeOfOrigin: CountryCode
  countryHarmonizedSystemCodes(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): CountryHarmonizedSystemCodeConnection!
  createdAt: DateTime!
  duplicateSkuCount: Int!
  harmonizedSystemCode: String
  id: ID!
  inventoryHistoryUrl: URL
  inventoryLevel(locationId: ID!): InventoryLevel
  inventoryLevels(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, query: String): InventoryLevelConnection!
  legacyResourceId: UnsignedInt64!
  locationsCount: Int!
  provinceCodeOfOrigin: String
  requiresShipping: Boolean!
  sku: String
  tracked: Boolean!
  trackedEditable: EditableProperty!
  unitCost: MoneyV2
  updatedAt: DateTime!
  variant: ProductVariant!
}

input InventoryItemInput
  @join__type(graph: PRODUCT)
{
  cost: Decimal
  tracked: Boolean
}

type InventoryLevel implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  available: Int!
  canDeactivate: Boolean!
  createdAt: DateTime!
  deactivationAlert: String
  deactivationAlertHtml: FormattedString
  id: ID!
  incoming: Int!
  item: InventoryItem!
  location: Location!
  updatedAt: DateTime!
}

type InventoryLevelConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [InventoryLevelEdge!]!
  nodes: [InventoryLevel!]!
  pageInfo: PageInfo!
}

type InventoryLevelEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: InventoryLevel!
}

input InventoryLevelInput
  @join__type(graph: PRODUCT)
{
  availableQuantity: Int!
  locationId: ID!
}

type Job
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  done: Boolean!
  id: ID!
}

scalar join__FieldSet

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

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

enum LanguageCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  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
}

interface LegacyInteroperability
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  legacyResourceId: UnsignedInt64!
}

type LimitedPendingOrderCount
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  atMax: Boolean!
  count: Int!
}

type LineItem implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  contract: SubscriptionContract
  currentQuantity: Int!
  customAttributes: [Attribute!]!
  discountAllocations: [DiscountAllocation!]!
  discountedTotalSet: MoneyBag!
  discountedUnitPriceSet: MoneyBag!
  duties: [Duty!]!
  id: ID!
  image: Image
  merchantEditable: Boolean!
  name: String!
  nonFulfillableQuantity: Int!
  originalTotalSet: MoneyBag!
  originalUnitPriceSet: MoneyBag!
  product: Product
  quantity: Int!
  refundableQuantity: Int!
  requiresShipping: Boolean!
  restockable: Boolean!
  sellingPlan: LineItemSellingPlan
  sku: String
  staffMember: StaffMember
  taxLines(first: Int): [TaxLine!]!
  taxable: Boolean!
  title: String!
  totalDiscountSet: MoneyBag!
  unfulfilledDiscountedTotalSet: MoneyBag!
  unfulfilledOriginalTotalSet: MoneyBag!
  unfulfilledQuantity: Int!
  variant: ProductVariant
  variantTitle: String
  vendor: String
}

type LineItemConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [LineItemEdge!]!
  nodes: [LineItem!]!
  pageInfo: PageInfo!
}

type LineItemEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: LineItem!
}

type LineItemSellingPlan
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  name: String!
  sellingPlanId: ID
}

type Link implements HasPublishedTranslations
  @join__implements(graph: CUSTOMER, interface: "HasPublishedTranslations")
  @join__implements(graph: PRODUCT, interface: "HasPublishedTranslations")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  label: String!
  translations(locale: String!, marketId: ID): [PublishedTranslation!]!
  url: URL!
}

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 LocalizationExtension
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countryCode: CountryCode!
  key: LocalizationExtensionKey!
  purpose: LocalizationExtensionPurpose!
  title: String!
  value: String!
}

type LocalizationExtensionConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [LocalizationExtensionEdge!]!
  nodes: [LocalizationExtension!]!
  pageInfo: PageInfo!
}

type LocalizationExtensionEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: LocalizationExtension!
}

enum LocalizationExtensionKey
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  TAX_CREDENTIAL_BR
  SHIPPING_CREDENTIAL_BR
  SHIPPING_CREDENTIAL_CN
  TAX_CREDENTIAL_IT
  TAX_EMAIL_IT
  SHIPPING_CREDENTIAL_KR
}

enum LocalizationExtensionPurpose
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SHIPPING
  TAX
}

type Location implements HasMetafieldDefinitions & HasMetafields & LegacyInteroperability & Node
  @join__implements(graph: CUSTOMER, interface: "HasMetafieldDefinitions")
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "HasMetafieldDefinitions")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  activatable: Boolean!
  address: LocationAddress!
  addressVerified: Boolean!
  deactivatable: Boolean!
  deactivatedAt: String
  deletable: Boolean!
  fulfillmentService: FulfillmentService
  fulfillsOnlineOrders: Boolean!
  hasActiveInventory: Boolean!
  hasUnfulfilledOrders: Boolean!
  id: ID!
  inventoryLevel(inventoryItemId: ID!): InventoryLevel
  inventoryLevels(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, query: String): InventoryLevelConnection!
  isActive: Boolean!
  legacyResourceId: UnsignedInt64!
  metafield(namespace: String!, key: String!): Metafield
  metafieldDefinitions(namespace: String, pinnedStatus: MetafieldDefinitionPinnedStatus = ANY, first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: MetafieldDefinitionSortKeys = ID, query: String): MetafieldDefinitionConnection!
  metafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  name: String!
  privateMetafield(namespace: String!, key: String!): PrivateMetafield
  privateMetafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PrivateMetafieldConnection!
  shipsInventory: Boolean!
  suggestedAddresses: [LocationSuggestedAddress!]!
}

type LocationAddress
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  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: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [LocationEdge!]!
  nodes: [Location!]!
  pageInfo: PageInfo!
}

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

enum LocationSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  NAME
  ID
  RELEVANCE
}

type LocationSuggestedAddress
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address1: String
  address2: String
  city: String
  country: String
  countryCode: CountryCode
  formatted: [String!]!
  province: String
  provinceCode: String
  zip: String
}

type MailingAddress implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address1: String
  address2: String
  city: String
  company: String
  coordinatesValidated: Boolean!
  country: String
  countryCodeV2: CountryCode
  firstName: String
  formattedArea: String
  id: ID!
  lastName: String
  latitude: Float
  longitude: Float
  name: String
  phone: String
  province: String
  provinceCode: String
  zip: String
}

input MailingAddressInput
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address1: String
  address2: String
  city: String
  company: String
  countryCode: CountryCode
  firstName: String
  lastName: String
  phone: String
  provinceCode: String
  zip: String
}

type ManualDiscountApplication implements DiscountApplication
  @join__implements(graph: CUSTOMER, interface: "DiscountApplication")
  @join__implements(graph: PRODUCT, interface: "DiscountApplication")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  allocationMethod: DiscountApplicationAllocationMethod!
  description: String
  index: Int!
  targetSelection: DiscountApplicationTargetSelection!
  targetType: DiscountApplicationTargetType!
  title: String!
  value: PricingValue!
}

type Market implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  currencySettings: MarketCurrencySettings!
  enabled: Boolean!
  id: ID!
  name: String!
  priceList: PriceList
  primary: Boolean!
  regions(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MarketRegionConnection!
  webPresence: MarketWebPresence
}

type MarketCurrencySettings
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  baseCurrency: CurrencySetting!
  localCurrencies: Boolean!
}

enum MarketingChannel
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SEARCH
  DISPLAY
  SOCIAL
  EMAIL
  REFERRAL
}

type MarketingEvent implements LegacyInteroperability & Node
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  app: App!
  channel: MarketingChannel
  description: String
  endedAt: DateTime
  id: ID!
  legacyResourceId: UnsignedInt64!
  manageUrl: URL
  previewUrl: URL
  remoteId: String
  scheduledToEndAt: DateTime
  sourceAndMedium: String!
  startedAt: DateTime!
  type: MarketingTactic!
  utmCampaign: String
  utmMedium: String
  utmSource: String
}

enum MarketingTactic
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ABANDONED_CART
  AD
  AFFILIATE
  LINK
  LOYALTY
  MESSAGE
  NEWSLETTER
  NOTIFICATION
  POST
  RETARGETING
  TRANSACTIONAL
  SEO
  DIRECT
  STOREFRONT_APP
}

interface MarketRegion
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  name: String!
}

type MarketRegionConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [MarketRegionEdge!]!
  nodes: [MarketRegion!]!
  pageInfo: PageInfo!
}

type MarketRegionEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: MarketRegion!
}

type MarketWebPresence implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  alternateLocales: [String!]!
  defaultLocale: String!
  domain: Domain
  id: ID!
  market: Market!
  rootUrls: [MarketWebPresenceRootUrl!]!
  subfolderSuffix: String
}

type MarketWebPresenceRootUrl
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  locale: String!
  url: URL!
}

interface Media
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  alt: String
  mediaContentType: MediaContentType!
  mediaErrors: [MediaError!]!
  mediaWarnings: [MediaWarning!]!
  preview: MediaPreviewImage
  status: MediaStatus!
}

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

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

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

type MediaError
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  code: MediaErrorCode!
  details: String
  message: String!
}

enum MediaErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  UNKNOWN
  INVALID_SIGNED_URL
  IMAGE_DOWNLOAD_FAILURE
  IMAGE_PROCESSING_FAILURE
  MEDIA_TIMEOUT_ERROR
  EXTERNAL_VIDEO_NOT_FOUND
  EXTERNAL_VIDEO_UNLISTED
  EXTERNAL_VIDEO_INVALID_ASPECT_RATIO
  EXTERNAL_VIDEO_EMBED_DISABLED
  EXTERNAL_VIDEO_EMBED_NOT_FOUND_OR_TRANSCODING
  GENERIC_FILE_DOWNLOAD_FAILURE
  GENERIC_FILE_INVALID_SIZE
  VIDEO_METADATA_READ_ERROR
  VIDEO_INVALID_FILETYPE_ERROR
  VIDEO_MIN_WIDTH_ERROR
  VIDEO_MAX_WIDTH_ERROR
  VIDEO_MIN_HEIGHT_ERROR
  VIDEO_MAX_HEIGHT_ERROR
  VIDEO_MIN_DURATION_ERROR
  VIDEO_MAX_DURATION_ERROR
  VIDEO_VALIDATION_ERROR
  MODEL3D_VALIDATION_ERROR
  MODEL3D_THUMBNAIL_GENERATION_ERROR
  MODEL3D_GLB_TO_USDZ_CONVERSION_ERROR
  MODEL3D_GLB_OUTPUT_CREATION_ERROR
  MODEL3D_PROCESSING_FAILURE
  UNSUPPORTED_IMAGE_FILE_TYPE
  INVALID_IMAGE_FILE_SIZE
  INVALID_IMAGE_ASPECT_RATIO
  INVALID_IMAGE_RESOLUTION
  FILE_STORAGE_LIMIT_EXCEEDED
}

type MediaImage implements File & Media & Node
  @join__implements(graph: CUSTOMER, interface: "File")
  @join__implements(graph: CUSTOMER, interface: "Media")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "File")
  @join__implements(graph: PRODUCT, interface: "Media")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  alt: String
  createdAt: DateTime!
  fileErrors: [FileError!]!
  fileStatus: FileStatus!
  id: ID!
  image: Image
  mediaContentType: MediaContentType!
  mediaErrors: [MediaError!]!
  mediaWarnings: [MediaWarning!]!
  mimeType: String
  originalSource: MediaImageOriginalSource
  preview: MediaPreviewImage
  status: MediaStatus!
}

type MediaImageOriginalSource
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  fileSize: Int
}

type MediaPreviewImage
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  image: Image
  status: MediaPreviewImageStatus!
}

enum MediaPreviewImageStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  UPLOADED
  PROCESSING
  READY
  FAILED
}

enum MediaStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  UPLOADED
  PROCESSING
  READY
  FAILED
}

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

enum MediaUserErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  INVALID
  BLANK
  VIDEO_VALIDATION_ERROR
  MODEL3D_VALIDATION_ERROR
  VIDEO_THROTTLE_EXCEEDED
  MODEL3D_THROTTLE_EXCEEDED
  PRODUCT_MEDIA_LIMIT_EXCEEDED
  SHOP_MEDIA_LIMIT_EXCEEDED
  PRODUCT_DOES_NOT_EXIST
  MEDIA_DOES_NOT_EXIST
  MEDIA_DOES_NOT_EXIST_ON_PRODUCT
  TOO_MANY_MEDIA_PER_INPUT_PAIR
  MAXIMUM_VARIANT_MEDIA_PAIRS_EXCEEDED
  INVALID_MEDIA_TYPE
  PRODUCT_VARIANT_SPECIFIED_MULTIPLE_TIMES
  PRODUCT_VARIANT_DOES_NOT_EXIST_ON_PRODUCT
  NON_READY_MEDIA
  PRODUCT_VARIANT_ALREADY_HAS_MEDIA
  MEDIA_IS_NOT_ATTACHED_TO_VARIANT
  MEDIA_CANNOT_BE_MODIFIED
}

type MediaWarning
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  code: MediaWarningCode!
  message: String
}

enum MediaWarningCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  MODEL_SMALL_PHYSICAL_SIZE
  MODEL_LARGE_PHYSICAL_SIZE
}

type MerchantApprovalSignals
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  identityVerified: Boolean!
  verifiedByShopify: Boolean!
}

type Metafield implements LegacyInteroperability & Node
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  createdAt: DateTime!
  definition: MetafieldDefinition
  description: String
  id: ID!
  key: String!
  legacyResourceId: UnsignedInt64!
  namespace: String!
  owner: HasMetafields!
  ownerType: MetafieldOwnerType!
  reference: MetafieldReference
  references(first: Int, after: String, last: Int, before: String): MetafieldReferenceConnection
  type: String!
  updatedAt: DateTime!
  value: String!
}

type MetafieldConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [MetafieldEdge!]!
  nodes: [Metafield!]!
  pageInfo: PageInfo!
}

type MetafieldDefinition implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  description: String
  id: ID!
  key: String!
  metafields(validationStatus: MetafieldValidationStatus = ANY, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  metafieldsCount(validationStatus: MetafieldValidationStatus): Int!
  name: String!
  namespace: String!
  ownerType: MetafieldOwnerType!
  pinnedPosition: Int
  standardTemplate: StandardMetafieldDefinitionTemplate
  type: MetafieldDefinitionType!
  validationStatus: MetafieldDefinitionValidationStatus!
  validations: [MetafieldDefinitionValidation!]!
  visibleToStorefrontApi: Boolean!
}

type MetafieldDefinitionConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [MetafieldDefinitionEdge!]!
  nodes: [MetafieldDefinition!]!
  pageInfo: PageInfo!
}

type MetafieldDefinitionEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: MetafieldDefinition!
}

enum MetafieldDefinitionPinnedStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ANY
  PINNED
  UNPINNED
}

enum MetafieldDefinitionSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ID
  NAME
  PINNED_POSITION
  RELEVANCE
}

type MetafieldDefinitionSupportedValidation
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  name: String!
  type: String!
}

type MetafieldDefinitionType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  category: String!
  name: String!
  supportedValidations: [MetafieldDefinitionSupportedValidation!]!
  supportsDefinitionMigrations: Boolean!
}

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

enum MetafieldDefinitionValidationStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ALL_VALID
  IN_PROGRESS
  SOME_INVALID
}

type MetafieldEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: Metafield!
}

input MetafieldInput
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  description: String
  id: ID
  namespace: String
  key: String
  value: String
  type: String
}

enum MetafieldOwnerType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  API_PERMISSION
  ARTICLE
  BLOG
  COLLECTION
  CUSTOMER
  DISCOUNT
  DRAFTORDER
  LOCATION
  ORDER
  PAGE
  PRODUCT
  PRODUCTIMAGE
  PRODUCTVARIANT
  SHOP
}

union MetafieldReference
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = Collection | GenericFile | MediaImage | OnlineStorePage | Product | ProductVariant | Video

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
}

enum MetafieldValidationStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ANY
  VALID
  INVALID
}

enum MethodDefinitionSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  RATE_PROVIDER_TYPE
  ID
  RELEVANCE
}

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

type MoneyBag
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  presentmentMoney: MoneyV2!
  shopMoney: MoneyV2!
}

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

input MoveInput
  @join__type(graph: PRODUCT)
{
  id: ID!
  newPosition: UnsignedInt64!
}

type Mutation
  @inContext
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  customerCreate(input: CustomerInput!): CustomerCreatePayload @join__field(graph: CUSTOMER)
  productAppendImages(input: ProductAppendImagesInput!): ProductAppendImagesPayload @join__field(graph: PRODUCT)
  productChangeStatus(productId: ID!, status: ProductStatus!): ProductChangeStatusPayload @join__field(graph: PRODUCT)
  productCreate(input: ProductInput!, media: [CreateMediaInput!]): ProductCreatePayload @join__field(graph: PRODUCT)
  productCreateMedia(productId: ID!, media: [CreateMediaInput!]!): ProductCreateMediaPayload @join__field(graph: PRODUCT)
  productDelete(input: ProductDeleteInput!): ProductDeletePayload @join__field(graph: PRODUCT)
  productDeleteImages(id: ID!, imageIds: [ID!]!): ProductDeleteImagesPayload @join__field(graph: PRODUCT)
  productDeleteMedia(productId: ID!, mediaIds: [ID!]!): ProductDeleteMediaPayload @join__field(graph: PRODUCT)
  productDuplicate(productId: ID!, newTitle: String!, newStatus: ProductStatus, includeImages: Boolean = false): ProductDuplicatePayload @join__field(graph: PRODUCT)
  productImageUpdate(productId: ID!, image: ImageInput!): ProductImageUpdatePayload @join__field(graph: PRODUCT)
  productJoinSellingPlanGroups(id: ID!, sellingPlanGroupIds: [ID!]!): ProductJoinSellingPlanGroupsPayload @join__field(graph: PRODUCT)
  productLeaveSellingPlanGroups(id: ID!, sellingPlanGroupIds: [ID!]!): ProductLeaveSellingPlanGroupsPayload @join__field(graph: PRODUCT)
  productReorderImages(id: ID!, moves: [MoveInput!]!): ProductReorderImagesPayload @join__field(graph: PRODUCT)
  productReorderMedia(id: ID!, moves: [MoveInput!]!): ProductReorderMediaPayload @join__field(graph: PRODUCT)
  productUpdate(input: ProductInput!): ProductUpdatePayload @join__field(graph: PRODUCT)
  productUpdateMedia(productId: ID!, media: [UpdateMediaInput!]!): ProductUpdateMediaPayload @join__field(graph: PRODUCT)
  productVariantAppendMedia(productId: ID!, variantMedia: [ProductVariantAppendMediaInput!]!): ProductVariantAppendMediaPayload @join__field(graph: PRODUCT)
  productVariantCreate(input: ProductVariantInput!): ProductVariantCreatePayload @join__field(graph: PRODUCT)
  productVariantDelete(id: ID!): ProductVariantDeletePayload @join__field(graph: PRODUCT)
  productVariantDetachMedia(productId: ID!, variantMedia: [ProductVariantDetachMediaInput!]!): ProductVariantDetachMediaPayload @join__field(graph: PRODUCT)
  productVariantJoinSellingPlanGroups(id: ID!, sellingPlanGroupIds: [ID!]!): ProductVariantJoinSellingPlanGroupsPayload @join__field(graph: PRODUCT)
  productVariantLeaveSellingPlanGroups(id: ID!, sellingPlanGroupIds: [ID!]!): ProductVariantLeaveSellingPlanGroupsPayload @join__field(graph: PRODUCT)
  productVariantUpdate(input: ProductVariantInput!): ProductVariantUpdatePayload @join__field(graph: PRODUCT)
  productVariantsBulkCreate(variants: [ProductVariantsBulkInput!]!, productId: ID!): ProductVariantsBulkCreatePayload @join__field(graph: PRODUCT)
  productVariantsBulkDelete(variantsIds: [ID!]!, productId: ID!): ProductVariantsBulkDeletePayload @join__field(graph: PRODUCT)
  productVariantsBulkReorder(productId: ID!, positions: [ProductVariantPositionInput!]!): ProductVariantsBulkReorderPayload @join__field(graph: PRODUCT)
  productVariantsBulkUpdate(variants: [ProductVariantsBulkInput!]!, productId: ID!): ProductVariantsBulkUpdatePayload @join__field(graph: PRODUCT)
}

interface Navigable
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  defaultCursor: String!
}

type NavigationItem
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: String!
  title: String!
  url: URL!
}

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

type OnlineStorePage implements HasPublishedTranslations & Navigable & Node
  @join__implements(graph: CUSTOMER, interface: "HasPublishedTranslations")
  @join__implements(graph: CUSTOMER, interface: "Navigable")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "HasPublishedTranslations")
  @join__implements(graph: PRODUCT, interface: "Navigable")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  defaultCursor: String!
  id: ID!
  translations(locale: String!, marketId: ID): [PublishedTranslation!]!
}

interface OnlineStorePreviewable
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  onlineStorePreviewUrl: URL
}

type Order implements CommentEventSubject & HasEvents & HasLocalizationExtensions & HasMetafieldDefinitions & HasMetafields & LegacyInteroperability & Node
  @join__implements(graph: CUSTOMER, interface: "CommentEventSubject")
  @join__implements(graph: CUSTOMER, interface: "HasEvents")
  @join__implements(graph: CUSTOMER, interface: "HasLocalizationExtensions")
  @join__implements(graph: CUSTOMER, interface: "HasMetafieldDefinitions")
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "CommentEventSubject")
  @join__implements(graph: PRODUCT, interface: "HasEvents")
  @join__implements(graph: PRODUCT, interface: "HasLocalizationExtensions")
  @join__implements(graph: PRODUCT, interface: "HasMetafieldDefinitions")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  agreements(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, query: String): SalesAgreementConnection!
  alerts: [ResourceAlert!]!
  app: OrderApp
  billingAddress: MailingAddress
  billingAddressMatchesShippingAddress: Boolean!
  canMarkAsPaid: Boolean!
  canNotifyCustomer: Boolean!
  cancelReason: OrderCancelReason
  cancelledAt: DateTime
  capturable: Boolean!
  cartDiscountAmountSet: MoneyBag
  channelInformation: ChannelInformation
  clientIp: String
  closed: Boolean!
  closedAt: DateTime
  confirmed: Boolean!
  createdAt: DateTime!
  currencyCode: CurrencyCode!
  currentCartDiscountAmountSet: MoneyBag!
  currentSubtotalLineItemsQuantity: Int!
  currentSubtotalPriceSet: MoneyBag!
  currentTaxLines: [TaxLine!]!
  currentTotalDiscountsSet: MoneyBag!
  currentTotalDutiesSet: MoneyBag
  currentTotalPriceSet: MoneyBag!
  currentTotalTaxSet: MoneyBag!
  currentTotalWeight: UnsignedInt64!
  customAttributes: [Attribute!]!
  customer: Customer
  customerAcceptsMarketing: Boolean!
  customerJourneySummary: CustomerJourneySummary
  customerLocale: String
  discountApplications(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): DiscountApplicationConnection!
  discountCode: String
  discountCodes: [String!]!
  displayAddress: MailingAddress
  displayFinancialStatus: OrderDisplayFinancialStatus
  displayFulfillmentStatus: OrderDisplayFulfillmentStatus!
  disputes: [OrderDisputeSummary!]!
  edited: Boolean!
  email: String
  estimatedTaxes: Boolean!
  events(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: EventSortKeys = ID, query: String): EventConnection!
  fulfillable: Boolean!
  fulfillmentOrders(displayable: Boolean = false, first: Int, after: String, last: Int, before: String, reverse: Boolean = false, query: String): FulfillmentOrderConnection!
  fulfillments(first: Int): [Fulfillment!]!
  fullyPaid: Boolean!
  hasTimelineComment: Boolean!
  id: ID!
  legacyResourceId: UnsignedInt64!
  lineItems(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): LineItemConnection!
  localizationExtensions(countryCodes: [CountryCode!], purposes: [LocalizationExtensionPurpose!], first: Int, after: String, last: Int, before: String, reverse: Boolean = false): LocalizationExtensionConnection!
  merchantEditable: Boolean!
  merchantEditableErrors: [String!]!
  merchantOfRecordApp: OrderApp
  metafield(namespace: String!, key: String!): Metafield
  metafieldDefinitions(namespace: String, pinnedStatus: MetafieldDefinitionPinnedStatus = ANY, first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: MetafieldDefinitionSortKeys = ID, query: String): MetafieldDefinitionConnection!
  metafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  name: String!
  netPaymentSet: MoneyBag!
  nonFulfillableLineItems(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): LineItemConnection!
  note: String
  originalTotalDutiesSet: MoneyBag
  originalTotalPriceSet: MoneyBag!
  paymentCollectionDetails: OrderPaymentCollectionDetails!
  paymentGatewayNames: [String!]!
  paymentTerms: PaymentTerms
  phone: String
  physicalLocation: Location
  presentmentCurrencyCode: CurrencyCode!
  privateMetafield(namespace: String!, key: String!): PrivateMetafield
  privateMetafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PrivateMetafieldConnection!
  processedAt: DateTime!
  publication: Publication
  purchasingEntity: PurchasingEntity
  refundDiscrepancySet: MoneyBag!
  refundable: Boolean!
  refunds(first: Int): [Refund!]!
  registeredSourceUrl: URL
  requiresShipping: Boolean!
  restockable: Boolean!
  riskLevel: OrderRiskLevel!
  risks(first: Int): [OrderRisk!]!
  shippingAddress: MailingAddress
  shippingLine: ShippingLine
  shippingLines(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ShippingLineConnection!
  sourceIdentifier: String
  subtotalLineItemsQuantity: Int!
  subtotalPriceSet: MoneyBag
  suggestedRefund(shippingAmount: Money, refundShipping: Boolean, refundLineItems: [RefundLineItemInput!], refundDuties: [RefundDutyInput!], suggestFullRefund: Boolean = false): SuggestedRefund
  tags: [String!]!
  taxLines: [TaxLine!]!
  taxesIncluded: Boolean!
  test: Boolean!
  totalCapturableSet: MoneyBag!
  totalDiscountsSet: MoneyBag
  totalOutstandingSet: MoneyBag!
  totalPriceSet: MoneyBag!
  totalReceivedSet: MoneyBag!
  totalRefundedSet: MoneyBag!
  totalRefundedShippingSet: MoneyBag!
  totalShippingPriceSet: MoneyBag!
  totalTaxSet: MoneyBag
  totalTipReceivedSet: MoneyBag!
  totalWeight: UnsignedInt64
  transactions(first: Int, capturable: Boolean, manuallyResolvable: Boolean): [OrderTransaction!]!
  unpaid: Boolean!
  updatedAt: DateTime!
}

enum OrderActionType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ORDER
  ORDER_EDIT
  REFUND
  UNKNOWN
}

type OrderApp
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  icon: Image!
  id: ID!
  name: String!
}

enum OrderCancelReason
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CUSTOMER
  FRAUD
  INVENTORY
  DECLINED
  OTHER
}

type OrderConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [OrderEdge!]!
  nodes: [Order!]!
  pageInfo: PageInfo!
}

enum OrderDisplayFinancialStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PENDING
  AUTHORIZED
  PARTIALLY_PAID
  PARTIALLY_REFUNDED
  VOIDED
  PAID
  REFUNDED
  EXPIRED
}

enum OrderDisplayFulfillmentStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  UNFULFILLED
  PARTIALLY_FULFILLED
  FULFILLED
  RESTOCKED
  PENDING_FULFILLMENT
  OPEN
  IN_PROGRESS
  ON_HOLD
  SCHEDULED
}

type OrderDisputeSummary implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  initiatedAs: DisputeType!
  status: DisputeStatus!
}

type OrderEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: Order!
}

type OrderPaymentCollectionDetails
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  additionalPaymentCollectionUrl: URL
  vaultedPaymentMethods: [PaymentMandate!]
}

type OrderRisk
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  display: Boolean!
  level: OrderRiskLevel
  message: String
}

enum OrderRiskLevel
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  LOW
  MEDIUM
  HIGH
}

enum OrderSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CREATED_AT
  CUSTOMER_NAME
  FINANCIAL_STATUS
  FULFILLMENT_STATUS
  ORDER_NUMBER
  PROCESSED_AT
  TOTAL_PRICE
  UPDATED_AT
  ID
  RELEVANCE
}

type OrderTransaction implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  accountNumber: String
  amountSet: MoneyBag!
  authorizationCode: String
  authorizationExpiresAt: DateTime
  createdAt: DateTime!
  errorCode: OrderTransactionErrorCode
  fees: [TransactionFee!]!
  formattedGateway: String
  gateway: String
  id: ID!
  kind: OrderTransactionKind!
  manuallyCapturable: Boolean!
  maximumRefundableV2: MoneyV2
  order: Order
  parentTransaction: OrderTransaction
  paymentIcon: Image
  processedAt: DateTime
  receiptJson: JSON
  settlementCurrency: CurrencyCode
  settlementCurrencyRate: Decimal
  shopifyPaymentsSet: ShopifyPaymentsTransactionSet
  status: OrderTransactionStatus!
  test: Boolean!
  totalUnsettledSet: MoneyBag
  user: StaffMember
}

type OrderTransactionConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [OrderTransactionEdge!]!
  nodes: [OrderTransaction!]!
  pageInfo: PageInfo!
}

type OrderTransactionEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: OrderTransaction!
}

enum OrderTransactionErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  INCORRECT_NUMBER
  INVALID_NUMBER
  INVALID_EXPIRY_DATE
  INVALID_CVC
  EXPIRED_CARD
  INCORRECT_CVC
  INCORRECT_ZIP
  INCORRECT_ADDRESS
  INCORRECT_PIN
  CARD_DECLINED
  PROCESSING_ERROR
  CALL_ISSUER
  PICK_UP_CARD
  CONFIG_ERROR
  TEST_MODE_LIVE_CARD
  UNSUPPORTED_FEATURE
  GENERIC_ERROR
  INVALID_COUNTRY
  INVALID_AMOUNT
  PAYMENT_METHOD_UNAVAILABLE
  AMAZON_PAYMENTS_INVALID_PAYMENT_METHOD
  AMAZON_PAYMENTS_MAX_AMOUNT_CHARGED
  AMAZON_PAYMENTS_MAX_AMOUNT_REFUNDED
  AMAZON_PAYMENTS_MAX_AUTHORIZATIONS_CAPTURED
  AMAZON_PAYMENTS_MAX_REFUNDS_PROCESSED
  AMAZON_PAYMENTS_ORDER_REFERENCE_CANCELED
  AMAZON_PAYMENTS_STALE
}

enum OrderTransactionKind
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SALE
  CAPTURE
  AUTHORIZATION
  VOID
  REFUND
  CHANGE
  EMV_AUTHORIZATION
  SUGGESTED_REFUND
}

enum OrderTransactionStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SUCCESS
  FAILURE
  PENDING
  ERROR
  AWAITING_RESPONSE
  UNKNOWN
}

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

union PaymentInstrument
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = VaultCreditCard | VaultPaypalBillingAgreement

type PaymentMandate implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  paymentInstrument: PaymentInstrument!
}

type PaymentSchedule implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amount: MoneyV2!
  completedAt: DateTime
  dueAt: DateTime
  id: ID!
  issuedAt: DateTime
}

type PaymentScheduleConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [PaymentScheduleEdge!]!
  nodes: [PaymentSchedule!]!
  pageInfo: PageInfo!
}

type PaymentScheduleEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: PaymentSchedule!
}

type PaymentSettings
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  supportedDigitalWallets: [DigitalWallet!]!
}

type PaymentTerms implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  dueInDays: Int
  id: ID!
  overdue: Boolean!
  paymentSchedules(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PaymentScheduleConnection!
  paymentTermsName: String!
  paymentTermsType: PaymentTermsType!
  translatedName: String!
}

type PaymentTermsTemplate implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  description: String!
  dueInDays: Int
  id: ID!
  name: String!
  paymentTermsType: PaymentTermsType!
  translatedName: String!
}

enum PaymentTermsType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  RECEIPT
  NET
  FIXED
  UNKNOWN
}

enum PaypalExpressSubscriptionsGatewayStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ENABLED
  DISABLED
  PENDING
}

type PriceList implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  contextRule: PriceListContextRule
  currency: CurrencyCode!
  id: ID!
  name: String!
  parent: PriceListParent
  prices(originType: PriceListPriceOriginType, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PriceListPriceConnection!
}

type PriceListAdjustment
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  type: PriceListAdjustmentType!
  value: Float!
}

enum PriceListAdjustmentType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PERCENTAGE_DECREASE
  PERCENTAGE_INCREASE
}

type PriceListContextRule
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  countries: [CountryCode!]!
  market: Market
}

type PriceListParent
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  adjustment: PriceListAdjustment!
}

type PriceListPrice
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  compareAtPrice: MoneyV2
  originType: PriceListPriceOriginType!
  price: MoneyV2!
  variant: ProductVariant!
}

type PriceListPriceConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [PriceListPriceEdge!]!
  nodes: [PriceListPrice!]!
  pageInfo: PageInfo!
}

type PriceListPriceEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: PriceListPrice!
}

enum PriceListPriceOriginType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  FIXED
  RELATIVE
}

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

union PricingValue
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = MoneyV2 | PricingPercentageValue

type PrivateMetafield implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  createdAt: DateTime!
  id: ID!
  key: String!
  namespace: String!
  updatedAt: DateTime!
  value: String!
  valueType: PrivateMetafieldValueType!
}

type PrivateMetafieldConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [PrivateMetafieldEdge!]!
  nodes: [PrivateMetafield!]!
  pageInfo: PageInfo!
}

type PrivateMetafieldEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: PrivateMetafield!
}

input PrivateMetafieldInput
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  owner: ID
  namespace: String!
  key: String!
  valueInput: PrivateMetafieldValueInput!
}

input PrivateMetafieldValueInput
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  value: String!
  valueType: PrivateMetafieldValueType!
}

enum PrivateMetafieldValueType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  STRING
  INTEGER
  JSON_STRING
}

type Product implements HasMetafieldDefinitions & HasMetafields & HasPublishedTranslations & LegacyInteroperability & Navigable & Node & OnlineStorePreviewable & Publishable
  @join__implements(graph: CUSTOMER, interface: "HasMetafieldDefinitions")
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: CUSTOMER, interface: "HasPublishedTranslations")
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Navigable")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: CUSTOMER, interface: "OnlineStorePreviewable")
  @join__implements(graph: CUSTOMER, interface: "Publishable")
  @join__implements(graph: PRODUCT, interface: "HasMetafieldDefinitions")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "HasPublishedTranslations")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Navigable")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "OnlineStorePreviewable")
  @join__implements(graph: PRODUCT, interface: "Publishable")
  @join__type(graph: CUSTOMER, key: "id")
  @join__type(graph: PRODUCT, key: "id")
{
  availablePublicationCount: Int!
  collections(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: CollectionSortKeys = ID, query: String): CollectionConnection!
  contextualPricing(context: ContextualPricingContext!): ProductContextualPricing!
  createdAt: DateTime!
  defaultCursor: String!
  description(truncateAt: Int): String!
  descriptionHtml: HTML!
  featuredImage: Image
  featuredMedia: Media
  feedback: ResourceFeedback
  giftCardTemplateSuffix: String
  handle: String!
  hasOnlyDefaultVariant: Boolean!
  hasOutOfStockVariants: Boolean!
  id: ID!
  images(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: ProductImageSortKeys = POSITION): ImageConnection!
  inCollection(id: ID!): Boolean!
  isGiftCard: Boolean!
  legacyResourceId: UnsignedInt64!
  media(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: ProductMediaSortKeys = POSITION): MediaConnection!
  mediaCount: Int!
  metafield(namespace: String!, key: String!): Metafield
  metafieldDefinitions(namespace: String, pinnedStatus: MetafieldDefinitionPinnedStatus = ANY, first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: MetafieldDefinitionSortKeys = ID, query: String): MetafieldDefinitionConnection!
  metafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  onlineStorePreviewUrl: URL
  onlineStoreUrl: URL
  options(first: Int): [ProductOption!]!
  priceRangeV2: ProductPriceRangeV2!
  privateMetafield(namespace: String!, key: String!): PrivateMetafield
  privateMetafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PrivateMetafieldConnection!
  productCategory: ProductCategory
  productType: String!
  publicationCount(onlyPublished: Boolean = true): Int!
  publishedAt: DateTime
  publishedOnCurrentPublication: Boolean!
  publishedOnPublication(publicationId: ID!): Boolean!
  requiresSellingPlan: Boolean!
  resourcePublicationOnCurrentPublication: ResourcePublicationV2
  resourcePublications(onlyPublished: Boolean = true, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ResourcePublicationConnection!
  resourcePublicationsV2(onlyPublished: Boolean = true, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ResourcePublicationV2Connection!
  sellingPlanGroupCount: Int!
  sellingPlanGroups(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SellingPlanGroupConnection!
  seo: SEO!
  status: ProductStatus!
  tags: [String!]!
  templateSuffix: String
  title: String!
  totalInventory: Int!
  totalVariants: Int!
  tracksInventory: Boolean!
  translations(locale: String!, marketId: ID): [PublishedTranslation!]!
  unpublishedPublications(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PublicationConnection!
  updatedAt: DateTime!
  variants(first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: ProductVariantSortKeys = POSITION): ProductVariantConnection!
  vendor: String!
}

input ProductAppendImagesInput
  @join__type(graph: PRODUCT)
{
  id: ID!
  images: [ImageInput!]!
}

type ProductAppendImagesPayload
  @join__type(graph: PRODUCT)
{
  newImages: [Image!]
  product: Product
  userErrors: [UserError!]!
}

type ProductCategory
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  productTaxonomyNode: ProductTaxonomyNode
}

input ProductCategoryInput
  @join__type(graph: PRODUCT)
{
  productTaxonomyNodeId: ID!
}

type ProductChangeStatusPayload
  @join__type(graph: PRODUCT)
{
  product: Product
  userErrors: [ProductChangeStatusUserError!]!
}

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

enum ProductChangeStatusUserErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PRODUCT_NOT_FOUND
}

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

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

type ProductContextualPricing
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  maxVariantPricing: ProductVariantContextualPricing
  minVariantPricing: ProductVariantContextualPricing
  priceRange: ProductPriceRangeV2!
}

type ProductCreateMediaPayload
  @join__type(graph: PRODUCT)
{
  media: [Media!]
  mediaUserErrors: [MediaUserError!]!
  product: Product
}

type ProductCreatePayload
  @join__type(graph: PRODUCT)
{
  product: Product
  shop: Shop!
  userErrors: [UserError!]!
}

type ProductDeleteImagesPayload
  @join__type(graph: PRODUCT)
{
  deletedImageIds: [ID!]!
  product: Product
  userErrors: [UserError!]!
}

input ProductDeleteInput
  @join__type(graph: PRODUCT)
{
  id: ID!
}

type ProductDeleteMediaPayload
  @join__type(graph: PRODUCT)
{
  deletedMediaIds: [ID!]
  deletedProductImageIds: [ID!]
  mediaUserErrors: [MediaUserError!]!
  product: Product
}

type ProductDeletePayload
  @join__type(graph: PRODUCT)
{
  deletedProductId: ID
  shop: Shop!
  userErrors: [UserError!]!
}

type ProductDuplicatePayload
  @join__type(graph: PRODUCT)
{
  imageJob: Job
  newProduct: Product
  shop: Shop!
  userErrors: [UserError!]!
}

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

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

type ProductImageUpdatePayload
  @join__type(graph: PRODUCT)
{
  image: Image
  userErrors: [UserError!]!
}

input ProductInput
  @join__type(graph: PRODUCT)
{
  descriptionHtml: String
  redirectNewHandle: Boolean
  handle: String
  seo: SEOInput
  productType: String
  standardizedProductType: StandardizedProductTypeInput
  productCategory: ProductCategoryInput
  customProductType: String
  tags: [String!]
  templateSuffix: String
  giftCard: Boolean
  giftCardTemplateSuffix: String
  title: String
  vendor: String
  collectionsToJoin: [ID!]
  collectionsToLeave: [ID!]
  id: ID
  images: [ImageInput!]
  metafields: [MetafieldInput!]
  privateMetafields: [PrivateMetafieldInput!]
  options: [String!]
  variants: [ProductVariantInput!]
  status: ProductStatus
  requiresSellingPlan: Boolean
}

type ProductJoinSellingPlanGroupsPayload
  @join__type(graph: PRODUCT)
{
  product: Product
  userErrors: [SellingPlanGroupUserError!]!
}

type ProductLeaveSellingPlanGroupsPayload
  @join__type(graph: PRODUCT)
{
  product: Product
  userErrors: [SellingPlanGroupUserError!]!
}

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

type ProductOption implements HasPublishedTranslations & Node
  @join__implements(graph: CUSTOMER, interface: "HasPublishedTranslations")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "HasPublishedTranslations")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  name: String!
  position: Int!
  translations(locale: String!, marketId: ID): [PublishedTranslation!]!
  values: [String!]!
}

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

type ProductReorderImagesPayload
  @join__type(graph: PRODUCT)
{
  job: Job
  userErrors: [UserError!]!
}

type ProductReorderMediaPayload
  @join__type(graph: PRODUCT)
{
  job: Job
  mediaUserErrors: [MediaUserError!]!
}

type ProductResourceFeedback
  @join__type(graph: PRODUCT)
{
  feedbackGeneratedAt: DateTime!
  messages: [String!]!
  productId: ID!
  productUpdatedAt: DateTime!
  state: ResourceFeedbackState!
}

enum ProductSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  TITLE
  PRODUCT_TYPE
  VENDOR
  INVENTORY_TOTAL
  UPDATED_AT
  CREATED_AT
  PUBLISHED_AT
  ID
  RELEVANCE
}

enum ProductStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ACTIVE
  ARCHIVED
  DRAFT
}

type ProductTaxonomyNode implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  fullName: String!
  id: ID!
  isLeaf: Boolean!
  isRoot: Boolean!
  name: String!
}

type ProductUpdateMediaPayload
  @join__type(graph: PRODUCT)
{
  media: [Media!]
  mediaUserErrors: [MediaUserError!]!
  product: Product
}

type ProductUpdatePayload
  @join__type(graph: PRODUCT)
{
  product: Product
  userErrors: [UserError!]!
}

type ProductVariant implements HasMetafieldDefinitions & HasMetafields & HasPublishedTranslations & LegacyInteroperability & Navigable & Node
  @join__implements(graph: CUSTOMER, interface: "HasMetafieldDefinitions")
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: CUSTOMER, interface: "HasPublishedTranslations")
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Navigable")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "HasMetafieldDefinitions")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "HasPublishedTranslations")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Navigable")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  availableForSale: Boolean!
  barcode: String
  compareAtPrice: Money
  contextualPricing(context: ContextualPricingContext!): ProductVariantContextualPricing!
  createdAt: DateTime!
  defaultCursor: String!
  deliveryProfile: DeliveryProfile
  displayName: String!
  fulfillmentServiceEditable: EditableProperty!
  id: ID!
  image: Image
  inventoryItem: InventoryItem!
  inventoryPolicy: ProductVariantInventoryPolicy!
  inventoryQuantity: Int
  legacyResourceId: UnsignedInt64!
  media(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MediaConnection!
  metafield(namespace: String!, key: String!): Metafield
  metafieldDefinitions(namespace: String, pinnedStatus: MetafieldDefinitionPinnedStatus = ANY, first: Int, after: String, last: Int, before: String, reverse: Boolean = false, sortKey: MetafieldDefinitionSortKeys = ID, query: String): MetafieldDefinitionConnection!
  metafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): MetafieldConnection!
  position: Int!
  price: Money!
  privateMetafield(namespace: String!, key: String!): PrivateMetafield
  privateMetafields(namespace: String, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PrivateMetafieldConnection!
  product: Product!
  selectedOptions: [SelectedOption!]!
  sellableOnlineQuantity: Int!
  sellingPlanGroupCount: Int!
  sellingPlanGroups(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SellingPlanGroupConnection!
  sku: String
  taxCode: String
  taxable: Boolean!
  title: String!
  translations(locale: String!, marketId: ID): [PublishedTranslation!]!
  updatedAt: DateTime!
  weight: Float
  weightUnit: WeightUnit!
}

input ProductVariantAppendMediaInput
  @join__type(graph: PRODUCT)
{
  variantId: ID!
  mediaIds: [ID!]!
}

type ProductVariantAppendMediaPayload
  @join__type(graph: PRODUCT)
{
  product: Product
  productVariants: [ProductVariant!]
  userErrors: [MediaUserError!]!
}

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

type ProductVariantContextualPricing
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  compareAtPrice: MoneyV2
  price: MoneyV2!
}

type ProductVariantCreatePayload
  @join__type(graph: PRODUCT)
{
  product: Product
  productVariant: ProductVariant
  userErrors: [UserError!]!
}

type ProductVariantDeletePayload
  @join__type(graph: PRODUCT)
{
  deletedProductVariantId: ID
  product: Product
  userErrors: [UserError!]!
}

input ProductVariantDetachMediaInput
  @join__type(graph: PRODUCT)
{
  variantId: ID!
  mediaIds: [ID!]!
}

type ProductVariantDetachMediaPayload
  @join__type(graph: PRODUCT)
{
  product: Product
  productVariants: [ProductVariant!]
  userErrors: [MediaUserError!]!
}

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

input ProductVariantInput
  @join__type(graph: PRODUCT)
{
  barcode: String
  compareAtPrice: Money
  harmonizedSystemCode: String
  id: ID
  imageId: ID
  imageSrc: String
  mediaSrc: [String!]
  inventoryPolicy: ProductVariantInventoryPolicy
  inventoryQuantities: [InventoryLevelInput!]
  inventoryItem: InventoryItemInput
  metafields: [MetafieldInput!]
  privateMetafields: [PrivateMetafieldInput!]
  options: [String!]
  position: Int
  price: Money
  productId: ID
  requiresShipping: Boolean
  sku: String
  taxable: Boolean
  taxCode: String
  weight: Float
  weightUnit: WeightUnit
}

enum ProductVariantInventoryPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  DENY
  CONTINUE
}

type ProductVariantJoinSellingPlanGroupsPayload
  @join__type(graph: PRODUCT)
{
  productVariant: ProductVariant
  userErrors: [SellingPlanGroupUserError!]!
}

type ProductVariantLeaveSellingPlanGroupsPayload
  @join__type(graph: PRODUCT)
{
  productVariant: ProductVariant
  userErrors: [SellingPlanGroupUserError!]!
}

input ProductVariantPositionInput
  @join__type(graph: PRODUCT)
{
  id: ID!
  position: Int!
}

type ProductVariantsBulkCreatePayload
  @join__type(graph: PRODUCT)
{
  product: Product
  productVariants: [ProductVariant!]
  userErrors: [ProductVariantsBulkCreateUserError!]!
}

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

enum ProductVariantsBulkCreateUserErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PRODUCT_DOES_NOT_EXIST
  NO_KEY_ON_CREATE
  VARIANT_ALREADY_EXISTS
  GREATER_THAN_OR_EQUAL_TO
  NEED_TO_ADD_OPTION_VALUES
  OPTION_VALUES_FOR_NUMBER_OF_UNKNOWN_OPTIONS
  TOO_MANY_INVENTORY_LOCATIONS
  SUBSCRIPTION_VIOLATION
  VARIANT_ALREADY_EXISTS_CHANGE_OPTION_VALUE
  TRACKED_VARIANT_LOCATION_NOT_FOUND
  MUST_BE_FOR_THIS_PRODUCT
  NOT_DEFINED_FOR_SHOP
  INVALID
  NEGATIVE_PRICE_VALUE
}

type ProductVariantsBulkDeletePayload
  @join__type(graph: PRODUCT)
{
  product: Product
  userErrors: [ProductVariantsBulkDeleteUserError!]!
}

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

enum ProductVariantsBulkDeleteUserErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PRODUCT_DOES_NOT_EXIST
  CANNOT_DELETE_LAST_VARIANT
  AT_LEAST_ONE_VARIANT_DOES_NOT_BELONG_TO_THE_PRODUCT
}

input ProductVariantsBulkInput
  @join__type(graph: PRODUCT)
{
  barcode: String
  compareAtPrice: Money
  harmonizedSystemCode: String
  id: ID
  imageId: ID
  imageSrc: String
  mediaSrc: [String!]
  inventoryPolicy: ProductVariantInventoryPolicy
  inventoryQuantities: [InventoryLevelInput!]
  inventoryItem: InventoryItemInput
  metafields: [MetafieldInput!]
  privateMetafields: [PrivateMetafieldInput!]
  options: [String!]
  price: Money
  requiresShipping: Boolean
  sku: String
  taxable: Boolean
  taxCode: String
  weight: Float
  weightUnit: WeightUnit
}

type ProductVariantsBulkReorderPayload
  @join__type(graph: PRODUCT)
{
  product: Product
  userErrors: [ProductVariantsBulkReorderUserError!]!
}

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

enum ProductVariantsBulkReorderUserErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PRODUCT_DOES_NOT_EXIST
  MISSING_VARIANT
  INVALID_POSITION
  DUPLICATED_VARIANT_ID
}

type ProductVariantsBulkUpdatePayload
  @join__type(graph: PRODUCT)
{
  product: Product
  productVariants: [ProductVariant!]
  userErrors: [ProductVariantsBulkUpdateUserError!]!
}

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

enum ProductVariantsBulkUpdateUserErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PRODUCT_DOES_NOT_EXIST
  PRODUCT_VARIANT_ID_MISSING
  PRODUCT_VARIANT_DOES_NOT_EXIST
  NO_INVENTORY_QUANTITIES_ON_VARIANTS_UPDATE
  VARIANT_ALREADY_EXISTS
  GREATER_THAN_OR_EQUAL_TO
  NEED_TO_ADD_OPTION_VALUES
  OPTION_VALUES_FOR_NUMBER_OF_UNKNOWN_OPTIONS
  SUBSCRIPTION_VIOLATION
  NO_INVENTORY_QUANTITES_DURING_UPDATE
  NEGATIVE_PRICE_VALUE
}

enum ProductVariantSortKeys
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  TITLE
  NAME
  SKU
  INVENTORY_QUANTITY
  INVENTORY_MANAGEMENT
  INVENTORY_LEVELS_AVAILABLE
  INVENTORY_POLICY
  FULL_TITLE
  POPULAR
  POSITION
  ID
  RELEVANCE
}

type ProductVariantUpdatePayload
  @join__type(graph: PRODUCT)
{
  product: Product
  productVariant: ProductVariant
  userErrors: [UserError!]!
}

type Publication implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  app: App!
  collectionPublicationsV3(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ResourcePublicationConnection!
  collections(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): CollectionConnection!
  hasCollection(id: ID!): Boolean!
  id: ID!
  name: String!
  productPublicationsV3(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ResourcePublicationConnection!
  products(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ProductConnection!
  supportsFuturePublishing: Boolean!
}

type PublicationConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [PublicationEdge!]!
  nodes: [Publication!]!
  pageInfo: PageInfo!
}

type PublicationEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: Publication!
}

interface Publishable
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  availablePublicationCount: Int!
  publicationCount(onlyPublished: Boolean = true): Int!
  publishedOnCurrentPublication: Boolean!
  publishedOnPublication(publicationId: ID!): Boolean!
  resourcePublications(onlyPublished: Boolean = true, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ResourcePublicationConnection!
  resourcePublicationsV2(onlyPublished: Boolean = true, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ResourcePublicationV2Connection!
  unpublishedPublications(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): PublicationConnection!
}

type PublishedTranslation
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  key: String!
  locale: String!
  marketId: ID
  value: String
}

type PurchasingCompany
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  company: Company!
  contact: CompanyContact
  location: CompanyLocation!
}

union PurchasingEntity
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = Customer | PurchasingCompany

type Query
  @inContext
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  customer(id: ID!): Customer @join__field(graph: CUSTOMER)
  product(id: ID!): Product @join__field(graph: PRODUCT)
  productByHandle(handle: String!): Product @join__field(graph: PRODUCT)
  productResourceFeedback(id: ID!): ProductResourceFeedback @join__field(graph: PRODUCT)
  productSavedSearches(after: String, before: String, first: Int, last: Int, reverse: Boolean = false): SavedSearchConnection! @join__field(graph: PRODUCT)
  productVariant(id: ID!): ProductVariant @join__field(graph: PRODUCT)
  productVariants(after: String, before: String, first: Int, last: Int, query: String, reverse: Boolean = false, savedSearchId: ID, sortKey: ProductVariantSortKeys = ID): ProductVariantConnection! @join__field(graph: PRODUCT)
  products(after: String, before: String, first: Int, last: Int, query: String, reverse: Boolean = false, savedSearchId: ID, sortKey: ProductSortKeys = ID): ProductConnection! @join__field(graph: PRODUCT)
}

type Refund implements LegacyInteroperability & Node
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  createdAt: DateTime
  duties: [RefundDuty!]
  id: ID!
  legacyResourceId: UnsignedInt64!
  note: String
  order: Order!
  refundLineItems(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): RefundLineItemConnection!
  staffMember: StaffMember
  totalRefundedSet: MoneyBag!
  transactions(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): OrderTransactionConnection!
  updatedAt: DateTime!
}

type RefundDuty
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amountSet: MoneyBag!
  originalDuty: Duty
}

input RefundDutyInput
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  dutyId: ID!
  refundType: RefundDutyRefundType
}

enum RefundDutyRefundType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PROPORTIONAL
  FULL
}

type RefundLineItem
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  lineItem: LineItem!
  location: Location
  priceSet: MoneyBag!
  quantity: Int!
  restockType: RefundLineItemRestockType!
  restocked: Boolean!
  subtotalSet: MoneyBag!
  totalTaxSet: MoneyBag!
}

type RefundLineItemConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [RefundLineItemEdge!]!
  nodes: [RefundLineItem!]!
  pageInfo: PageInfo!
}

type RefundLineItemEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: RefundLineItem!
}

input RefundLineItemInput
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  lineItemId: ID!
  quantity: Int!
  restockType: RefundLineItemRestockType
  locationId: ID
}

enum RefundLineItemRestockType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  RETURN
  CANCEL
  LEGACY_RESTOCK
  NO_RESTOCK
}

type ResourceAlert
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  actions: [ResourceAlertAction!]!
  content: HTML!
  dismissibleHandle: String
  icon: ResourceAlertIcon
  severity: ResourceAlertSeverity!
  title: String!
}

type ResourceAlertAction
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  primary: Boolean!
  show: String
  title: String!
  url: URL!
}

enum ResourceAlertIcon
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CHECKMARK_CIRCLE
  INFORMATION_CIRCLE
}

enum ResourceAlertSeverity
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  DEFAULT
  INFO
  WARNING
  SUCCESS
  CRITICAL
}

type ResourceFeedback
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  details: [AppFeedback!]!
  summary: String!
}

enum ResourceFeedbackState
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ACCEPTED
  REQUIRES_ACTION
}

type ResourceLimit
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  available: Boolean!
  quantityAvailable: Int
  quantityLimit: Int
  quantityUsed: Int
}

type ResourcePublication
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  isPublished: Boolean!
  publication: Publication!
  publishDate: DateTime!
  publishable: Publishable!
}

type ResourcePublicationConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [ResourcePublicationEdge!]!
  nodes: [ResourcePublication!]!
  pageInfo: PageInfo!
}

type ResourcePublicationEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: ResourcePublication!
}

type ResourcePublicationV2
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  isPublished: Boolean!
  publication: Publication!
  publishDate: DateTime
  publishable: Publishable!
}

type ResourcePublicationV2Connection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [ResourcePublicationV2Edge!]!
  nodes: [ResourcePublicationV2!]!
  pageInfo: PageInfo!
}

type ResourcePublicationV2Edge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: ResourcePublicationV2!
}

interface Sale
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  actionType: SaleActionType!
  id: ID!
  lineType: SaleLineType!
  quantity: Int
  taxes: [SaleTax!]!
  totalAmount: MoneyBag!
  totalDiscountAmountAfterTaxes: MoneyBag!
  totalDiscountAmountBeforeTaxes: MoneyBag!
  totalTaxAmount: MoneyBag!
}

enum SaleActionType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ORDER
  RETURN
  UPDATE
  UNKNOWN
}

type SaleConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [SaleEdge!]!
  nodes: [Sale!]!
  pageInfo: PageInfo!
}

type SaleEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: Sale!
}

enum SaleLineType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PRODUCT
  TIP
  GIFT_CARD
  SHIPPING
  DUTY
  UNKNOWN
  ADJUSTMENT
}

interface SalesAgreement
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  app: App
  happenedAt: DateTime!
  id: ID!
  reason: OrderActionType!
  sales(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SaleConnection!
  user: StaffMember
}

type SalesAgreementConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [SalesAgreementEdge!]!
  nodes: [SalesAgreement!]!
  pageInfo: PageInfo!
}

type SalesAgreementEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: SalesAgreement!
}

type SaleTax
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amount: MoneyBag!
  id: ID!
  taxLine: TaxLine!
}

type SavedSearch implements LegacyInteroperability & Node
  @join__implements(graph: CUSTOMER, interface: "LegacyInteroperability")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "LegacyInteroperability")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  filters: [SearchFilter!]!
  id: ID!
  legacyResourceId: UnsignedInt64!
  name: String!
  query: String!
  resourceType: SearchResultType!
  searchTerms: String!
}

type SavedSearchConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [SavedSearchEdge!]!
  nodes: [SavedSearch!]!
  pageInfo: PageInfo!
}

type SavedSearchEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: SavedSearch!
}

type ScriptDiscountApplication implements DiscountApplication
  @join__implements(graph: CUSTOMER, interface: "DiscountApplication")
  @join__implements(graph: PRODUCT, interface: "DiscountApplication")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  allocationMethod: DiscountApplicationAllocationMethod!
  index: Int!
  targetSelection: DiscountApplicationTargetSelection!
  targetType: DiscountApplicationTargetType!
  title: String!
  value: PricingValue!
}

type SearchFilter
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  key: String!
  value: String!
}

type SearchFilterOptions
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  productAvailability: [FilterOption!]!
}

type SearchResult
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  description: String
  image: Image
  reference: Node!
  title: String!
  url: URL!
}

type SearchResultConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [SearchResultEdge!]!
  pageInfo: PageInfo!
}

type SearchResultEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: SearchResult!
}

enum SearchResultType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CUSTOMER
  DRAFT_ORDER
  PRODUCT
  COLLECTION
  FILE
  ONLINE_STORE_PAGE
  ONLINE_STORE_BLOG
  ONLINE_STORE_ARTICLE
  URL_REDIRECT
  PRICE_RULE
  DISCOUNT_REDEEM_CODE
  ORDER
}

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

type SellingPlan implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  billingPolicy: SellingPlanBillingPolicy!
  category: SellingPlanCategory
  createdAt: DateTime!
  deliveryPolicy: SellingPlanDeliveryPolicy!
  description: String
  id: ID!
  inventoryPolicy: SellingPlanInventoryPolicy
  name: String!
  options: [String!]!
  position: Int
  pricingPolicies: [SellingPlanPricingPolicy!]!
}

type SellingPlanAnchor
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cutoffDay: Int
  day: Int!
  month: Int
  type: SellingPlanAnchorType!
}

enum SellingPlanAnchorType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  WEEKDAY
  MONTHDAY
  YEARDAY
}

union SellingPlanBillingPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = SellingPlanFixedBillingPolicy | SellingPlanRecurringBillingPolicy

enum SellingPlanCategory
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  OTHER
  PRE_ORDER
  SUBSCRIPTION
  TRY_BEFORE_YOU_BUY
}

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

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

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

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

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

union SellingPlanDeliveryPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = SellingPlanFixedDeliveryPolicy | SellingPlanRecurringDeliveryPolicy

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

type SellingPlanFixedBillingPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  checkoutCharge: SellingPlanCheckoutCharge!
  remainingBalanceChargeExactTime: DateTime
  remainingBalanceChargeTimeAfterCheckout: String
  remainingBalanceChargeTrigger: SellingPlanRemainingBalanceChargeTrigger!
}

type SellingPlanFixedDeliveryPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  anchors: [SellingPlanAnchor!]!
  cutoff: Int
  fulfillmentExactTime: DateTime
  fulfillmentTrigger: SellingPlanFulfillmentTrigger!
  intent: SellingPlanFixedDeliveryPolicyIntent!
  preAnchorBehavior: SellingPlanFixedDeliveryPolicyPreAnchorBehavior!
}

enum SellingPlanFixedDeliveryPolicyIntent
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  FULFILLMENT_BEGIN
}

enum SellingPlanFixedDeliveryPolicyPreAnchorBehavior
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ASAP
  NEXT
}

type SellingPlanFixedPricingPolicy implements SellingPlanPricingPolicyBase
  @join__implements(graph: CUSTOMER, interface: "SellingPlanPricingPolicyBase")
  @join__implements(graph: PRODUCT, interface: "SellingPlanPricingPolicyBase")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  adjustmentType: SellingPlanPricingPolicyAdjustmentType!
  adjustmentValue: SellingPlanPricingPolicyAdjustmentValue!
  createdAt: DateTime!
}

enum SellingPlanFulfillmentTrigger
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ANCHOR
  ASAP
  EXACT_TIME
  UNKNOWN
}

type SellingPlanGroup implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  appId: String
  appliesToProduct(productId: ID!): Boolean!
  appliesToProductVariant(productVariantId: ID!): Boolean!
  appliesToProductVariants(productId: ID!): Boolean!
  createdAt: DateTime!
  description: String
  id: ID!
  merchantCode: String!
  name: String!
  options: [String!]!
  position: Int
  productCount: Int!
  productVariantCount(productId: ID): Int!
  productVariants(productId: ID, first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ProductVariantConnection!
  products(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): ProductConnection!
  sellingPlans(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SellingPlanConnection!
  summary: String
}

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

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

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

enum SellingPlanGroupUserErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  BLANK
  EQUAL_TO
  GREATER_THAN
  GREATER_THAN_OR_EQUAL_TO
  INCLUSION
  INVALID
  LESS_THAN
  LESS_THAN_OR_EQUAL_TO
  NOT_A_NUMBER
  NOT_FOUND
  PRESENT
  TAKEN
  TOO_BIG
  TOO_LONG
  TOO_SHORT
  WRONG_LENGTH
  SELLING_PLAN_COUNT_UPPER_BOUND
  SELLING_PLAN_COUNT_LOWER_BOUND
  SELLING_PLAN_MAX_CYCLES_MUST_BE_GREATER_THAN_MIN_CYCLES
  SELLING_PLAN_BILLING_AND_DELIVERY_POLICY_ANCHORS_MUST_BE_EQUAL
  SELLING_PLAN_BILLING_CYCLE_MUST_BE_A_MULTIPLE_OF_DELIVERY_CYCLE
  SELLING_PLAN_PRICING_POLICIES_MUST_CONTAIN_A_FIXED_PRICING_POLICY
  SELLING_PLAN_MISSING_OPTION2_LABEL_ON_PARENT_GROUP
  SELLING_PLAN_MISSING_OPTION3_LABEL_ON_PARENT_GROUP
  SELLING_PLAN_OPTION2_REQUIRED_AS_DEFINED_ON_PARENT_GROUP
  SELLING_PLAN_OPTION3_REQUIRED_AS_DEFINED_ON_PARENT_GROUP
  SELLING_PLAN_PRICING_POLICIES_LIMIT
  RESOURCE_LIST_CONTAINS_INVALID_IDS
  PRODUCT_VARIANT_DOES_NOT_EXIST
  PRODUCT_DOES_NOT_EXIST
  GROUP_DOES_NOT_EXIST
  GROUP_COULD_NOT_BE_DELETED
  ERROR_ADDING_RESOURCE_TO_GROUP
  SELLING_PLAN_DELIVERY_POLICY_MISSING
  SELLING_PLAN_BILLING_POLICY_MISSING
  PLAN_DOES_NOT_EXIST
  PLAN_ID_MUST_BE_SPECIFIED_TO_UPDATE
  ONLY_NEED_ONE_BILLING_POLICY_TYPE
  ONLY_NEED_ONE_DELIVERY_POLICY_TYPE
  ONLY_NEED_ONE_PRICING_POLICY_TYPE
  BILLING_AND_DELIVERY_POLICY_TYPES_MUST_BE_THE_SAME
  ONLY_NEED_ONE_PRICING_POLICY_VALUE
  PRICING_POLICY_ADJUSTMENT_VALUE_AND_TYPE_MUST_MATCH
  SELLING_PLAN_DUPLICATE_NAME
  SELLING_PLAN_DUPLICATE_OPTIONS
  SELLING_PLAN_FIXED_PRICING_POLICIES_LIMIT
  REMAINING_BALANCE_CHARGE_EXACT_TIME_REQUIRED
  CHECKOUT_CHARGE_VALUE_AND_TYPE_MUST_MATCH
  ONLY_NEED_ONE_CHECKOUT_CHARGE_VALUE
  REMAINING_BALANCE_CHARGE_EXACT_TIME_NOT_ALLOWED
  REMAINING_BALANCE_CHARGE_TIME_AFTER_CHECKOUT_MUST_BE_GREATER_THAN_ZERO
  REMAINING_BALANCE_CHARGE_TRIGGER_ON_FULL_CHECKOUT
  REMAINING_BALANCE_CHARGE_TRIGGER_NO_REMAINING_BALANCE_ON_PARTIAL_PERCENTAGE_CHECKOUT_CHARGE
  REMAINING_BALANCE_CHARGE_TRIGGER_NO_REMAINING_BALANCE_ON_PRICE_CHECKOUT_CHARGE
  FULFILLMENT_EXACT_TIME_REQUIRED
  FULFILLMENT_EXACT_TIME_NOT_ALLOWED
  SELLING_PLAN_ANCHORS_NOT_ALLOWED
  SELLING_PLAN_ANCHORS_REQUIRED
  ONLY_ONE_OF_FIXED_OR_RECURRING_BILLING
  ONLY_ONE_OF_FIXED_OR_RECURRING_DELIVERY
}

enum SellingPlanInterval
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  DAY
  WEEK
  MONTH
  YEAR
}

type SellingPlanInventoryPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  reserve: SellingPlanReserve!
}

union SellingPlanPricingPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = SellingPlanFixedPricingPolicy | SellingPlanRecurringPricingPolicy

enum SellingPlanPricingPolicyAdjustmentType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PERCENTAGE
  FIXED_AMOUNT
  PRICE
}

union SellingPlanPricingPolicyAdjustmentValue
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = MoneyV2 | SellingPlanPricingPolicyPercentageValue

interface SellingPlanPricingPolicyBase
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  adjustmentType: SellingPlanPricingPolicyAdjustmentType!
  adjustmentValue: SellingPlanPricingPolicyAdjustmentValue!
}

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

type SellingPlanRecurringBillingPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  anchors: [SellingPlanAnchor!]!
  createdAt: DateTime!
  interval: SellingPlanInterval!
  intervalCount: Int!
  maxCycles: Int
  minCycles: Int
}

type SellingPlanRecurringDeliveryPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  anchors: [SellingPlanAnchor!]!
  createdAt: DateTime!
  cutoff: Int
  intent: SellingPlanRecurringDeliveryPolicyIntent!
  interval: SellingPlanInterval!
  intervalCount: Int!
  preAnchorBehavior: SellingPlanRecurringDeliveryPolicyPreAnchorBehavior!
}

enum SellingPlanRecurringDeliveryPolicyIntent
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  FULFILLMENT_BEGIN
}

enum SellingPlanRecurringDeliveryPolicyPreAnchorBehavior
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ASAP
  NEXT
}

type SellingPlanRecurringPricingPolicy implements SellingPlanPricingPolicyBase
  @join__implements(graph: CUSTOMER, interface: "SellingPlanPricingPolicyBase")
  @join__implements(graph: PRODUCT, interface: "SellingPlanPricingPolicyBase")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  adjustmentType: SellingPlanPricingPolicyAdjustmentType!
  adjustmentValue: SellingPlanPricingPolicyAdjustmentValue!
  afterCycle: Int
  createdAt: DateTime!
}

enum SellingPlanRemainingBalanceChargeTrigger
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  NO_REMAINING_BALANCE
  EXACT_TIME
  TIME_AFTER_CHECKOUT
}

enum SellingPlanReserve
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ON_FULFILLMENT
  ON_SALE
}

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

input SEOInput
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  title: String
  description: String
}

type ShippingLine
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  carrierIdentifier: String
  code: String
  custom: Boolean!
  deliveryCategory: String
  discountAllocations: [DiscountAllocation!]!
  discountedPriceSet: MoneyBag!
  id: ID
  originalPriceSet: MoneyBag!
  phone: String
  requestedFulfillmentService: FulfillmentService
  shippingRateHandle: String
  source: String
  taxLines: [TaxLine!]!
  title: String!
}

type ShippingLineConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [ShippingLineEdge!]!
  nodes: [ShippingLine!]!
  pageInfo: PageInfo!
}

type ShippingLineEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: ShippingLine!
}

type ShippingRefund
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amountSet: MoneyBag!
  maximumRefundableSet: MoneyBag!
  taxSet: MoneyBag!
}

type Shop implements HasMetafields & HasPublishedTranslations & Node
  @join__implements(graph: CUSTOMER, interface: "HasMetafields")
  @join__implements(graph: CUSTOMER, interface: "HasPublishedTranslations")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "HasMetafields")
  @join__implements(graph: PRODUCT, interface: "HasPublishedTranslations")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  alerts: [ShopAlert!]!
  allProductCategories: [ProductCategory!]!
  assignedFulfillmentOrders(after: String, assignmentStatus: FulfillmentOrderAssignmentStatus, before: String, first: Int, last: Int, locationIds: [ID!], reverse: Boolean = false, sortKey: FulfillmentOrderSortKeys = ID): FulfillmentOrderConnection!
  availableChannelApps(after: String, before: String, first: Int, last: Int, reverse: Boolean = false): AppConnection!
  billingAddress: MailingAddress!
  channelDefinitionsForInstalledChannels: [AvailableChannelDefinitionsByChannel!]!
  checkoutApiSupported: Boolean!
  contactEmail: String!
  countriesInShippingZones: CountriesInShippingZones!
  currencyCode: CurrencyCode!
  currencyFormats: CurrencyFormats!
  currencySettings(after: String, before: String, first: Int, last: Int, reverse: Boolean = false): CurrencySettingConnection!
  customerAccounts: ShopCustomerAccountsSetting!
  customerTags(first: Int!): StringConnection!
  description: String
  draftOrderTags(first: Int!): StringConnection!
  email: String!
  enabledPresentmentCurrencies: [CurrencyCode!]!
  features: ShopFeatures!
  fulfillmentServices: [FulfillmentService!]!
  ianaTimezone: String!
  id: ID!
  limitedPendingOrderCount: LimitedPendingOrderCount!
  merchantApprovalSignals: MerchantApprovalSignals
  metafield(key: String!, namespace: String!): Metafield
  metafields(after: String, before: String, first: Int, last: Int, namespace: String, reverse: Boolean = false): MetafieldConnection!
  myshopifyDomain: String!
  name: String!
  navigationSettings: [NavigationItem!]!
  orderNumberFormatPrefix: String!
  orderNumberFormatSuffix: String!
  orderTags(first: Int!, sort: ShopTagSort = ALPHABETICAL): StringConnection!
  paymentSettings: PaymentSettings!
  plan: ShopPlan!
  primaryDomain: Domain!
  privateMetafield(key: String!, namespace: String!): PrivateMetafield
  privateMetafields(after: String, before: String, first: Int, last: Int, namespace: String, reverse: Boolean = false): PrivateMetafieldConnection!
  productImages(after: String, before: String, first: Int, last: Int, reverse: Boolean = false, sortKey: ProductImageSortKeys = CREATED_AT): ImageConnection!
  productTags(first: Int!): StringConnection!
  productTypes(first: Int!): StringConnection!
  productVendors(first: Int!): StringConnection!
  publicationCount: Int!
  resourceLimits: ShopResourceLimits!
  richTextEditorUrl: URL!
  search(after: String, first: Int!, query: String!, types: [SearchResultType!]): SearchResultConnection!
  searchFilters: SearchFilterOptions!
  setupRequired: Boolean!
  shipsToCountries: [CountryCode!]!
  shopPolicies: [ShopPolicy!]!
  staffMembers(after: String, before: String, first: Int, last: Int, reverse: Boolean = false): StaffMemberConnection!
  storefrontAccessTokens(after: String, before: String, first: Int, last: Int, reverse: Boolean = false): StorefrontAccessTokenConnection!
  taxShipping: Boolean!
  taxesIncluded: Boolean!
  timezoneAbbreviation: String!
  timezoneOffset: String!
  timezoneOffsetMinutes: Int!
  transactionalSmsDisabled: Boolean!
  translations(locale: String!, marketId: ID): [PublishedTranslation!]!
  unitSystem: UnitSystem!
  uploadedImagesByIds(imageIds: [ID!]!): [Image!]!
  url: URL!
  weightUnit: WeightUnit!
}

type ShopAlert
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  action: ShopAlertAction!
  description: String!
}

type ShopAlertAction
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  title: String!
  url: URL!
}

enum ShopBranding
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SHOPIFY_GOLD
  SHOPIFY_PLUS
  ROGERS
  SHOPIFY
}

enum ShopCustomerAccountsSetting
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  REQUIRED
  OPTIONAL
  DISABLED
}

type ShopFeatures
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  avalaraAvatax: Boolean!
  branding: ShopBranding!
  captcha: Boolean!
  captchaExternalDomains: Boolean!
  dynamicRemarketing: Boolean!
  eligibleForSubscriptionMigration: Boolean!
  eligibleForSubscriptions: Boolean!
  giftCards: Boolean!
  harmonizedSystemCode: Boolean!
  internationalDomains: Boolean!
  internationalPriceOverrides: Boolean!
  internationalPriceRules: Boolean!
  legacySubscriptionGatewayEnabled: Boolean!
  liveView: Boolean!
  onboardingVisual: Boolean!
  paypalExpressSubscriptionGatewayStatus: PaypalExpressSubscriptionsGatewayStatus!
  reports: Boolean!
  sellsSubscriptions: Boolean!
  showMetrics: Boolean!
  storefront: Boolean!
  usingShopifyBalance: Boolean!
}

type ShopifyPaymentsExtendedAuthorization
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  extendedAuthorizationExpiresAt: DateTime!
  standardAuthorizationExpiresAt: DateTime!
}

type ShopifyPaymentsRefundSet
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  acquirerReferenceNumber: String
}

type ShopifyPaymentsTransactionSet
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  extendedAuthorizationSet: ShopifyPaymentsExtendedAuthorization
  refundSet: ShopifyPaymentsRefundSet
}

type ShopPlan
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  displayName: String!
  partnerDevelopment: Boolean!
  shopifyPlus: Boolean!
}

type ShopPolicy implements HasPublishedTranslations & Node
  @join__implements(graph: CUSTOMER, interface: "HasPublishedTranslations")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "HasPublishedTranslations")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  body: HTML!
  id: ID!
  translations(locale: String!, marketId: ID): [PublishedTranslation!]!
  type: ShopPolicyType!
  url: URL!
}

enum ShopPolicyType
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  REFUND_POLICY
  SHIPPING_POLICY
  PRIVACY_POLICY
  TERMS_OF_SERVICE
  TERMS_OF_SALE
  LEGAL_NOTICE
  SUBSCRIPTION_POLICY
}

type ShopResourceLimits
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  locationLimit: Int!
  maxProductOptions: Int!
  maxProductVariants: Int!
  redirectLimitReached: Boolean!
  skuResourceLimits: ResourceLimit!
}

enum ShopTagSort
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ALPHABETICAL
  POPULAR
}

type StaffMember implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  active: Boolean!
  avatar(fallback: StaffMemberDefaultImage = DEFAULT): Image!
  email: String!
  exists: Boolean!
  firstName: String
  id: ID!
  initials: [String!]
  isShopOwner: Boolean!
  lastName: String
  locale: String!
  name: String!
  phone: String
  privateData: StaffMemberPrivateData!
}

type StaffMemberConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [StaffMemberEdge!]!
  nodes: [StaffMember!]!
  pageInfo: PageInfo!
}

enum StaffMemberDefaultImage
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  DEFAULT
  TRANSPARENT
  NOT_FOUND
}

type StaffMemberEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: StaffMember!
}

type StaffMemberPrivateData
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  accountSettingsUrl: URL!
  createdAt: DateTime!
}

input StandardizedProductTypeInput
  @join__type(graph: PRODUCT)
{
  productTaxonomyNodeId: ID!
}

type StandardMetafieldDefinitionTemplate implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  description: String
  id: ID!
  key: String!
  name: String!
  namespace: String!
  ownerTypes: [MetafieldOwnerType!]!
  type: MetafieldDefinitionType!
  validations: [MetafieldDefinitionValidation!]!
  visibleToStorefrontApi: Boolean!
}

type StorefrontAccessToken implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  accessScopes: [AccessScope!]!
  accessToken: String!
  createdAt: DateTime!
  id: ID!
  title: String!
  updatedAt: DateTime!
}

type StorefrontAccessTokenConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [StorefrontAccessTokenEdge!]!
  nodes: [StorefrontAccessToken!]!
  pageInfo: PageInfo!
}

type StorefrontAccessTokenEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: StorefrontAccessToken!
}

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

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

type SubscriptionAppliedCodeDiscount
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  id: ID!
  redeemCode: String!
  rejectionReason: SubscriptionDiscountRejectionReason
}

type SubscriptionBillingAttempt implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  completedAt: DateTime
  createdAt: DateTime!
  errorCode: SubscriptionBillingAttemptErrorCode
  errorMessage: String
  id: ID!
  idempotencyKey: String!
  nextActionUrl: URL
  order: Order
  originTime: DateTime
  ready: Boolean!
  subscriptionContract: SubscriptionContract!
}

type SubscriptionBillingAttemptConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [SubscriptionBillingAttemptEdge!]!
  nodes: [SubscriptionBillingAttempt!]!
  pageInfo: PageInfo!
}

type SubscriptionBillingAttemptEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: SubscriptionBillingAttempt!
}

enum SubscriptionBillingAttemptErrorCode
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  PAYMENT_METHOD_NOT_FOUND
  PAYMENT_PROVIDER_IS_NOT_ENABLED
  INVALID_PAYMENT_METHOD
  UNEXPECTED_ERROR
  EXPIRED_PAYMENT_METHOD
  PAYMENT_METHOD_DECLINED
  AUTHENTICATION_ERROR
  TEST_MODE
  BUYER_CANCELED_PAYMENT_METHOD
  CUSTOMER_NOT_FOUND
  CUSTOMER_INVALID
  INVALID_SHIPPING_ADDRESS
  INVALID_CUSTOMER_BILLING_AGREEMENT
  INVOICE_ALREADY_PAID
  PAYMENT_METHOD_INCOMPATIBLE_WITH_GATEWAY_CONFIG
  AMOUNT_TOO_SMALL
}

type SubscriptionBillingPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  anchors: [SellingPlanAnchor!]!
  interval: SellingPlanInterval!
  intervalCount: Int!
  maxCycles: Int
  minCycles: Int
}

type SubscriptionContract implements Node & SubscriptionContractBase
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: CUSTOMER, interface: "SubscriptionContractBase")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "SubscriptionContractBase")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  app: App
  appAdminUrl: URL
  billingAttempts(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SubscriptionBillingAttemptConnection!
  billingPolicy: SubscriptionBillingPolicy!
  createdAt: DateTime!
  currencyCode: CurrencyCode!
  customAttributes: [Attribute!]!
  customer: Customer
  customerPaymentMethod(showRevoked: Boolean = false): CustomerPaymentMethod
  deliveryMethod: SubscriptionDeliveryMethod
  deliveryPolicy: SubscriptionDeliveryPolicy!
  deliveryPrice: MoneyV2!
  discounts(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SubscriptionManualDiscountConnection!
  id: ID!
  lastPaymentStatus: SubscriptionContractLastPaymentStatus
  lineCount: Int!
  lines(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SubscriptionLineConnection!
  nextBillingDate: DateTime
  note: String
  orders(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): OrderConnection!
  originOrder: Order
  status: SubscriptionContractSubscriptionStatus!
  updatedAt: DateTime!
}

interface SubscriptionContractBase
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  app: App
  appAdminUrl: URL
  currencyCode: CurrencyCode!
  customAttributes: [Attribute!]!
  customer: Customer
  customerPaymentMethod(showRevoked: Boolean = false): CustomerPaymentMethod
  deliveryMethod: SubscriptionDeliveryMethod
  deliveryPrice: MoneyV2!
  discounts(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SubscriptionManualDiscountConnection!
  lineCount: Int!
  lines(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SubscriptionLineConnection!
  note: String
  orders(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): OrderConnection!
  updatedAt: DateTime!
}

type SubscriptionContractConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [SubscriptionContractEdge!]!
  nodes: [SubscriptionContract!]!
  pageInfo: PageInfo!
}

type SubscriptionContractEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: SubscriptionContract!
}

enum SubscriptionContractLastPaymentStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SUCCEEDED
  FAILED
}

enum SubscriptionContractSubscriptionStatus
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  ACTIVE
  PAUSED
  CANCELLED
  EXPIRED
  FAILED
}

type SubscriptionCyclePriceAdjustment
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  adjustmentType: SellingPlanPricingPolicyAdjustmentType!
  adjustmentValue: SellingPlanPricingPolicyAdjustmentValue!
  afterCycle: Int!
  computedPrice: MoneyV2!
}

union SubscriptionDeliveryMethod
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = SubscriptionDeliveryMethodLocalDelivery | SubscriptionDeliveryMethodPickup | SubscriptionDeliveryMethodShipping

type SubscriptionDeliveryMethodLocalDelivery
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address: SubscriptionMailingAddress!
  localDeliveryOption: SubscriptionDeliveryMethodLocalDeliveryOption!
}

type SubscriptionDeliveryMethodLocalDeliveryOption
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  code: String
  description: String
  instructions: String
  phone: String!
  presentmentTitle: String
  title: String
}

type SubscriptionDeliveryMethodPickup
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  pickupOption: SubscriptionDeliveryMethodPickupOption!
}

type SubscriptionDeliveryMethodPickupOption
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  code: String
  description: String
  location: Location!
  presentmentTitle: String
  title: String
}

type SubscriptionDeliveryMethodShipping
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address: SubscriptionMailingAddress!
  shippingOption: SubscriptionDeliveryMethodShippingOption!
}

type SubscriptionDeliveryMethodShippingOption
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  carrierService: DeliveryCarrierService
  code: String
  description: String
  presentmentTitle: String
  title: String
}

type SubscriptionDeliveryPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  anchors: [SellingPlanAnchor!]!
  interval: SellingPlanInterval!
  intervalCount: Int!
}

union SubscriptionDiscount
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = SubscriptionAppliedCodeDiscount | SubscriptionManualDiscount

type SubscriptionDiscountAllocation
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amount: MoneyV2!
  discount: SubscriptionDiscount!
}

type SubscriptionDiscountEntitledLines
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  all: Boolean!
  lines(first: Int, after: String, last: Int, before: String, reverse: Boolean = false): SubscriptionLineConnection!
}

type SubscriptionDiscountFixedAmountValue
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amount: MoneyV2!
  appliesOnEachItem: Boolean!
}

type SubscriptionDiscountPercentageValue
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  percentage: Int!
}

enum SubscriptionDiscountRejectionReason
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  NOT_FOUND
  NO_ENTITLED_LINE_ITEMS
  QUANTITY_NOT_IN_RANGE
  PURCHASE_NOT_IN_RANGE
  CUSTOMER_NOT_ELIGIBLE
  USAGE_LIMIT_REACHED
  CUSTOMER_USAGE_LIMIT_REACHED
  CURRENTLY_INACTIVE
  NO_ENTITLED_SHIPPING_LINES
  INCOMPATIBLE_PURCHASE_TYPE
  INTERNAL_ERROR
}

union SubscriptionDiscountValue
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
 = SubscriptionDiscountFixedAmountValue | SubscriptionDiscountPercentageValue

type SubscriptionLine
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  currentPrice: MoneyV2!
  customAttributes: [Attribute!]!
  discountAllocations: [SubscriptionDiscountAllocation!]!
  id: ID!
  lineDiscountedPrice: MoneyV2!
  pricingPolicy: SubscriptionPricingPolicy
  productId: ID
  quantity: Int!
  requiresShipping: Boolean!
  sellingPlanId: ID
  sellingPlanName: String
  sku: String
  taxable: Boolean!
  title: String!
  variantId: ID
  variantImage: Image
  variantTitle: String
}

type SubscriptionLineConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [SubscriptionLineEdge!]!
  nodes: [SubscriptionLine!]!
  pageInfo: PageInfo!
}

type SubscriptionLineEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: SubscriptionLine!
}

type SubscriptionMailingAddress
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  address1: String
  address2: String
  city: String
  company: String
  country: String
  countryCode: CountryCode
  firstName: String
  lastName: String
  name: String
  phone: String
  province: String
  provinceCode: String
  zip: String
}

type SubscriptionManualDiscount
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  entitledLines: SubscriptionDiscountEntitledLines!
  id: ID!
  recurringCycleLimit: Int
  rejectionReason: SubscriptionDiscountRejectionReason
  targetType: DiscountTargetType!
  title: String
  type: DiscountType!
  usageCount: Int!
  value: SubscriptionDiscountValue!
}

type SubscriptionManualDiscountConnection
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  edges: [SubscriptionManualDiscountEdge!]!
  nodes: [SubscriptionManualDiscount!]!
  pageInfo: PageInfo!
}

type SubscriptionManualDiscountEdge
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  cursor: String!
  node: SubscriptionManualDiscount!
}

type SubscriptionPricingPolicy
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  basePrice: MoneyV2!
  cycleDiscounts: [SubscriptionCyclePriceAdjustment!]!
}

type SuggestedOrderTransaction
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  accountNumber: String
  amountSet: MoneyBag!
  formattedGateway: String
  gateway: String
  kind: SuggestedOrderTransactionKind!
  maximumRefundableSet: MoneyBag
  parentTransaction: OrderTransaction
}

enum SuggestedOrderTransactionKind
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  SUGGESTED_REFUND
}

type SuggestedRefund
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amountSet: MoneyBag!
  discountedSubtotalSet: MoneyBag!
  maximumRefundableSet: MoneyBag!
  refundDuties: [RefundDuty!]!
  refundLineItems: [RefundLineItem!]!
  shipping: ShippingRefund!
  subtotalSet: MoneyBag!
  suggestedTransactions: [SuggestedOrderTransaction!]!
  totalCartDiscountAmountSet: MoneyBag!
  totalDutiesSet: MoneyBag!
  totalTaxSet: MoneyBag!
}

enum TaxExemption
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  CA_STATUS_CARD_EXEMPTION
  CA_BC_RESELLER_EXEMPTION
  CA_MB_RESELLER_EXEMPTION
  CA_SK_RESELLER_EXEMPTION
  CA_DIPLOMAT_EXEMPTION
  CA_BC_COMMERCIAL_FISHERY_EXEMPTION
  CA_MB_COMMERCIAL_FISHERY_EXEMPTION
  CA_NS_COMMERCIAL_FISHERY_EXEMPTION
  CA_PE_COMMERCIAL_FISHERY_EXEMPTION
  CA_SK_COMMERCIAL_FISHERY_EXEMPTION
  CA_BC_PRODUCTION_AND_MACHINERY_EXEMPTION
  CA_SK_PRODUCTION_AND_MACHINERY_EXEMPTION
  CA_BC_SUB_CONTRACTOR_EXEMPTION
  CA_SK_SUB_CONTRACTOR_EXEMPTION
  CA_BC_CONTRACTOR_EXEMPTION
  CA_SK_CONTRACTOR_EXEMPTION
  CA_ON_PURCHASE_EXEMPTION
  CA_MB_FARMER_EXEMPTION
  CA_NS_FARMER_EXEMPTION
  CA_SK_FARMER_EXEMPTION
  EU_REVERSE_CHARGE_EXEMPTION_RULE
  US_AL_RESELLER_EXEMPTION
  US_AK_RESELLER_EXEMPTION
  US_AZ_RESELLER_EXEMPTION
  US_AR_RESELLER_EXEMPTION
  US_CA_RESELLER_EXEMPTION
  US_CO_RESELLER_EXEMPTION
  US_CT_RESELLER_EXEMPTION
  US_DE_RESELLER_EXEMPTION
  US_FL_RESELLER_EXEMPTION
  US_GA_RESELLER_EXEMPTION
  US_HI_RESELLER_EXEMPTION
  US_ID_RESELLER_EXEMPTION
  US_IL_RESELLER_EXEMPTION
  US_IN_RESELLER_EXEMPTION
  US_IA_RESELLER_EXEMPTION
  US_KS_RESELLER_EXEMPTION
  US_KY_RESELLER_EXEMPTION
  US_LA_RESELLER_EXEMPTION
  US_ME_RESELLER_EXEMPTION
  US_MD_RESELLER_EXEMPTION
  US_MA_RESELLER_EXEMPTION
  US_MI_RESELLER_EXEMPTION
  US_MN_RESELLER_EXEMPTION
  US_MS_RESELLER_EXEMPTION
  US_MO_RESELLER_EXEMPTION
  US_MT_RESELLER_EXEMPTION
  US_NE_RESELLER_EXEMPTION
  US_NV_RESELLER_EXEMPTION
  US_NH_RESELLER_EXEMPTION
  US_NJ_RESELLER_EXEMPTION
  US_NM_RESELLER_EXEMPTION
  US_NY_RESELLER_EXEMPTION
  US_NC_RESELLER_EXEMPTION
  US_ND_RESELLER_EXEMPTION
  US_OH_RESELLER_EXEMPTION
  US_OK_RESELLER_EXEMPTION
  US_OR_RESELLER_EXEMPTION
  US_PA_RESELLER_EXEMPTION
  US_RI_RESELLER_EXEMPTION
  US_SC_RESELLER_EXEMPTION
  US_SD_RESELLER_EXEMPTION
  US_TN_RESELLER_EXEMPTION
  US_TX_RESELLER_EXEMPTION
  US_UT_RESELLER_EXEMPTION
  US_VT_RESELLER_EXEMPTION
  US_VA_RESELLER_EXEMPTION
  US_WA_RESELLER_EXEMPTION
  US_WV_RESELLER_EXEMPTION
  US_WI_RESELLER_EXEMPTION
  US_WY_RESELLER_EXEMPTION
  US_DC_RESELLER_EXEMPTION
}

type TaxLine
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  channelLiable: Boolean
  priceSet: MoneyBag!
  rate: Float
  ratePercentage: Float
  title: String!
}

type TransactionFee implements Node
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  amount: MoneyV2!
  flatFee: MoneyV2!
  flatFeeName: String
  id: ID!
  rate: Decimal!
  rateName: String
  taxAmount: MoneyV2!
  type: String!
}

type TypedAttribute
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  key: String!
  value: String!
}

enum UnitSystem
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  IMPERIAL_SYSTEM
  METRIC_SYSTEM
}

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

input UpdateMediaInput
  @join__type(graph: PRODUCT)
{
  id: ID!
  previewImageSource: String
  alt: String
}

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

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

type UTMParameters
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  campaign: String
  content: String
  medium: String
  source: String
  term: String
}

type VaultCreditCard
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  billingAddress: CustomerCreditCardBillingAddress
  brand: String!
  expired: Boolean!
  expiryMonth: Int!
  expiryYear: Int!
  lastDigits: String!
  name: String!
}

type VaultPaypalBillingAgreement
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  inactive: Boolean!
  name: String!
  paypalAccountEmail: String!
}

type Video implements File & Media & Node
  @join__implements(graph: CUSTOMER, interface: "File")
  @join__implements(graph: CUSTOMER, interface: "Media")
  @join__implements(graph: CUSTOMER, interface: "Node")
  @join__implements(graph: PRODUCT, interface: "File")
  @join__implements(graph: PRODUCT, interface: "Media")
  @join__implements(graph: PRODUCT, interface: "Node")
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  alt: String
  createdAt: DateTime!
  duration: Int
  fileErrors: [FileError!]!
  fileStatus: FileStatus!
  filename: String!
  id: ID!
  mediaContentType: MediaContentType!
  mediaErrors: [MediaError!]!
  mediaWarnings: [MediaWarning!]!
  originalSource: VideoSource
  preview: MediaPreviewImage
  sources: [VideoSource!]!
  status: MediaStatus!
}

type VideoSource
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  fileSize: Int
  format: String!
  height: Int!
  mimeType: String!
  url: String!
  width: Int!
}

type Weight
  @join__type(graph: CUSTOMER)
  @join__type(graph: PRODUCT)
{
  unit: WeightUnit!
  value: Float!
}

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

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