Skip to main content

Mutations

addCustomersToGroup​

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

addFulfillmentToOrder​

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

addItemToDraftOrder​

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

addManualPaymentToOrder​

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

addMembersToZone​

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

addNoteToCustomer​

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

addNoteToOrder​

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

addOptionGroupToProduct​

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

adjustDraftOrderLine​

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

applyCouponCodeToDraftOrder​

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

assignAssetsToChannel​

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

assignCollectionsToChannel​

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

assignFacetsToChannel​

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

assignPaymentMethodsToChannel​

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

assignProductVariantsToChannel​

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

assignProductsToChannel​

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

assignPromotionsToChannel​

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

assignRoleToAdministrator​

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

assignShippingMethodsToChannel​

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

assignStockLocationsToChannel​

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

authenticate​

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

cancelJob​

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

cancelOrder​

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

cancelPayment​

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

createAdministrator​

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

createAssets​

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

createChannel​

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

createCollection​

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

createCountry​

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

createCustomer​

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

createCustomerAddress​

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

createCustomerGroup​

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

createDraftOrder​

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

createFacet​

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

createFacetValues​

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

createPaymentMethod​

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

createProduct​

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

createProductOption​

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

createProductOptionGroup​

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

createProductVariants​

"""
Create a set of ProductVariants based on the OptionGroups assigned to the given Product
"""
type Mutation {
createProductVariants(input: [CreateProductVariantInput!]!): [ProductVariant]!
}

createPromotion​

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

createProvince​

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

createRole​

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

createSeller​

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

createShippingMethod​

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

createStockLocation​

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

createTag​

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

createTaxCategory​

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

createTaxRate​

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

createZone​

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

deleteAdministrator​

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

deleteAdministrators​

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

deleteAsset​

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

deleteAssets​

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

deleteChannel​

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

deleteChannels​

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

deleteCollection​

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

deleteCollections​

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

deleteCountries​

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

deleteCountry​

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

deleteCustomer​

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

deleteCustomerAddress​

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

deleteCustomerGroup​

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

deleteCustomerGroups​

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

deleteCustomerNote​

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

deleteCustomers​

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

deleteDraftOrder​

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

deleteFacet​

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

deleteFacetValues​

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

deleteFacets​

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

deleteOrderNote​

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

deletePaymentMethod​

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

deletePaymentMethods​

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

deleteProduct​

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

deleteProductOption​

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

deleteProductVariant​

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

deleteProductVariants​

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

deleteProducts​

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

deletePromotion​

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

deletePromotions​

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

deleteProvince​

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

deleteRole​

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

deleteRoles​

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

deleteSeller​

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

deleteSellers​

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

deleteShippingMethod​

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

deleteShippingMethods​

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

deleteStockLocation​

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

deleteStockLocations​

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

deleteTag​

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

deleteTaxCategories​

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

deleteTaxCategory​

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

deleteTaxRate​

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

deleteTaxRates​

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

deleteZone​

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

deleteZones​

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

duplicateEntity​

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

flushBufferedJobs​

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

importProducts​

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

login​

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

logout​

type Mutation {
logout: Success!
}

modifyOrder​

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

moveCollection​

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

refundOrder​

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

reindex​

type Mutation {
reindex: Job!
}

removeCollectionsFromChannel​

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

removeCouponCodeFromDraftOrder​

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

removeCustomersFromGroup​

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

removeDraftOrderLine​

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

removeFacetsFromChannel​

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

removeMembersFromZone​

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

removeOptionGroupFromProduct​

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

removePaymentMethodsFromChannel​

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

removeProductVariantsFromChannel​

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

removeProductsFromChannel​

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

removePromotionsFromChannel​

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

removeSettledJobs​

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

removeShippingMethodsFromChannel​

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

removeStockLocationsFromChannel​

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

runPendingSearchIndexUpdates​

type Mutation {
runPendingSearchIndexUpdates: Success!
}

setCustomerForDraftOrder​

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

setDraftOrderBillingAddress​

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

setDraftOrderCustomFields​

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

setDraftOrderShippingAddress​

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

setDraftOrderShippingMethod​

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

setOrderCustomFields​

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

setOrderCustomer​

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

settlePayment​

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

settleRefund​

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

transitionFulfillmentToState​

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

transitionOrderToState​

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

transitionPaymentToState​

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

updateActiveAdministrator​

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

updateAdministrator​

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

updateAsset​

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

updateChannel​

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

updateCollection​

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

updateCountry​

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

updateCustomer​

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

updateCustomerAddress​

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

updateCustomerGroup​

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

updateCustomerNote​

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

updateFacet​

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

updateFacetValues​

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

updateGlobalSettings​

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

updateOrderNote​

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

updatePaymentMethod​

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

updateProduct​

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

updateProductOption​

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

updateProductOptionGroup​

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

updateProductVariants​

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

updateProducts​

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

updatePromotion​

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

updateProvince​

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

updateRole​

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

updateSeller​

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

updateShippingMethod​

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

updateStockLocation​

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

updateTag​

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

updateTaxCategory​

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

updateTaxRate​

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

updateZone​

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