Mutations

"""Add an OptionGroup to a Product"""
type Mutation {
  addOptionGroupToProduct(productId: ID!, optionGroupId: ID!): Product!
}

"""Adjusts a draft OrderLine. If custom fields are defined on the OrderLine entity, a third argument 'customFields' of type `OrderLineCustomFieldsInput` will be available."""
type Mutation {
  adjustDraftOrderLine(orderId: ID!, input: AdjustDraftOrderLineInput!): UpdateOrderItemsResult!
}

"""Applies the given coupon code to the draft Order"""
type Mutation {
  applyCouponCodeToDraftOrder(orderId: ID!, couponCode: String!): ApplyCouponCodeResult!
}

"""Assign assets to channel"""
type Mutation {
  assignAssetsToChannel(input: AssignAssetsToChannelInput!): [Asset!]!
}

"""Assigns Collections to the specified Channel"""
type Mutation {
  assignCollectionsToChannel(input: AssignCollectionsToChannelInput!): [Collection!]!
}

"""Assigns Facets to the specified Channel"""
type Mutation {
  assignFacetsToChannel(input: AssignFacetsToChannelInput!): [Facet!]!
}

"""Assigns PaymentMethods to the specified Channel"""
type Mutation {
  assignPaymentMethodsToChannel(input: AssignPaymentMethodsToChannelInput!): [PaymentMethod!]!
}

"""Assigns ProductOptionGroups to the specified Channel"""
type Mutation {
  assignProductOptionGroupsToChannel(input: AssignProductOptionGroupsToChannelInput!): [ProductOptionGroup!]!
}

"""Assigns ProductVariants to the specified Channel"""
type Mutation {
  assignProductVariantsToChannel(input: AssignProductVariantsToChannelInput!): [ProductVariant!]!
}

"""Assigns all ProductVariants of Product to the specified Channel"""
type Mutation {
  assignProductsToChannel(input: AssignProductsToChannelInput!): [Product!]!
}

"""Assigns Promotions to the specified Channel"""
type Mutation {
  assignPromotionsToChannel(input: AssignPromotionsToChannelInput!): [Promotion!]!
}

"""Assign a Role to an Administrator"""
type Mutation {
  assignRoleToAdministrator(administratorId: ID!, roleId: ID!): Administrator!
}

"""
Grants the User each Role on the given Channel. The active user must hold every permission
of the Role on that Channel, be able to grant every assignment the User already holds, and
have UpdateAdministrator (UpdateApiKey for an ApiKey's User) on each Channel involved.
A SuperAdmin grant applies on every Channel.
"""
type Mutation {
  assignRolesToUser(input: AssignRolesToUserInput!): User!
}

"""Assigns ShippingMethods to the specified Channel"""
type Mutation {
  assignShippingMethodsToChannel(input: AssignShippingMethodsToChannelInput!): [ShippingMethod!]!
}

"""Assigns StockLocations to the specified Channel"""
type Mutation {
  assignStockLocationsToChannel(input: AssignStockLocationsToChannelInput!): [StockLocation!]!
}

"""Authenticates the user using a named authentication strategy"""
type Mutation {
  authenticate(input: AuthenticationInput!, rememberMe: Boolean): AuthenticationResult!
}

type Mutation {
  cancelJob(jobId: ID!): Job!
}

type Mutation {
  cancelOrder(input: CancelOrderInput!): CancelOrderResult!
}

type Mutation {
  cancelPayment(id: ID!): CancelPaymentResult!
}

"""Create a new Administrator"""
type Mutation {
  createAdministrator(input: CreateAdministratorInput!): Administrator!
}

"""
Generates a new API-Key and attaches it to an Administrator.
Returns the generated API-Key.
API-Keys cannot be viewed again after creation.
"""
type Mutation {
  createApiKey(input: CreateApiKeyInput!): CreateApiKeyResult!
}

"""Create a new Asset"""
type Mutation {
  createAssets(input: [CreateAssetInput!]!): [CreateAssetResult!]!
}

"""Create a new Channel"""
type Mutation {
  createChannel(input: CreateChannelInput!): CreateChannelResult!
}

"""Create a new Collection"""
type Mutation {
  createCollection(input: CreateCollectionInput!): Collection!
}

"""Create a new Country"""
type Mutation {
  createCountry(input: CreateCountryInput!): Country!
}

"""Create a new Customer. If a password is provided, a new User will also be created an linked to the Customer."""
type Mutation {
  createCustomer(input: CreateCustomerInput!, password: String): CreateCustomerResult!
}

"""Create a new Address and associate it with the Customer specified by customerId"""
type Mutation {
  createCustomerAddress(customerId: ID!, input: CreateAddressInput!): Address!
}

"""Create a new CustomerGroup"""
type Mutation {
  createCustomerGroup(input: CreateCustomerGroupInput!): CustomerGroup!
}

"""Creates a draft Order"""
type Mutation {
  createDraftOrder: Order!
}

"""Create a new Facet"""
type Mutation {
  createFacet(input: CreateFacetInput!): Facet!
}

"""Create a single FacetValue"""
type Mutation {
  createFacetValue(input: CreateFacetValueInput!): FacetValue!
}

"""Create one or more FacetValues"""
type Mutation {
  createFacetValues(input: [CreateFacetValueInput!]!): [FacetValue!]!
}

"""Create existing PaymentMethod"""
type Mutation {
  createPaymentMethod(input: CreatePaymentMethodInput!): PaymentMethod!
}

"""Create a new Product"""
type Mutation {
  createProduct(input: CreateProductInput!): Product!
}

"""Create a new ProductOption within a ProductOptionGroup"""
type Mutation {
  createProductOption(input: CreateProductOptionInput!): ProductOption!
}

"""Create a new ProductOptionGroup"""
type Mutation {
  createProductOptionGroup(input: CreateProductOptionGroupInput!): ProductOptionGroup!
}

"""
Creates ProductVariants for the given Product. Each input must name exactly one option from
each OptionGroup assigned to the Product. A create is rejected if another variant of the
Product already holds the same combination of options. A Product with no OptionGroups may
hold any number of variants.
"""
type Mutation {
  createProductVariants(input: [CreateProductVariantInput!]!): [ProductVariant]!
}

type Mutation {
  createPromotion(input: CreatePromotionInput!): CreatePromotionResult!
}

"""Create a new Province"""
type Mutation {
  createProvince(input: CreateProvinceInput!): Province!
}

"""Create a new Role"""
type Mutation {
  createRole(input: CreateRoleInput!): Role!
}

"""Create a new Seller"""
type Mutation {
  createSeller(input: CreateSellerInput!): Seller!
}

"""Create a new ShippingMethod"""
type Mutation {
  createShippingMethod(input: CreateShippingMethodInput!): ShippingMethod!
}

type Mutation {
  createStockLocation(input: CreateStockLocationInput!): StockLocation!
}

"""Create a new Tag"""
type Mutation {
  createTag(input: CreateTagInput!): Tag!
}

"""Create a new TaxCategory"""
type Mutation {
  createTaxCategory(input: CreateTaxCategoryInput!): TaxCategory!
}

"""Create a new TaxRate"""
type Mutation {
  createTaxRate(input: CreateTaxRateInput!): TaxRate!
}

"""Create a new Zone"""
type Mutation {
  createZone(input: CreateZoneInput!): Zone!
}

"""Delete an Administrator"""
type Mutation {
  deleteAdministrator(id: ID!): DeletionResponse!
}

"""Delete multiple Administrators"""
type Mutation {
  deleteAdministrators(ids: [ID!]!): [DeletionResponse!]!
}

"""Deletes API-Keys"""
type Mutation {
  deleteApiKeys(ids: [ID!]!): [DeletionResponse!]!
}

"""Delete an Asset"""
type Mutation {
  deleteAsset(input: DeleteAssetInput!): DeletionResponse!
}

"""Delete multiple Assets"""
type Mutation {
  deleteAssets(input: DeleteAssetsInput!): DeletionResponse!
}

"""Delete a Channel"""
type Mutation {
  deleteChannel(id: ID!): DeletionResponse!
}

"""Delete multiple Channels"""
type Mutation {
  deleteChannels(ids: [ID!]!): [DeletionResponse!]!
}

"""Delete a Collection and all of its descendants"""
type Mutation {
  deleteCollection(id: ID!): DeletionResponse!
}

"""Delete multiple Collections and all of their descendants"""
type Mutation {
  deleteCollections(ids: [ID!]!): [DeletionResponse!]!
}

"""Delete multiple Countries"""
type Mutation {
  deleteCountries(ids: [ID!]!): [DeletionResponse!]!
}

"""Delete a Country"""
type Mutation {
  deleteCountry(id: ID!): DeletionResponse!
}

"""Delete a Customer"""
type Mutation {
  deleteCustomer(id: ID!): DeletionResponse!
}

"""Update an existing Address"""
type Mutation {
  deleteCustomerAddress(id: ID!): Success!
}

"""Delete a CustomerGroup"""
type Mutation {
  deleteCustomerGroup(id: ID!): DeletionResponse!
}

"""Delete multiple CustomerGroups"""
type Mutation {
  deleteCustomerGroups(ids: [ID!]!): [DeletionResponse!]!
}

type Mutation {
  deleteCustomerNote(id: ID!): DeletionResponse!
}

"""Deletes Customers"""
type Mutation {
  deleteCustomers(ids: [ID!]!): [DeletionResponse!]!
}

"""Deletes a draft Order"""
type Mutation {
  deleteDraftOrder(orderId: ID!): DeletionResponse!
}

"""Delete an existing Facet"""
type Mutation {
  deleteFacet(id: ID!, force: Boolean): DeletionResponse!
}

"""Delete one or more FacetValues"""
type Mutation {
  deleteFacetValues(ids: [ID!]!, force: Boolean): [DeletionResponse!]!
}

"""Delete multiple existing Facets"""
type Mutation {
  deleteFacets(ids: [ID!]!, force: Boolean): [DeletionResponse!]!
}

type Mutation {
  deleteOrderNote(id: ID!): DeletionResponse!
}

"""Delete a PaymentMethod"""
type Mutation {
  deletePaymentMethod(id: ID!, force: Boolean): DeletionResponse!
}

"""Delete multiple PaymentMethods"""
type Mutation {
  deletePaymentMethods(ids: [ID!]!, force: Boolean): [DeletionResponse!]!
}

"""Delete a Product"""
type Mutation {
  deleteProduct(id: ID!): DeletionResponse!
}

"""Delete a ProductOption"""
type Mutation {
  deleteProductOption(id: ID!): DeletionResponse!
}

"""Delete a ProductOptionGroup"""
type Mutation {
  deleteProductOptionGroup(id: ID!, force: Boolean): DeletionResponse!
}

"""Delete multiple ProductOptionGroups"""
type Mutation {
  deleteProductOptionGroups(ids: [ID!]!, force: Boolean): [DeletionResponse!]!
}

"""Delete a ProductVariant"""
type Mutation {
  deleteProductVariant(id: ID!): DeletionResponse!
}

"""Delete multiple ProductVariants"""
type Mutation {
  deleteProductVariants(ids: [ID!]!): [DeletionResponse!]!
}

"""Delete multiple Products"""
type Mutation {
  deleteProducts(ids: [ID!]!): [DeletionResponse!]!
}

type Mutation {
  deletePromotion(id: ID!): DeletionResponse!
}

type Mutation {
  deletePromotions(ids: [ID!]!): [DeletionResponse!]!
}

"""Delete a Province"""
type Mutation {
  deleteProvince(id: ID!): DeletionResponse!
}

"""Delete an existing Role"""
type Mutation {
  deleteRole(id: ID!): DeletionResponse!
}

"""Delete multiple Roles"""
type Mutation {
  deleteRoles(ids: [ID!]!): [DeletionResponse!]!
}

"""Delete a Seller"""
type Mutation {
  deleteSeller(id: ID!): DeletionResponse!
}

"""Delete multiple Sellers"""
type Mutation {
  deleteSellers(ids: [ID!]!): [DeletionResponse!]!
}

"""Delete a ShippingMethod"""
type Mutation {
  deleteShippingMethod(id: ID!): DeletionResponse!
}

"""Delete multiple ShippingMethods"""
type Mutation {
  deleteShippingMethods(ids: [ID!]!): [DeletionResponse!]!
}

type Mutation {
  deleteStockLocation(input: DeleteStockLocationInput!): DeletionResponse!
}

type Mutation {
  deleteStockLocations(input: [DeleteStockLocationInput!]!): [DeletionResponse!]!
}

"""Delete an existing Tag"""
type Mutation {
  deleteTag(id: ID!): DeletionResponse!
}

"""Deletes multiple TaxCategories"""
type Mutation {
  deleteTaxCategories(ids: [ID!]!): [DeletionResponse!]!
}

"""Deletes a TaxCategory"""
type Mutation {
  deleteTaxCategory(id: ID!): DeletionResponse!
}

"""Delete a TaxRate"""
type Mutation {
  deleteTaxRate(id: ID!): DeletionResponse!
}

"""Delete multiple TaxRates"""
type Mutation {
  deleteTaxRates(ids: [ID!]!): [DeletionResponse!]!
}

"""Delete a Zone"""
type Mutation {
  deleteZone(id: ID!): DeletionResponse!
}

"""Delete a Zone"""
type Mutation {
  deleteZones(ids: [ID!]!): [DeletionResponse!]!
}

"""
Duplicate an existing entity using a specific EntityDuplicator.
Since v2.2.0.
"""
type Mutation {
  duplicateEntity(input: DuplicateEntityInput!): DuplicateEntityResult!
}

type Mutation {
  flushBufferedJobs(bufferIds: [String!]): Success!
}

type Mutation {
  importProducts(csvFile: Upload!): ImportInfo
}

"""
Authenticates the user using the native authentication strategy. This mutation is an alias for authenticate({ native: { ... }})

The `rememberMe` option applies when using cookie-based sessions, and if `true` it will set the maxAge of the session cookie
to 1 year.
"""
type Mutation {
  login(username: String!, password: String!, rememberMe: Boolean): NativeAuthenticationResult!
}

type Mutation {
  logout: Success!
}

"""
Allows an Order to be modified after it has been completed by the Customer. The Order must first
be in the `Modifying` state.
"""
type Mutation {
  modifyOrder(input: ModifyOrderInput!): ModifyOrderResult!
}

"""Move a Collection to a different parent or index"""
type Mutation {
  moveCollection(input: MoveCollectionInput!): Collection!
}

type Mutation {
  refundOrder(input: RefundOrderInput!): RefundOrderResult!
}

type Mutation {
  reindex: Job!
}

"""Removes Collections from the specified Channel"""
type Mutation {
  removeCollectionsFromChannel(input: RemoveCollectionsFromChannelInput!): [Collection!]!
}

"""Removes the given coupon code from the draft Order"""
type Mutation {
  removeCouponCodeFromDraftOrder(orderId: ID!, couponCode: String!): Order
}

"""Remove Customers from a CustomerGroup"""
type Mutation {
  removeCustomersFromGroup(customerGroupId: ID!, customerIds: [ID!]!): CustomerGroup!
}

"""Remove an OrderLine from the draft Order"""
type Mutation {
  removeDraftOrderLine(orderId: ID!, orderLineId: ID!): RemoveOrderItemsResult!
}

"""Removes Facets from the specified Channel"""
type Mutation {
  removeFacetsFromChannel(input: RemoveFacetsFromChannelInput!): [RemoveFacetFromChannelResult!]!
}

"""Remove members from a Zone"""
type Mutation {
  removeMembersFromZone(zoneId: ID!, memberIds: [ID!]!): Zone!
}

"""
Remove an OptionGroup from a Product. If the OptionGroup is in use by any ProductVariants
the mutation will return a ProductOptionInUseError, and the OptionGroup will not be removed.
Setting the `force` argument to `true` will override this and remove the OptionGroup anyway,
as well as removing any of the group's options from the Product's ProductVariants.
"""
type Mutation {
  removeOptionGroupFromProduct(productId: ID!, optionGroupId: ID!, force: Boolean): RemoveOptionGroupFromProductResult!
}

"""Removes PaymentMethods from the specified Channel"""
type Mutation {
  removePaymentMethodsFromChannel(input: RemovePaymentMethodsFromChannelInput!): [PaymentMethod!]!
}

"""Removes ProductOptionGroups from the specified Channel"""
type Mutation {
  removeProductOptionGroupsFromChannel(input: RemoveProductOptionGroupsFromChannelInput!): [RemoveProductOptionGroupFromChannelResult!]!
}

"""Removes ProductVariants from the specified Channel"""
type Mutation {
  removeProductVariantsFromChannel(input: RemoveProductVariantsFromChannelInput!): [ProductVariant!]!
}

"""Removes all ProductVariants of Product from the specified Channel"""
type Mutation {
  removeProductsFromChannel(input: RemoveProductsFromChannelInput!): [Product!]!
}

"""Removes Promotions from the specified Channel"""
type Mutation {
  removePromotionsFromChannel(input: RemovePromotionsFromChannelInput!): [Promotion!]!
}

"""
Revokes each Role on the given Channel from the User, under the same rules as
assignRolesToUser. Revoking SuperAdmin removes it on every Channel; the sole SuperAdmin
cannot lose it.
"""
type Mutation {
  removeRolesFromUser(input: RemoveRolesFromUserInput!): User!
}

"""Remove all settled jobs in the given queues older than the given date. Returns the number of jobs deleted."""
type Mutation {
  removeSettledJobs(queueNames: [String!], olderThan: DateTime): Int!
}

"""Removes ShippingMethods from the specified Channel"""
type Mutation {
  removeShippingMethodsFromChannel(input: RemoveShippingMethodsFromChannelInput!): [ShippingMethod!]!
}

"""Removes StockLocations from the specified Channel"""
type Mutation {
  removeStockLocationsFromChannel(input: RemoveStockLocationsFromChannelInput!): [StockLocation!]!
}

"""
Requests a password reset email to be sent to the Customer, the same as the Customer calling
`requestPasswordReset` from the Shop API: it sets a reset token and publishes a
`PasswordResetEvent`, which the EmailPlugin uses to send the email. The event carries the
administrator's RequestContext, so the email uses the administrator's language.

When `authOptions.requireVerification` is on, a Customer who has not verified their account is
marked as verified when they complete the reset. No `AccountVerifiedEvent` is published.

Throws for a Customer with no User (a guest checkout), and for a User with no native
authentication method, since neither has a native credential to reset.
"""
type Mutation {
  requestCustomerPasswordReset(id: ID!): Success!
}

"""
Requests a password reset email to be sent to the Administrator with the given email address. To
prevent leaking information about which email addresses exist, the mutation resolves to `Success`
even if no Administrator with that email address was found.
"""
type Mutation {
  requestPasswordReset(emailAddress: String!): RequestPasswordResetResult
}

"""
Resets an Administrator's password based on the provided token, which is obtained via the email
sent as a result of the `requestPasswordReset` mutation. Upon success, the Administrator will be
signed in.
"""
type Mutation {
  resetPassword(token: String!, password: String!): ResetPasswordResult!
}

"""
Replaces the old with a new API-Key.
This is a convenience method to invalidate an API-Key without
deleting the underlying roles and permissions.
"""
type Mutation {
  rotateApiKey(id: ID!): RotateApiKeyResult!
}

type Mutation {
  runPendingSearchIndexUpdates: Success!
}

type Mutation {
  runScheduledTask(id: String!): Success!
}

"""Upload, replace or remove the active Administrator's profile picture"""
type Mutation {
  setActiveAdministratorAvatar(file: Upload): Administrator!
}

type Mutation {
  setCustomerForDraftOrder(orderId: ID!, customerId: ID, input: CreateCustomerInput): SetCustomerForDraftOrderResult!
}

"""Sets the billing address for a draft Order"""
type Mutation {
  setDraftOrderBillingAddress(orderId: ID!, input: CreateAddressInput!): Order!
}

"""Allows any custom fields to be set for the active order"""
type Mutation {
  setDraftOrderCustomFields(orderId: ID!, input: UpdateOrderInput!): Order!
}

"""Sets the shipping address for a draft Order"""
type Mutation {
  setDraftOrderShippingAddress(orderId: ID!, input: CreateAddressInput!): Order!
}

"""Sets the shipping method by id, which can be obtained with the `eligibleShippingMethodsForDraftOrder` query"""
type Mutation {
  setDraftOrderShippingMethod(orderId: ID!, shippingMethodId: ID!): SetOrderShippingMethodResult!
}

type Mutation {
  setOrderCustomFields(input: UpdateOrderInput!): Order
}

"""Allows a different Customer to be assigned to an Order. Added in v2.2.0."""
type Mutation {
  setOrderCustomer(input: SetOrderCustomerInput!): Order
}

"""Set a single key-value pair (automatically scoped based on field configuration)"""
type Mutation {
  setSettingsStoreValue(input: SettingsStoreInput!): SetSettingsStoreValueResult!
}

"""Set multiple key-value pairs in a transaction (each automatically scoped)"""
type Mutation {
  setSettingsStoreValues(inputs: [SettingsStoreInput!]!): [SetSettingsStoreValueResult!]!
}

type Mutation {
  settlePayment(id: ID!): SettlePaymentResult!
}

type Mutation {
  settleRefund(input: SettleRefundInput!): SettleRefundResult!
}

type Mutation {
  transitionFulfillmentToState(id: ID!, state: String!): TransitionFulfillmentToStateResult!
}

type Mutation {
  transitionOrderToState(id: ID!, state: String!): TransitionOrderToStateResult
}

type Mutation {
  transitionPaymentToState(id: ID!, state: String!): TransitionPaymentToStateResult!
}

"""Unsets the billing address for a draft Order"""
type Mutation {
  unsetDraftOrderBillingAddress(orderId: ID!): Order!
}

"""Unsets the shipping address for a draft Order"""
type Mutation {
  unsetDraftOrderShippingAddress(orderId: ID!): Order!
}

"""Update the active (currently logged-in) Administrator"""
type Mutation {
  updateActiveAdministrator(input: UpdateActiveAdministratorInput!): Administrator!
}

"""Update an existing Administrator"""
type Mutation {
  updateAdministrator(input: UpdateAdministratorInput!): Administrator!
}

"""Updates an API-Key"""
type Mutation {
  updateApiKey(input: UpdateApiKeyInput!): ApiKey!
}

"""Update an existing Asset"""
type Mutation {
  updateAsset(input: UpdateAssetInput!): Asset!
}

"""Update an existing Channel"""
type Mutation {
  updateChannel(input: UpdateChannelInput!): UpdateChannelResult!
}

"""Update an existing Collection"""
type Mutation {
  updateCollection(input: UpdateCollectionInput!): Collection!
}

"""Update an existing Country"""
type Mutation {
  updateCountry(input: UpdateCountryInput!): Country!
}

"""Update an existing Customer"""
type Mutation {
  updateCustomer(input: UpdateCustomerInput!): UpdateCustomerResult!
}

"""Update an existing Address"""
type Mutation {
  updateCustomerAddress(input: UpdateAddressInput!): Address!
}

"""Update an existing CustomerGroup"""
type Mutation {
  updateCustomerGroup(input: UpdateCustomerGroupInput!): CustomerGroup!
}

type Mutation {
  updateCustomerNote(input: UpdateCustomerNoteInput!): HistoryEntry!
}

"""Update an existing Facet"""
type Mutation {
  updateFacet(input: UpdateFacetInput!): Facet!
}

"""Update a single FacetValue"""
type Mutation {
  updateFacetValue(input: UpdateFacetValueInput!): FacetValue!
}

"""Update one or more FacetValues"""
type Mutation {
  updateFacetValues(input: [UpdateFacetValueInput!]!): [FacetValue!]!
}

type Mutation {
  updateGlobalSettings(input: UpdateGlobalSettingsInput!): UpdateGlobalSettingsResult!
}

type Mutation {
  updateOrderNote(input: UpdateOrderNoteInput!): HistoryEntry!
}

"""Update an existing PaymentMethod"""
type Mutation {
  updatePaymentMethod(input: UpdatePaymentMethodInput!): PaymentMethod!
}

"""Update an existing Product"""
type Mutation {
  updateProduct(input: UpdateProductInput!): Product!
}

"""Create a new ProductOption within a ProductOptionGroup"""
type Mutation {
  updateProductOption(input: UpdateProductOptionInput!): ProductOption!
}

"""Update an existing ProductOptionGroup"""
type Mutation {
  updateProductOptionGroup(input: UpdateProductOptionGroupInput!): ProductOptionGroup!
}

"""Update an existing ProductVariant"""
type Mutation {
  updateProductVariant(input: UpdateProductVariantInput!): ProductVariant!
}

"""Update existing ProductVariants"""
type Mutation {
  updateProductVariants(input: [UpdateProductVariantInput!]!): [ProductVariant]!
}

"""Update multiple existing Products"""
type Mutation {
  updateProducts(input: [UpdateProductInput!]!): [Product!]!
}

type Mutation {
  updatePromotion(input: UpdatePromotionInput!): UpdatePromotionResult!
}

"""Update an existing Province"""
type Mutation {
  updateProvince(input: UpdateProvinceInput!): Province!
}

"""Update an existing Role"""
type Mutation {
  updateRole(input: UpdateRoleInput!): Role!
}

type Mutation {
  updateScheduledTask(input: UpdateScheduledTaskInput!): ScheduledTask!
}

"""Update an existing Seller"""
type Mutation {
  updateSeller(input: UpdateSellerInput!): Seller!
}

"""Update an existing ShippingMethod"""
type Mutation {
  updateShippingMethod(input: UpdateShippingMethodInput!): ShippingMethod!
}

type Mutation {
  updateStockLocation(input: UpdateStockLocationInput!): StockLocation!
}

"""Update an existing Tag"""
type Mutation {
  updateTag(input: UpdateTagInput!): Tag!
}

"""Update an existing TaxCategory"""
type Mutation {
  updateTaxCategory(input: UpdateTaxCategoryInput!): TaxCategory!
}

"""Update an existing TaxRate"""
type Mutation {
  updateTaxRate(input: UpdateTaxRateInput!): TaxRate!
}

"""Update an existing Zone"""
type Mutation {
  updateZone(input: UpdateZoneInput!): Zone!
}

"""
Manually mark a Customer's email address as verified, without the Customer having to use a
verification email.

A Customer with no password set (as created by `createCustomer` without one) cannot log in.
Omitting `password` for such a Customer returns a `MissingPasswordError`. Passing one for a
Customer who already has a password returns a `PasswordAlreadySetError`.

Two failures are outside the result union, because they describe a Customer the caller should
not have picked rather than a password they should correct: a Customer with no User at all (a
guest checkout), and a User whose only credential is external, which a password cannot be
stored on. Both throw.
"""
type Mutation {
  verifyCustomerAccount(id: ID!, password: String): VerifyCustomerAccountResult!
}