Mutations

"""Add Customers to a CustomerGroup"""
type Mutation {
  addCustomersToGroup(customerGroupId: ID!, customerIds: [ID!]!): CustomerGroup!
}

type Mutation {
  addFulfillmentToOrder(input: FulfillOrderInput!): AddFulfillmentToOrderResult!
}

"""Adds an item to the draft Order."""
type Mutation {
  addItemToDraftOrder(orderId: ID!, input: AddItemToDraftOrderInput!): UpdateOrderItemsResult!
}

"""
Used to manually create a new Payment against an Order.
This can be used by an Administrator when an Order is in the ArrangingPayment state.

It is also used when a completed Order
has been modified (using `modifyOrder`) and the price has increased. The extra payment
can then be manually arranged by the administrator, and the details used to create a new
Payment.
"""
type Mutation {
  addManualPaymentToOrder(input: ManualPaymentInput!): AddManualPaymentToOrderResult!
}

"""Add members to a Zone"""
type Mutation {
  addMembersToZone(zoneId: ID!, memberIds: [ID!]!): Zone!
}

type Mutation {
  addNoteToCustomer(input: AddNoteToCustomerInput!): Customer!
}

type Mutation {
  addNoteToOrder(input: AddNoteToOrderInput!): Order!
}

"""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!
}

"""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!
}

"""Create a set of ProductVariants based on the OptionGroups assigned to the given Product"""
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!]!
}

"""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 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!
}