@jetshop/core 3.13.5-non-polyfill → 3.13.5

package/types.d.ts

@@ -6,15 +6,37 @@ export type Scalars = {
   Boolean: boolean;
   Int: number;
   Float: number;
-  Decimal: any;
   Uri: any;
+  /** The `Paging` scalar type represents a numeric values between (0; 100> */
+  Paging: any;
+  Decimal: any;
   /** The `DateTime` scalar type represents a date and time. `DateTime` expects
    * timestamps to be formatted in accordance with the
    * [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standard.
    */
   DateTime: any;
-  /** The `Paging` scalar type represents a numeric values between <1; 100> */
-  Paging: any;
+  BigInt: any;
+  Byte: any;
+  /** The `Date` scalar type represents a year, month and day in accordance with the
+   * [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standard.
+   */
+  Date: any;
+  /** The `DateTimeOffset` scalar type represents a date, time and offset from UTC.
+   * `DateTimeOffset` expects timestamps to be formatted in accordance with the
+   * [ISO-8601](https://en.wikipedia.org/wiki/ISO_8601) standard.
+   */
+  DateTimeOffset: any;
+  Guid: any;
+  Long: any;
+  /** The `Milliseconds` scalar type represents a period of time represented as the total number of milliseconds. */
+  Milliseconds: any;
+  SByte: any;
+  /** The `Seconds` scalar type represents a period of time represented as the total number of seconds. */
+  Seconds: any;
+  Short: any;
+  UInt: any;
+  ULong: any;
+  UShort: any;
 };
 
 export type ActivateExternalCustomerByIdInput = {
@@ -33,16 +55,15 @@ export type ActivateExternalCustomerByTokenInput = {
 
 export type ActivateExternalCustomerByTokenResult = {
   __typename?: 'ActivateExternalCustomerByTokenResult';
-  success: Scalars['Boolean'];
   customer?: Maybe<ExternalCustomer>;
+  success: Scalars['Boolean'];
 };
 
 export enum ActivationStatusSource {
   PreexistingCustomer = 'PREEXISTING_CUSTOMER',
   ActivationRequired = 'ACTIVATION_REQUIRED',
   AdditionalUserDataRequired = 'ADDITIONAL_USER_DATA_REQUIRED',
-  NonExistingCustomer = 'NON_EXISTING_CUSTOMER',
-  CountryNotValid = 'COUNTRY_NOT_VALID'
+  NonExistingCustomer = 'NON_EXISTING_CUSTOMER'
 }
 
 export type ActiveFilters = {
@@ -81,10 +102,10 @@ export type AddToCustomerProductListInput = {
 
 export type AlternateRoute = {
   __typename?: 'AlternateRoute';
+  alias?: Maybe<Scalars['String']>;
   channelId?: Maybe<Scalars['Int']>;
   culture?: Maybe<Scalars['String']>;
   route?: Maybe<Scalars['String']>;
-  alias?: Maybe<Scalars['String']>;
 };
 
 export type BooleanFilter = Filter & {
@@ -101,33 +122,28 @@ export type BooleanFilterInput = {
   value?: Maybe<Scalars['Boolean']>;
 };
 
-export type BoolValue = {
-  __typename?: 'BoolValue';
-  value?: Maybe<Scalars['Boolean']>;
-};
-
 export type BusinessCustomer = Customer & {
   __typename?: 'BusinessCustomer';
-  organizationId?: Maybe<Scalars['String']>;
-  organizationNumber?: Maybe<Scalars['String']>;
-  id: Scalars['ID'];
-  memberId?: Maybe<Scalars['String']>;
+  billingAddress?: Maybe<CustomerAddress>;
+  communication?: Maybe<CustomerCommunication>;
+  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
+  dynamicContent?: Maybe<Scalars['String']>;
   email?: Maybe<Scalars['String']>;
+  externalAttributes?: Maybe<Array<Maybe<CustomerExternalAttribute>>>;
   /** Customer id for external system */
   externalId?: Maybe<Scalars['String']>;
-  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  googleUserId?: Maybe<Scalars['String']>;
+  id: Scalars['ID'];
   language?: Maybe<Language>;
-  billingAddress?: Maybe<CustomerAddress>;
-  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
+  memberId?: Maybe<Scalars['String']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   orderHeaders?: Maybe<OrderHeaderResult>;
-  communication?: Maybe<CustomerCommunication>;
+  organizationId?: Maybe<Scalars['String']>;
+  organizationNumber?: Maybe<Scalars['String']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   store?: Maybe<Store>;
-  dynamicContent?: Maybe<Scalars['String']>;
-  externalAttributes?: Maybe<Array<Maybe<CustomerExternalAttribute>>>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  googleUserId?: Maybe<Scalars['String']>;
+  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
 };
 
 export type BusinessCustomerOrderHeadersArgs = {
@@ -137,40 +153,40 @@ export type BusinessCustomerOrderHeadersArgs = {
 
 export type Cart = {
   __typename?: 'Cart';
-  id?: Maybe<Scalars['String']>;
-  totalQuantity?: Maybe<Scalars['Int']>;
-  productTotal?: Maybe<Price>;
-  productPreviousTotal?: Maybe<Price>;
-  discountTotal?: Maybe<Price>;
   aggregatedDiscounts?: Maybe<Array<Maybe<Discount>>>;
+  discountTotal?: Maybe<Price>;
   externalCheckoutUrl?: Maybe<Scalars['Uri']>;
+  id?: Maybe<Scalars['String']>;
   items?: Maybe<Array<Maybe<CartItem>>>;
+  productPreviousTotal?: Maybe<Price>;
+  productTotal?: Maybe<Price>;
+  totalQuantity?: Maybe<Scalars['Int']>;
 };
 
 export type CartItem = {
   __typename?: 'CartItem';
-  id: Scalars['String'];
-  quantity: Scalars['Int'];
   articleNumber: Scalars['String'];
-  images?: Maybe<Array<Maybe<ProductImage>>>;
-  subHeading?: Maybe<Scalars['String']>;
-  variant?: Maybe<ProductVariant>;
-  variantOptionNames?: Maybe<Array<Maybe<Scalars['String']>>>;
+  configurations?: Maybe<Array<Maybe<SelectedProductConfiguration>>>;
   customerComments?: Maybe<Array<Maybe<CartItemComment>>>;
+  /** Discount total */
+  discount?: Maybe<Price>;
   discounts?: Maybe<Array<Maybe<Discount>>>;
-  /** Total price, including discounts */
-  total: Price;
+  id: Scalars['String'];
+  images?: Maybe<Array<Maybe<ProductImage>>>;
+  preOrderDate?: Maybe<Scalars['DateTime']>;
   /** Total price, excluding discounts */
   previousTotal: Price;
-  /** Unit price, including discounts */
-  unitPrice: Price;
   /** Unit price, excluding discounts */
   previousUnitPrice: Price;
-  /** Discount total */
-  discount?: Maybe<Price>;
   product?: Maybe<Product>;
-  configurations?: Maybe<Array<Maybe<SelectedProductConfiguration>>>;
-  preOrderDate?: Maybe<Scalars['DateTime']>;
+  quantity: Scalars['Int'];
+  subHeading?: Maybe<Scalars['String']>;
+  /** Total price, including discounts */
+  total: Price;
+  /** Unit price, including discounts */
+  unitPrice: Price;
+  variant?: Maybe<ProductVariant>;
+  variantOptionNames?: Maybe<Array<Maybe<Scalars['String']>>>;
 };
 
 export type CartItemComment = {
@@ -186,52 +202,35 @@ export type CartMutation = {
 
 export type Category = Document & {
   __typename?: 'Category';
-  id: Scalars['Int'];
-  parentId?: Maybe<Scalars['Int']>;
-  name: Scalars['String'];
-  level: Scalars['Int'];
-  /** The time interval of the campaign/category */
-  activeDateSpan?: Maybe<CategoryActiveDateSpan>;
-  /** Whether or not this category and all its children are considered hidden */
-  isHidden: Scalars['Boolean'];
-  /** When empty will display the value of the name field */
-  mainHeader?: Maybe<Scalars['String']>;
+  breadcrumbText?: Maybe<Scalars['String']>;
   content?: Maybe<Scalars['String']>;
-  externalId?: Maybe<Scalars['String']>;
-  externalDiscountId?: Maybe<Scalars['String']>;
-  images?: Maybe<Array<Maybe<CategoryImage>>>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  products?: Maybe<PagedResult>;
+  hasSubcategories?: Maybe<Scalars['Boolean']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   head?: Maybe<HtmlHead>;
-  /** The primary route of this Category. NB: Carries a performance cost, as asking
-   * for this will result in a separate API call in the backend.
-   */
-  primaryRoute?: Maybe<Route>;
-  breadcrumbText?: Maybe<Scalars['String']>;
-  hasSubcategories?: Maybe<Scalars['Boolean']>;
-  subcategories?: Maybe<Array<Maybe<Category>>>;
-  parentCategory?: Maybe<Category>;
-  parent?: Maybe<Category>;
+  id: Scalars['Int'];
+  images?: Maybe<Array<Maybe<CategoryImage>>>;
   /** A dynamic category has no fixed products; products are dynamically included
    * based on filters defined on the category in Admin. N.B. Products found on a
    * dynamic category has no route that includes said category, instead
    * product.primaryRoute will have to be used.
    */
   isDynamic: Scalars['Boolean'];
-  /** The category's dynamic filtersNB: Carries a performance cost, as asking for
-   * this will result in a separate API call in the backend.
-   */
-  dynamicFiltering?: Maybe<Array<Maybe<CategoryDynamicFilter>>>;
-  /** Get content data set via the Content Editor. NB: Carries a performance cost,
-   * as asking for this will result in a separate API call in the backend.
-   */
-  data?: Maybe<Content>;
-  /** When set to false, the category will be excluded from sitemap. The frontend
-   * implementation should use this value to set meta tags to exclude the category
-   * from being indexed by crawlers. Defaults to true.
+  /** Whether or not this category and all its children are considered hidden */
+  isHidden: Scalars['Boolean'];
+  level: Scalars['Int'];
+  /** When empty will display the value of the name field */
+  mainHeader?: Maybe<Scalars['String']>;
+  name: Scalars['String'];
+  parent?: Maybe<Category>;
+  parentCategory?: Maybe<Category>;
+  parentId?: Maybe<Scalars['Int']>;
+  /** The primary route of this Category. NB: Carries a performance cost, as asking
+   * for this will result in a separate API call in the backend.
    */
-  allowWebIndexing?: Maybe<Scalars['Boolean']>;
+  primaryRoute?: Maybe<Route>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  products?: Maybe<PagedResult>;
+  subcategories?: Maybe<Array<Maybe<Category>>>;
 };
 
 export type CategoryProductsArgs = {
@@ -242,33 +241,16 @@ export type CategoryProductsArgs = {
   filters?: Maybe<FilterInput>;
 };
 
-export type CategoryActiveDateSpan = {
-  __typename?: 'CategoryActiveDateSpan';
-  startDate?: Maybe<Scalars['DateTime']>;
-  endDate?: Maybe<Scalars['DateTime']>;
-};
-
 export type CategoryAutoCompleteResult = {
   __typename?: 'CategoryAutoCompleteResult';
   result?: Maybe<Array<Maybe<Category>>>;
 };
 
-export type CategoryDynamicFilter = {
-  __typename?: 'CategoryDynamicFilter';
-  type?: Maybe<Scalars['String']>;
-  value?: Maybe<CategoryDynamicFilterValue>;
-};
-
-export type CategoryDynamicFilterValue =
-  | StringValue
-  | ListStringValue
-  | BoolValue;
-
 export type CategoryImage = {
   __typename?: 'CategoryImage';
-  width?: Maybe<Scalars['Int']>;
   height?: Maybe<Scalars['Int']>;
   url?: Maybe<Scalars['Uri']>;
+  width?: Maybe<Scalars['Int']>;
 };
 
 export type CategorySearchResult = {
@@ -287,83 +269,63 @@ export type ChangeByOneItemQuantityInput = {
  */
 export type Channel = {
   __typename?: 'Channel';
-  id: Scalars['Int'];
-  name?: Maybe<Scalars['String']>;
-  displayName?: Maybe<Scalars['String']>;
-  groupName?: Maybe<Scalars['String']>;
-  isDefault?: Maybe<Scalars['Boolean']>;
-  url?: Maybe<Scalars['Uri']>;
-  settings?: Maybe<ChannelSettings>;
-  languages?: Maybe<Array<Maybe<Language>>>;
-  defaultLanguage?: Maybe<Language>;
+  countries?: Maybe<Array<Maybe<Country>>>;
   currencies?: Maybe<Array<Maybe<Currency>>>;
   defaultCurrency?: Maybe<Currency>;
-  countries?: Maybe<Array<Maybe<Country>>>;
+  defaultLanguage?: Maybe<Language>;
+  displayName?: Maybe<Scalars['String']>;
+  groupName?: Maybe<Scalars['String']>;
+  id: Scalars['Int'];
   /** The root url of images, this can be used to build image urls if needed. */
   imageUrl?: Maybe<Scalars['String']>;
+  isDefault?: Maybe<Scalars['Boolean']>;
+  languages?: Maybe<Array<Maybe<Language>>>;
+  name?: Maybe<Scalars['String']>;
   /** This channel requires a user to be authorized. */
   requiresAuth?: Maybe<Scalars['Boolean']>;
+  settings?: Maybe<ChannelSettings>;
+  url?: Maybe<Scalars['Uri']>;
 };
 
 export type ChannelSettings = {
   __typename?: 'ChannelSettings';
-  pricesIncVat?: Maybe<Scalars['Boolean']>;
   countrySettings?: Maybe<Array<Maybe<CountrySettings>>>;
-  tracking?: Maybe<Tracking>;
   nostoAccountId?: Maybe<Scalars['String']>;
+  pricesIncVat?: Maybe<Scalars['Boolean']>;
+  tracking?: Maybe<Tracking>;
 };
 
 export type Consent = {
   __typename?: 'Consent';
   id: Scalars['ID'];
-  name?: Maybe<Scalars['String']>;
-  title?: Maybe<Scalars['String']>;
-  text?: Maybe<Scalars['String']>;
+  isMandatory?: Maybe<Scalars['Boolean']>;
   linkText?: Maybe<Scalars['String']>;
+  name?: Maybe<Scalars['String']>;
   page?: Maybe<Page>;
-  isMandatory?: Maybe<Scalars['Boolean']>;
+  text?: Maybe<Scalars['String']>;
+  title?: Maybe<Scalars['String']>;
 };
 
 export type Content = {
   __typename?: 'Content';
-  name?: Maybe<Scalars['String']>;
   id: Scalars['ID'];
   items?: Maybe<Array<Maybe<ContentItem>>>;
-  tags?: Maybe<Array<Maybe<Scalars['String']>>>;
 };
 
 export type ContentItem = {
   __typename?: 'ContentItem';
-  name?: Maybe<Scalars['String']>;
-  type: Scalars['String'];
+  name: Scalars['String'];
   properties?: Maybe<Array<Maybe<ContentItemProperty>>>;
-  children?: Maybe<Array<Maybe<ContentItem>>>;
-};
-
-export type ContentItemPropertiesArgs = {
-  getImageAsImageValue?: Maybe<Scalars['Boolean']>;
+  type: Scalars['String'];
 };
 
 export type ContentItemProperty = {
   __typename?: 'ContentItemProperty';
   name: Scalars['String'];
   type: Scalars['String'];
-  valueType?: Maybe<ContentPropertyValueType>;
-  value?: Maybe<ContentItemPropertyValue>;
+  value?: Maybe<Scalars['String']>;
 };
 
-export type ContentItemPropertyValue =
-  | StringValue
-  | ImageValue
-  | BoolValue
-  | Product
-  | Category;
-
-export enum ContentPropertyValueType {
-  Object = 'OBJECT',
-  Scalar = 'SCALAR'
-}
-
 export type Coordinates = {
   __typename?: 'Coordinates';
   latitude: Scalars['Decimal'];
@@ -372,33 +334,33 @@ export type Coordinates = {
 
 export type Country = {
   __typename?: 'Country';
-  id: Scalars['ID'];
   code?: Maybe<Scalars['String']>;
-  name?: Maybe<Scalars['String']>;
+  id: Scalars['ID'];
   isDefault?: Maybe<Scalars['Boolean']>;
+  name?: Maybe<Scalars['String']>;
 };
 
 export type CountrySettings = {
   __typename?: 'CountrySettings';
-  countryCode: Scalars['String'];
-  paymentTypes?: Maybe<Array<Maybe<PaymentType>>>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  privateCustomerFields?: Maybe<Array<Maybe<CustomerField>>>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  businessCustomerFields?: Maybe<Array<Maybe<CustomerField>>>;
-  shipping?: Maybe<Shipping>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend.
    *
    * This will use localization, and will work well when requesting one `channel`,
    * but may give unpredictable results when getting multiple channels via `channels`
    */
-  privateCustomerConsents?: Maybe<Array<Maybe<Consent>>>;
+  businessCustomerConsents?: Maybe<Array<Maybe<Consent>>>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  businessCustomerFields?: Maybe<Array<Maybe<CustomerField>>>;
+  countryCode: Scalars['String'];
+  paymentTypes?: Maybe<Array<Maybe<PaymentType>>>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend.
    *
    * This will use localization, and will work well when requesting one `channel`,
    * but may give unpredictable results when getting multiple channels via `channels`
    */
-  businessCustomerConsents?: Maybe<Array<Maybe<Consent>>>;
+  privateCustomerConsents?: Maybe<Array<Maybe<Consent>>>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  privateCustomerFields?: Maybe<Array<Maybe<CustomerField>>>;
+  shipping?: Maybe<Shipping>;
 };
 
 export type CreateCustomerProductListInput = {
@@ -410,46 +372,46 @@ export type CreateCustomerProductListInput = {
 
 export type Currency = {
   __typename?: 'Currency';
+  format?: Maybe<CurrencyFormat>;
   id: Scalars['String'];
-  name?: Maybe<Scalars['String']>;
   isDefault?: Maybe<Scalars['Boolean']>;
-  format?: Maybe<CurrencyFormat>;
+  name?: Maybe<Scalars['String']>;
 };
 
 export type CurrencyFormat = {
   __typename?: 'CurrencyFormat';
-  culture: Scalars['String'];
   code: Scalars['String'];
+  culture: Scalars['String'];
   decimals: Scalars['Int'];
 };
 
 export type CustomBoolField = CustomField & {
   __typename?: 'CustomBoolField';
-  value: Scalars['Boolean'];
-  type?: Maybe<ProductCustomFieldType>;
   key?: Maybe<Scalars['String']>;
   title?: Maybe<Scalars['String']>;
+  type?: Maybe<ProductCustomFieldType>;
+  value: Scalars['Boolean'];
 };
 
 export type Customer = {
-  id: Scalars['ID'];
-  memberId?: Maybe<Scalars['String']>;
+  billingAddress?: Maybe<CustomerAddress>;
+  communication?: Maybe<CustomerCommunication>;
+  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
+  dynamicContent?: Maybe<Scalars['String']>;
   email?: Maybe<Scalars['String']>;
+  externalAttributes?: Maybe<Array<Maybe<CustomerExternalAttribute>>>;
   /** Customer id for external system */
   externalId?: Maybe<Scalars['String']>;
-  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  googleUserId?: Maybe<Scalars['String']>;
+  id: Scalars['ID'];
   language?: Maybe<Language>;
-  billingAddress?: Maybe<CustomerAddress>;
-  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
+  memberId?: Maybe<Scalars['String']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   orderHeaders?: Maybe<OrderHeaderResult>;
-  communication?: Maybe<CustomerCommunication>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   store?: Maybe<Store>;
-  dynamicContent?: Maybe<Scalars['String']>;
-  externalAttributes?: Maybe<Array<Maybe<CustomerExternalAttribute>>>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  googleUserId?: Maybe<Scalars['String']>;
+  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
 };
 
 export type CustomerOrderHeadersArgs = {
@@ -459,22 +421,22 @@ export type CustomerOrderHeadersArgs = {
 
 export type CustomerAddress = {
   __typename?: 'CustomerAddress';
-  id?: Maybe<Scalars['Int']>;
   addressName?: Maybe<Scalars['String']>;
-  firstName?: Maybe<Scalars['String']>;
-  lastName?: Maybe<Scalars['String']>;
-  companyAtt?: Maybe<Scalars['String']>;
+  city?: Maybe<Scalars['String']>;
+  co?: Maybe<Scalars['String']>;
   company?: Maybe<Scalars['String']>;
+  companyAtt?: Maybe<Scalars['String']>;
+  country?: Maybe<Country>;
   department?: Maybe<Scalars['String']>;
-  streetName?: Maybe<Scalars['String']>;
-  co?: Maybe<Scalars['String']>;
-  postalCode?: Maybe<Scalars['String']>;
-  city?: Maybe<Scalars['String']>;
+  firstName?: Maybe<Scalars['String']>;
+  id?: Maybe<Scalars['Int']>;
+  lastName?: Maybe<Scalars['String']>;
+  mobilePhone?: Maybe<Scalars['String']>;
   municipality?: Maybe<Scalars['String']>;
-  region?: Maybe<Scalars['String']>;
-  country?: Maybe<Country>;
   phone?: Maybe<Scalars['String']>;
-  mobilePhone?: Maybe<Scalars['String']>;
+  postalCode?: Maybe<Scalars['String']>;
+  region?: Maybe<Scalars['String']>;
+  streetName?: Maybe<Scalars['String']>;
 };
 
 export type CustomerCommunication = {
@@ -492,21 +454,21 @@ export type CustomerExternalAttribute = {
 
 export type CustomerField = {
   __typename?: 'CustomerField';
-  id: Scalars['ID'];
-  required: Scalars['Boolean'];
-  pattern?: Maybe<Scalars['String']>;
   fields?: Maybe<Array<Maybe<CustomerField>>>;
+  id: Scalars['ID'];
   name: Scalars['ID'];
+  pattern?: Maybe<Scalars['String']>;
+  required: Scalars['Boolean'];
 };
 
 export type CustomerLoyalty = {
   __typename?: 'CustomerLoyalty';
   bonusChecks?: Maybe<Array<Maybe<CustomerLoyaltyBonusCheck>>>;
-  pointCards?: Maybe<Array<Maybe<CustomerLoyaltyPointCard>>>;
-  discounts?: Maybe<Array<Maybe<CustomerLoyaltyDiscount>>>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   bonusPoints?: Maybe<CustomerLoyaltyBonusPoints>;
-};
+  discounts?: Maybe<Array<Maybe<CustomerLoyaltyDiscount>>>;
+  pointCards?: Maybe<Array<Maybe<CustomerLoyaltyPointCard>>>;
+};
 
 export type CustomerLoyaltyDiscountsArgs = {
   includeRedeemed?: Scalars['Boolean'];
@@ -514,14 +476,14 @@ export type CustomerLoyaltyDiscountsArgs = {
 
 export type CustomerLoyaltyBonusCheck = {
   __typename?: 'CustomerLoyaltyBonusCheck';
+  /** For display purposes, not guaranteed to match up with a currency on the channel. */
+  currency?: Maybe<Scalars['String']>;
+  endDate?: Maybe<Scalars['DateTime']>;
   externalId?: Maybe<Scalars['String']>;
   name?: Maybe<Scalars['String']>;
-  startDate?: Maybe<Scalars['DateTime']>;
-  endDate?: Maybe<Scalars['DateTime']>;
   redeemed?: Maybe<Scalars['Boolean']>;
   redeemedOn?: Maybe<Scalars['DateTime']>;
-  /** For display purposes, not guaranteed to match up with a currency on the channel. */
-  currency?: Maybe<Scalars['String']>;
+  startDate?: Maybe<Scalars['DateTime']>;
   value?: Maybe<Scalars['Decimal']>;
 };
 
@@ -532,68 +494,68 @@ export type CustomerLoyaltyBonusPoints = {
 
 export type CustomerLoyaltyDiscount = {
   __typename?: 'CustomerLoyaltyDiscount';
-  name?: Maybe<Scalars['String']>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  category?: Maybe<Category>;
   description?: Maybe<Scalars['String']>;
-  startDate?: Maybe<Scalars['DateTime']>;
+  discountCode?: Maybe<Scalars['String']>;
   endDate?: Maybe<Scalars['DateTime']>;
   externalData?: Maybe<CustomerLoyaltyDiscountOfferExternalData>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  category?: Maybe<Category>;
   isActivatedByDiscountCode: Scalars['Boolean'];
-  discountCode?: Maybe<Scalars['String']>;
+  name?: Maybe<Scalars['String']>;
+  startDate?: Maybe<Scalars['DateTime']>;
 };
 
 export type CustomerLoyaltyDiscountOfferExternalData = {
   __typename?: 'CustomerLoyaltyDiscountOfferExternalData';
-  name?: Maybe<Scalars['String']>;
   description?: Maybe<Scalars['String']>;
-  startDate?: Maybe<Scalars['DateTime']>;
   endDate?: Maybe<Scalars['DateTime']>;
   externalId?: Maybe<Scalars['String']>;
   externalReference?: Maybe<Scalars['String']>;
   heading?: Maybe<Scalars['String']>;
-  redeemed?: Maybe<Scalars['Boolean']>;
-  redeemedOn?: Maybe<Scalars['DateTime']>;
   imageUrl?: Maybe<Scalars['String']>;
   link?: Maybe<Scalars['String']>;
+  name?: Maybe<Scalars['String']>;
+  redeemed?: Maybe<Scalars['Boolean']>;
+  redeemedOn?: Maybe<Scalars['DateTime']>;
+  startDate?: Maybe<Scalars['DateTime']>;
 };
 
 export type CustomerLoyaltyPointCard = {
   __typename?: 'CustomerLoyaltyPointCard';
   externalId?: Maybe<Scalars['String']>;
-  name?: Maybe<Scalars['String']>;
+  isActive?: Maybe<Scalars['Boolean']>;
   lastStampTime?: Maybe<Scalars['DateTime']>;
+  name?: Maybe<Scalars['String']>;
   numberOfSlots?: Maybe<Scalars['Int']>;
   numberOfSlotsRemaining?: Maybe<Scalars['Int']>;
-  isActive?: Maybe<Scalars['Boolean']>;
 };
 
 export type CustomerProductList = {
   __typename?: 'CustomerProductList';
+  description?: Maybe<Scalars['String']>;
   id: Scalars['ID'];
-  shareToken?: Maybe<Scalars['String']>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  items?: Maybe<Array<Maybe<CustomerProductListItem>>>;
   name?: Maybe<Scalars['String']>;
-  description?: Maybe<Scalars['String']>;
+  shareToken?: Maybe<Scalars['String']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   type?: Maybe<CustomerProductListType>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  items?: Maybe<Array<Maybe<CustomerProductListItem>>>;
 };
 
 export type CustomerProductListItem = {
   __typename?: 'CustomerProductListItem';
   description?: Maybe<Scalars['String']>;
-  quantity?: Maybe<Scalars['Int']>;
-  variant?: Maybe<ProductVariant>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   product?: Maybe<Product>;
+  quantity?: Maybe<Scalars['Int']>;
+  variant?: Maybe<ProductVariant>;
 };
 
 export type CustomerProductListResult = {
   __typename?: 'CustomerProductListResult';
-  success?: Maybe<Scalars['Boolean']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   customerProductList?: Maybe<CustomerProductList>;
+  success?: Maybe<Scalars['Boolean']>;
 };
 
 export type CustomerProductListType = {
@@ -651,20 +613,13 @@ export type CustomerUpdateDeliveryAddressInput = {
   addressName?: Maybe<Scalars['String']>;
 };
 
-export type CustomerUpdateExternalAttribute = {
-  name: Scalars['String'];
-  value: Scalars['String'];
-};
-
 export type CustomerUpdateInput = {
   pid?: Maybe<Scalars['String']>;
-  emailAddress?: Maybe<Scalars['String']>;
   organizationNumber?: Maybe<Scalars['String']>;
   billingAddress: CustomerUpdateBillingAddressInput;
   deliveryAddresses?: Maybe<Array<Maybe<CustomerUpdateDeliveryAddressInput>>>;
   preferences?: Maybe<CustomerUpdatePreferenceInput>;
   consents?: Maybe<Array<Maybe<CustomerUpdateConsentInput>>>;
-  externalAttributes?: Maybe<Array<Maybe<CustomerUpdateExternalAttribute>>>;
   dynamicContent?: Maybe<Scalars['String']>;
 };
 
@@ -687,42 +642,42 @@ export type CustomerUpdateResponse = {
 };
 
 export type CustomField = {
-  type?: Maybe<ProductCustomFieldType>;
   key?: Maybe<Scalars['String']>;
   title?: Maybe<Scalars['String']>;
+  type?: Maybe<ProductCustomFieldType>;
 };
 
 export type CustomHtmlField = CustomField & {
   __typename?: 'CustomHtmlField';
-  value: Scalars['String'];
-  type?: Maybe<ProductCustomFieldType>;
   key?: Maybe<Scalars['String']>;
   title?: Maybe<Scalars['String']>;
+  type?: Maybe<ProductCustomFieldType>;
+  value: Scalars['String'];
 };
 
 export type CustomItem = {
   __typename?: 'CustomItem';
-  id: Scalars['Int'];
-  name: Scalars['String'];
   content?: Maybe<Scalars['String']>;
-  linkUrl?: Maybe<Scalars['Uri']>;
+  id: Scalars['Int'];
   image?: Maybe<Image>;
+  linkUrl?: Maybe<Scalars['Uri']>;
+  name: Scalars['String'];
 };
 
 export type CustomListField = CustomField & {
   __typename?: 'CustomListField';
-  value?: Maybe<Array<Maybe<Scalars['String']>>>;
-  type?: Maybe<ProductCustomFieldType>;
   key?: Maybe<Scalars['String']>;
   title?: Maybe<Scalars['String']>;
+  type?: Maybe<ProductCustomFieldType>;
+  value?: Maybe<Array<Maybe<Scalars['String']>>>;
 };
 
 export type CustomMultiLevelListField = CustomField & {
   __typename?: 'CustomMultiLevelListField';
   items?: Maybe<Array<Maybe<CustomMultiLevelListFieldItem>>>;
-  type?: Maybe<ProductCustomFieldType>;
   key?: Maybe<Scalars['String']>;
   title?: Maybe<Scalars['String']>;
+  type?: Maybe<ProductCustomFieldType>;
 };
 
 export type CustomMultiLevelListFieldItem = {
@@ -735,10 +690,10 @@ export type CustomMultiLevelListFieldItem = {
 
 export type CustomStringField = CustomField & {
   __typename?: 'CustomStringField';
-  value: Scalars['String'];
-  type?: Maybe<ProductCustomFieldType>;
   key?: Maybe<Scalars['String']>;
   title?: Maybe<Scalars['String']>;
+  type?: Maybe<ProductCustomFieldType>;
+  value: Scalars['String'];
 };
 
 export type DeleteCustomerProductListResult = {
@@ -748,93 +703,46 @@ export type DeleteCustomerProductListResult = {
 
 export type Discount = {
   __typename?: 'Discount';
-  externalId?: Maybe<Scalars['ID']>;
+  campaign?: Maybe<Category>;
+  description?: Maybe<Scalars['String']>;
   name?: Maybe<Scalars['String']>;
   value?: Maybe<Price>;
-  type?: Maybe<DiscountType>;
-  description?: Maybe<Scalars['String']>;
-  campaign?: Maybe<Category>;
 };
 
-export enum DiscountType {
-  /** No discount defined */
-  Undefined = 'UNDEFINED',
-  /** Discount drops price of the order total by defined amount */
-  FixedAmount = 'FIXED_AMOUNT',
-  /** Discount drops price of the product by X % */
-  Percent = 'PERCENT',
-  /** Discount will get the amount of the cheapest product and use this as a discount */
-  Items = 'ITEMS',
-  /** Discount drops total price of the product if there is at least X of them in cart */
-  ItemsPercentageLimit = 'ITEMS_PERCENTAGE_LIMIT',
-  /** Only a collection of products */
-  OnlyUseLandingPage = 'ONLY_USE_LANDING_PAGE',
-  /** Discount drops price of the least expensive product in cart */
-  PercentOnLeastExpensiveItem = 'PERCENT_ON_LEAST_EXPENSIVE_ITEM',
-  /** Discount drops price of the most expensive product in cart */
-  PercentOnMostExpensiveItem = 'PERCENT_ON_MOST_EXPENSIVE_ITEM',
-  /** Discount allows to get a free gift when the product is added */
-  FreeProduct = 'FREE_PRODUCT',
-  /** Discount allows to get free shipping option for the product */
-  FreeShipping = 'FREE_SHIPPING',
-  /** Discount drops price for the package when all products in the package is added to cart */
-  PackageDiscount = 'PACKAGE_DISCOUNT',
-  /** Discount on the order total from a voucher */
-  BonusVoucherDiscount = 'BONUS_VOUCHER_DISCOUNT',
-  /** Discount allows to buy amount of X of the article, but pay only for amount of Y */
-  BuyXArticlesPayYAmount = 'BUY_X_ARTICLES_PAY_Y_AMOUNT'
-}
-
 export type Document = {
+  breadcrumbText?: Maybe<Scalars['String']>;
   head?: Maybe<HtmlHead>;
   primaryRoute?: Maybe<Route>;
-  breadcrumbText?: Maybe<Scalars['String']>;
 };
 
 export type ExternalCustomer = {
   __typename?: 'ExternalCustomer';
-  externalId?: Maybe<Scalars['String']>;
-  email?: Maybe<MaskedProperty>;
-  firstName?: Maybe<MaskedProperty>;
-  lastName?: Maybe<MaskedProperty>;
-  co?: Maybe<MaskedProperty>;
   address?: Maybe<MaskedProperty>;
   city?: Maybe<MaskedProperty>;
-  postalCode?: Maybe<MaskedProperty>;
+  co?: Maybe<MaskedProperty>;
   country?: Maybe<MaskedProperty>;
-  countryCode?: Maybe<Scalars['String']>;
-  phoneNumber?: Maybe<MaskedProperty>;
+  email?: Maybe<MaskedProperty>;
+  externalId?: Maybe<Scalars['String']>;
+  firstName?: Maybe<MaskedProperty>;
+  lastName?: Maybe<MaskedProperty>;
   mobilePhoneNumber?: Maybe<MaskedProperty>;
+  phoneNumber?: Maybe<MaskedProperty>;
   pid?: Maybe<MaskedProperty>;
+  postalCode?: Maybe<MaskedProperty>;
 };
 
 /** The activation status has 4 states;
  * PREEXISTING_CUSTOMER: No customer info will be returned and the customer is advised to login to the preexisting account.
- * ACTIVATION_REQUIRED: The customer account needs to be activated. Email (masked),
- * FirstName (masked) and externalId will be the only fields set on `customer`.
+ * ACTIVATION_REQUIRED: The customer account needs to be activated. Email (masked)
+ * and externalId will be the only fields set on `customer`.
  * ADDITIONAL_USER_DATA_REQUIRED: Additional data needed to register the customer,
  * the existing customer info will be available with masking on customer.
  * NON_EXISTING_CUSTOMER: Customer does not exist in any system and will have to do a sign up.
- * COUNTRY_NOT_VALID: The customer account may not be activated on this channel as
- * it's missing the customer country. Email (masked), FirstName (masked),
- * externalId and countryCode will be the only fields set on `customer`.
  */
 export type ExternalCustomerResult = {
   __typename?: 'ExternalCustomerResult';
-  status?: Maybe<ActivationStatusSource>;
   customer?: Maybe<ExternalCustomer>;
-};
-
-export type ExternalOrderData = {
-  __typename?: 'ExternalOrderData';
-  name: Scalars['String'];
-  value: Scalars['String'];
-};
-
-export type FacebookConversionsApi = {
-  __typename?: 'FacebookConversionsApi';
-  accessToken?: Maybe<Scalars['String']>;
-  pixelId?: Maybe<Scalars['String']>;
+  status?: Maybe<ActivationStatusSource>;
 };
 
 export type Filter = {
@@ -851,8 +759,8 @@ export type FilterInput = {
 
 export type FreeShippingLimit = {
   __typename?: 'FreeShippingLimit';
-  incVat?: Maybe<Scalars['Decimal']>;
   exVat?: Maybe<Scalars['Decimal']>;
+  incVat?: Maybe<Scalars['Decimal']>;
 };
 
 export type GoogleAnalytics = {
@@ -861,43 +769,29 @@ export type GoogleAnalytics = {
   useArticleNumberAsId?: Maybe<Scalars['Boolean']>;
 };
 
-export type GoogleAnalytics4 = {
-  __typename?: 'GoogleAnalytics4';
-  trackingId?: Maybe<Scalars['String']>;
-  useArticleNumberAsId?: Maybe<Scalars['Boolean']>;
-};
-
 export type GoogleTagManager = {
   __typename?: 'GoogleTagManager';
   containerId?: Maybe<Scalars['String']>;
-  useGa4Events?: Maybe<Scalars['Boolean']>;
 };
 
 export type HtmlHead = {
   __typename?: 'HtmlHead';
-  title?: Maybe<Scalars['String']>;
   metaTags?: Maybe<Array<Maybe<HtmlMetaTag>>>;
+  title?: Maybe<Scalars['String']>;
 };
 
 export type HtmlMetaTag = {
   __typename?: 'HtmlMetaTag';
-  name?: Maybe<Scalars['String']>;
   content?: Maybe<Scalars['String']>;
+  name?: Maybe<Scalars['String']>;
 };
 
 export type Image = {
   __typename?: 'Image';
+  height?: Maybe<Scalars['Int']>;
   title?: Maybe<Scalars['String']>;
   url?: Maybe<Scalars['Uri']>;
   width?: Maybe<Scalars['Int']>;
-  height?: Maybe<Scalars['Int']>;
-};
-
-export type ImageValue = {
-  __typename?: 'ImageValue';
-  value?: Maybe<Scalars['String']>;
-  focalPointX?: Maybe<Scalars['Int']>;
-  focalPointY?: Maybe<Scalars['Int']>;
 };
 
 export type InputComment = {
@@ -907,23 +801,17 @@ export type InputComment = {
 
 export type Language = {
   __typename?: 'Language';
-  id: Scalars['String'];
-  name: Scalars['String'];
   culture: Scalars['String'];
+  id: Scalars['String'];
   isDefault?: Maybe<Scalars['Boolean']>;
-};
-
-export type Link = {
-  __typename?: 'Link';
-  target?: Maybe<Scalars['String']>;
-  link?: Maybe<Scalars['Uri']>;
+  name: Scalars['String'];
 };
 
 export type ListFilter = Filter & {
   __typename?: 'ListFilter';
   hasActiveItems: Scalars['Boolean'];
-  items: Array<Maybe<ListFilterItem>>;
   id: Scalars['String'];
+  items: Array<Maybe<ListFilterItem>>;
   name: Scalars['String'];
 };
 
@@ -935,15 +823,10 @@ export type ListFilterInput = {
 export type ListFilterItem = {
   __typename?: 'ListFilterItem';
   isActive?: Maybe<Scalars['Boolean']>;
-  text: Scalars['String'];
   id: Scalars['String'];
-  value: Scalars['String'];
   resultCount?: Maybe<Scalars['Int']>;
-};
-
-export type ListStringValue = {
-  __typename?: 'ListStringValue';
-  value?: Maybe<Array<Maybe<Scalars['String']>>>;
+  text: Scalars['String'];
+  value: Scalars['String'];
 };
 
 export type LoginExternalCustomerInput = {
@@ -959,20 +842,19 @@ export type LoginExternalCustomerResult = {
 export type LoginResponse = {
   __typename?: 'LoginResponse';
   token: Token;
-  customerId?: Maybe<Scalars['Int']>;
 };
 
 export type MaskedProperty = {
   __typename?: 'MaskedProperty';
-  masked?: Maybe<Scalars['String']>;
   encrypted?: Maybe<Scalars['String']>;
+  masked?: Maybe<Scalars['String']>;
 };
 
 export type MultiListFilter = Filter & {
   __typename?: 'MultiListFilter';
   isActive: Scalars['Boolean'];
-  lists: Array<Maybe<MultiListFilterList>>;
   id: Scalars['String'];
+  lists: Array<Maybe<MultiListFilterList>>;
   name: Scalars['String'];
 };
 
@@ -985,14 +867,8 @@ export type MultiListFilterList = {
   __typename?: 'MultiListFilterList';
   hasActiveItems: Scalars['Boolean'];
   id: Scalars['String'];
-  name: Scalars['String'];
   items: Array<Maybe<ListFilterItem>>;
-};
-
-export type MultipleContent = {
-  __typename?: 'MultipleContent';
-  notFoundIds: Array<Maybe<Scalars['ID']>>;
-  content: Array<Maybe<Content>>;
+  name: Scalars['String'];
 };
 
 export type Mutation = {
@@ -1007,13 +883,26 @@ export type Mutation = {
   setMultiListFilter?: Maybe<MultiListFilter>;
   clearMultiListFilter?: Maybe<MultiListFilter>;
   clearMultiListFilterList?: Maybe<MultiListFilter>;
-  subscribeToStockNotifications?: Maybe<Scalars['Boolean']>;
-  /** This mutation's purpose is to subscribe a customer to a newsletter. In order
-   * to subscribe a customer a valid email address is required
-   *
-   * Responds with a boolean value whether the subscription has been successful or not
+  /** Error codes: CustomerNotFound, CustomerAlreadyActivated,
+   * UnableToActivateCustomer, UnableToLoginCustomer, InvalidCustomerActivateInput
    */
-  subscribeToNewsletter?: Maybe<Scalars['Boolean']>;
+  activateExternalCustomerById?: Maybe<ActivateExternalCustomerByIdResult>;
+  /** Error codes: CustomerNotFound, CustomerAlreadyActivated,
+   * UnableToActivateCustomer, UnableToLoginCustomer, InvalidCustomerActivateInput
+   */
+  activateExternalCustomerByToken?: Maybe<
+    ActivateExternalCustomerByTokenResult
+  >;
+  /** Adds products to the cart where you can add comments to the products and
+   * determine their quantities. Replies with the affected cart if a cartId has
+   * been presented, otherwise a new cart will be created.
+   */
+  addMultipleToCart?: Maybe<CartMutation>;
+  /** Adds a product to the cart where you can add a comment to the product and
+   * determine the quantity. Replies with the affected cart if a cartId has been
+   * presented, otherwise a new cart will be created.
+   */
+  addToCart?: Maybe<CartMutation>;
   /** ## Description
    * Adds items to product list, null id adds items to the default product list.
    * ## Error Codes
@@ -1038,6 +927,14 @@ export type Mutation = {
    * Error in underlying API call, more info may be contained in the error message.
    */
   createCustomerProductList?: Maybe<CustomerProductListResult>;
+  /** This mutation is used to reduce the quantity of a product in the cart, replies
+   * with the affected cart ruled by the cartId in the input.
+   */
+  decrementItemQuantity?: Maybe<CartMutation>;
+  /** This mutation deletes a customer. An authorization token is needed in the
+   * request, in order to be able to delete the customer.
+   */
+  deleteCustomer?: Maybe<Scalars['Boolean']>;
   /** ## Description
    * Deletes a product list for a logged in customer
    * ## Error Codes
@@ -1049,6 +946,18 @@ export type Mutation = {
    * Error in underlying API call, more info may be contained in the error message.
    */
   deleteCustomerProductList?: Maybe<DeleteCustomerProductListResult>;
+  /** This mutation is used to increase the quantity of a product in the cart,
+   * replies with the affected cart ruled by the cartId in the input
+   */
+  incrementItemQuantity?: Maybe<CartMutation>;
+  /** LoginMutation will log a user in.
+   * One of email, pid, externalId or memberNumber is required, along with a password.
+   * Returns an authorization token if the login was successful.
+   */
+  login?: Maybe<LoginResponse>;
+  loginExternalCustomer?: Maybe<LoginExternalCustomerResult>;
+  /** Removes a specific product in the cart, replies with the affected cart */
+  removeFromCart?: Maybe<CartMutation>;
   /** ## Description
    * Removes an item from a product list for a logged in customer, null id removes item in the default product list.
    * ## Error Codes
@@ -1066,6 +975,43 @@ export type Mutation = {
    * Argument `articleNumbers` cannot be null or empty.
    */
   removeFromCustomerProductList?: Maybe<CustomerProductListResult>;
+  /** Removes specific items from the cart, replies with the affected cart */
+  removeMultipleFromCart?: Maybe<CartMutation>;
+  /** Requires a valid email and returns boolean value if successful, otherwise an error will be thrown */
+  requestPasswordReset?: Maybe<RequestPasswordResetResult>;
+  /** Requires a valid resetPasswordToken and a new password and if successful will return a authentication token */
+  resetPassword?: Maybe<ResetPassword>;
+  /** Used to add a specific quantity to a product in the cart. Replies with the affected cart ruled by the cartId in the input */
+  setItemQuantity?: Maybe<CartMutation>;
+  /** The SignUp-mutation is used for creating a customer.
+   *
+   * If the sign up is successful the customer may be considered to be logged on and an authentication token will be returned
+   */
+  signUp?: Maybe<SignUpResponse>;
+  /** This mutation's purpose is to subscribe a customer to a newsletter. In order
+   * to subscribe a customer a valid email address is required
+   *
+   * Responds with a boolean value whether the subscription has been successful or not
+   */
+  subscribeToNewsletter?: Maybe<Scalars['Boolean']>;
+  subscribeToStockNotifications?: Maybe<Scalars['Boolean']>;
+  /** Responds with the affected cart. */
+  updateCart?: Maybe<UpdateCartMutation>;
+  /** This mutation's purpose is to update a existing customer's information. An
+   * authorization token is needed in the request, in order to be able to delete the customer.
+   */
+  updateCustomer?: Maybe<CustomerUpdateResponse>;
+  /** ## Description
+   * Updates a product list for a logged in customer
+   * ## Error Codes
+   * ### Unauthorized
+   *
+   * ### ProductListNotFound
+   * Argument `id` did not match any list for this customer.
+   * ### UnableToUpdateProductList
+   * Error in underlying API call, more info may be contained in the error message.
+   */
+  updateCustomerProductList?: Maybe<CustomerProductListResult>;
   /** ## Description
    * Updates an item in product list, null id updates item in the default product list.
    * ## Error Codes
@@ -1083,98 +1029,8 @@ export type Mutation = {
    * Argument `articleNumber` cannot be null or empty.
    */
   updateCustomerProductListItem?: Maybe<CustomerProductListResult>;
-  /** ## Description
-   * Updates a product list for a logged in customer
-   * ## Error Codes
-   * ### Unauthorized
-   *
-   * ### ProductListNotFound
-   * Argument `id` did not match any list for this customer.
-   * ### UnableToUpdateProductList
-   * Error in underlying API call, more info may be contained in the error message.
-   */
-  updateCustomerProductList?: Maybe<CustomerProductListResult>;
-  /** Error codes: CustomerNotFound, CustomerAlreadyActivated,
-   * UnableToActivateCustomer, UnableToLoginCustomer, InvalidCustomerActivateInput
-   */
-  activateExternalCustomerById?: Maybe<ActivateExternalCustomerByIdResult>;
-  /** Error codes: CustomerNotFound, CustomerAlreadyActivated,
-   * UnableToActivateCustomer, UnableToLoginCustomer, InvalidCustomerActivateInput
-   */
-  activateExternalCustomerByToken?: Maybe<
-    ActivateExternalCustomerByTokenResult
-  >;
-  /** This mutation deletes a customer. An authorization token is needed in the
-   * request, in order to be able to delete the customer.
-   */
-  deleteCustomer?: Maybe<Scalars['Boolean']>;
-  loginExternalCustomer?: Maybe<LoginExternalCustomerResult>;
-  /** LoginMutation will log a user in.
-   * One of email, pid, externalId, memberNumber or customerId is required, along with a password.
-   * Returns an authorization token if the login was successful.
-   */
-  login?: Maybe<LoginResponse>;
-  /** Requires a valid email and returns boolean value if successful, otherwise an error will be thrown */
-  requestPasswordReset?: Maybe<RequestPasswordResetResult>;
-  /** Requires a valid resetPasswordToken and a new password and if successful will return a authentication token */
-  resetPassword?: Maybe<ResetPassword>;
-  /** The SignUp-mutation is used for creating a customer.
-   *
-   * If the sign up is successful the customer may be considered to be logged on and an authentication token will be returned
-   */
-  signUp?: Maybe<SignUpResponse>;
-  /** ## Description
-   * This mutation's purpose is to update a existing customer's group using an
-   * access code. An authorization token is needed in the request, in order to be
-   * able to update the customer.
-   * ## Error Codes
-   * ### Unauthorized
-   * Unauthorized
-   * ### UnableToUpdateCustomer
-   * Error in underlying API call, more info may be contained in the error message.
-   * ### CustomerAlreadyUpdated
-   * Customer already in the customer group
-   * ### CustomerNotFound
-   * No match on customer with access code
-   */
-  updateCustomerGroup?: Maybe<UpdateCustomerGroupResult>;
-  /** This mutation's purpose is to update an existing customer's information. An
-   * authorization token is needed in the request, in order to be able to update the customer.
-   */
-  updateCustomer?: Maybe<CustomerUpdateResponse>;
-  /** This mutation's purpose is to update a existing customer's price list using an
-   * access code. An authorization token is needed in the request, in order to be
-   * able to update the customer.
-   */
-  updateCustomerPriceList?: Maybe<UpdateCustomerPriceListResult>;
   /** The updatePassword mutation updates the customers password. Both the old password and a new password is a requirement. */
   updatePassword?: Maybe<UpdatePasswordResult>;
-  /** Adds products to the cart where you can add comments to the products and
-   * determine their quantities. Replies with the affected cart if a cartId has
-   * been presented, otherwise a new cart will be created.
-   */
-  addMultipleToCart?: Maybe<CartMutation>;
-  /** Adds a product to the cart where you can add a comment to the product and
-   * determine the quantity. Replies with the affected cart if a cartId has been
-   * presented, otherwise a new cart will be created.
-   */
-  addToCart?: Maybe<CartMutation>;
-  /** This mutation is used to reduce the quantity of a product in the cart, replies
-   * with the affected cart ruled by the cartId in the input.
-   */
-  decrementItemQuantity?: Maybe<CartMutation>;
-  /** Used to add a specific quantity to a product in the cart. Replies with the affected cart ruled by the cartId in the input */
-  setItemQuantity?: Maybe<CartMutation>;
-  /** This mutation is used to increase the quantity of a product in the cart,
-   * replies with the affected cart ruled by the cartId in the input
-   */
-  incrementItemQuantity?: Maybe<CartMutation>;
-  /** Removes a specific product in the cart, replies with the affected cart */
-  removeFromCart?: Maybe<CartMutation>;
-  /** Removes specific items from the cart, replies with the affected cart */
-  removeMultipleFromCart?: Maybe<CartMutation>;
-  /** Responds with the affected cart. */
-  updateCart?: Maybe<UpdateCartMutation>;
 };
 
 export type MutationToggleListFilterItemArgs = {
@@ -1221,126 +1077,114 @@ export type MutationClearMultiListFilterListArgs = {
   filter: MultiListFilter;
 };
 
-export type MutationSubscribeToStockNotificationsArgs = {
-  email: Scalars['String'];
-  articleNumber: Scalars['String'];
-};
-
-export type MutationSubscribeToNewsletterArgs = {
-  email: Scalars['String'];
+export type MutationActivateExternalCustomerByIdArgs = {
+  input?: Maybe<ActivateExternalCustomerByIdInput>;
 };
 
-export type MutationAddToCustomerProductListArgs = {
-  id?: Maybe<Scalars['ID']>;
-  items: Array<AddToCustomerProductListInput>;
+export type MutationActivateExternalCustomerByTokenArgs = {
+  input?: Maybe<ActivateExternalCustomerByTokenInput>;
 };
 
-export type MutationCreateCustomerProductListArgs = {
-  input: CreateCustomerProductListInput;
+export type MutationAddMultipleToCartArgs = {
+  cartId?: Maybe<Scalars['String']>;
+  items: Array<Maybe<AddMultipleToCartInput>>;
 };
 
-export type MutationDeleteCustomerProductListArgs = {
-  id: Scalars['ID'];
+export type MutationAddToCartArgs = {
+  input: AddToCartInput;
 };
 
-export type MutationRemoveFromCustomerProductListArgs = {
+export type MutationAddToCustomerProductListArgs = {
   id?: Maybe<Scalars['ID']>;
-  articleNumbers?: Maybe<Array<Scalars['String']>>;
-};
-
-export type MutationUpdateCustomerProductListItemArgs = {
-  input: UpdateCustomerProductListItemInput;
+  items: Array<AddToCustomerProductListInput>;
 };
 
-export type MutationUpdateCustomerProductListArgs = {
-  input: UpdateCustomerProductListInput;
+export type MutationCreateCustomerProductListArgs = {
+  input: CreateCustomerProductListInput;
 };
 
-export type MutationActivateExternalCustomerByIdArgs = {
-  input?: Maybe<ActivateExternalCustomerByIdInput>;
+export type MutationDecrementItemQuantityArgs = {
+  input: ChangeByOneItemQuantityInput;
 };
 
-export type MutationActivateExternalCustomerByTokenArgs = {
-  input?: Maybe<ActivateExternalCustomerByTokenInput>;
+export type MutationDeleteCustomerProductListArgs = {
+  id: Scalars['ID'];
 };
 
-export type MutationLoginExternalCustomerArgs = {
-  input?: Maybe<LoginExternalCustomerInput>;
+export type MutationIncrementItemQuantityArgs = {
+  input: ChangeByOneItemQuantityInput;
 };
 
 export type MutationLoginArgs = {
-  password?: Maybe<Scalars['String']>;
+  password: Scalars['String'];
   email?: Maybe<Scalars['String']>;
   pid?: Maybe<Scalars['String']>;
   externalId?: Maybe<Scalars['String']>;
   memberNumber?: Maybe<Scalars['String']>;
-  externalHashId?: Maybe<Scalars['String']>;
-  timeStamp?: Maybe<Scalars['String']>;
-  customerId?: Maybe<Scalars['Int']>;
-  cartId?: Maybe<Scalars['String']>;
 };
 
-export type MutationRequestPasswordResetArgs = {
-  email: Scalars['String'];
+export type MutationLoginExternalCustomerArgs = {
+  input?: Maybe<LoginExternalCustomerInput>;
 };
 
-export type MutationResetPasswordArgs = {
-  resetPasswordToken: Scalars['String'];
-  newPassword: Scalars['String'];
+export type MutationRemoveFromCartArgs = {
+  input: RemoveFromCartInput;
 };
 
-export type MutationSignUpArgs = {
-  input: SignUpInput;
+export type MutationRemoveFromCustomerProductListArgs = {
+  id?: Maybe<Scalars['ID']>;
+  articleNumbers?: Maybe<Array<Scalars['String']>>;
 };
 
-export type MutationUpdateCustomerGroupArgs = {
-  customerGroupAccessCode: Scalars['String'];
+export type MutationRemoveMultipleFromCartArgs = {
+  input: RemoveMultipleFromCartInput;
 };
 
-export type MutationUpdateCustomerArgs = {
-  input: CustomerUpdateInput;
+export type MutationRequestPasswordResetArgs = {
+  email: Scalars['String'];
 };
 
-export type MutationUpdateCustomerPriceListArgs = {
-  priceListAccessCode: Scalars['String'];
+export type MutationResetPasswordArgs = {
+  resetPasswordToken: Scalars['String'];
+  newPassword: Scalars['String'];
 };
 
-export type MutationUpdatePasswordArgs = {
-  oldPassword: Scalars['String'];
-  newPassword: Scalars['String'];
+export type MutationSetItemQuantityArgs = {
+  input: SetItemQuantityInput;
 };
 
-export type MutationAddMultipleToCartArgs = {
-  cartId?: Maybe<Scalars['String']>;
-  items: Array<Maybe<AddMultipleToCartInput>>;
+export type MutationSignUpArgs = {
+  input: SignUpInput;
 };
 
-export type MutationAddToCartArgs = {
-  input: AddToCartInput;
+export type MutationSubscribeToNewsletterArgs = {
+  email: Scalars['String'];
 };
 
-export type MutationDecrementItemQuantityArgs = {
-  input: ChangeByOneItemQuantityInput;
+export type MutationSubscribeToStockNotificationsArgs = {
+  email: Scalars['String'];
+  articleNumber: Scalars['String'];
 };
 
-export type MutationSetItemQuantityArgs = {
-  input: SetItemQuantityInput;
+export type MutationUpdateCartArgs = {
+  input: UpdateCartInput;
 };
 
-export type MutationIncrementItemQuantityArgs = {
-  input: ChangeByOneItemQuantityInput;
+export type MutationUpdateCustomerArgs = {
+  input: CustomerUpdateInput;
 };
 
-export type MutationRemoveFromCartArgs = {
-  input: RemoveFromCartInput;
+export type MutationUpdateCustomerProductListArgs = {
+  input: UpdateCustomerProductListInput;
 };
 
-export type MutationRemoveMultipleFromCartArgs = {
-  input: RemoveMultipleFromCartInput;
+export type MutationUpdateCustomerProductListItemArgs = {
+  input: UpdateCustomerProductListItemInput;
 };
 
-export type MutationUpdateCartArgs = {
-  input: UpdateCartInput;
+export type MutationUpdatePasswordArgs = {
+  oldPassword: Scalars['String'];
+  newPassword: Scalars['String'];
 };
 
 export type MyPagesContent = {
@@ -1353,29 +1197,26 @@ export type NumericRangeFilter = Filter & {
   __typename?: 'NumericRangeFilter';
   isActive: Scalars['Boolean'];
   value?: Maybe<Array<Maybe<Scalars['Decimal']>>>;
-  min: Scalars['Decimal'];
-  max: Scalars['Decimal'];
   id: Scalars['String'];
+  max: Scalars['Decimal'];
+  min: Scalars['Decimal'];
   name: Scalars['String'];
 };
 
 export type Order = {
   __typename?: 'Order';
-  id: Scalars['ID'];
-  orderNumber?: Maybe<Scalars['String']>;
-  status?: Maybe<OrderStatus>;
-  items?: Maybe<Array<Maybe<OrderItem>>>;
   billingInfo?: Maybe<OrderInfo>;
+  currency?: Maybe<Currency>;
   deliveryInfo?: Maybe<OrderInfo>;
-  paymentMethod?: Maybe<OrderPaymentMethod>;
   deliveryMethod?: Maybe<OrderDeliveryMethod>;
   giftVouchers?: Maybe<Array<Maybe<OrderGiftVoucher>>>;
-  total?: Maybe<Price>;
+  id: Scalars['ID'];
+  items?: Maybe<Array<Maybe<OrderItem>>>;
   orderDate?: Maybe<Scalars['DateTime']>;
-  currency?: Maybe<Currency>;
-  attachments?: Maybe<Array<Maybe<OrderAttachment>>>;
-  orderPurchaseLocation?: Maybe<Scalars['String']>;
-  orderComments?: Maybe<Array<Maybe<OrderComment>>>;
+  orderNumber?: Maybe<Scalars['String']>;
+  paymentMethod?: Maybe<OrderPaymentMethod>;
+  status?: Maybe<OrderStatus>;
+  total?: Maybe<Price>;
 };
 
 export type OrderItemsArgs = {
@@ -1385,30 +1226,18 @@ export type OrderItemsArgs = {
 
 export type OrderAddress = {
   __typename?: 'OrderAddress';
-  street?: Maybe<Scalars['String']>;
-  postcode?: Maybe<Scalars['String']>;
   city?: Maybe<Scalars['String']>;
-  region?: Maybe<Scalars['String']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   country?: Maybe<Country>;
-};
-
-export type OrderAttachment = {
-  __typename?: 'OrderAttachment';
-  id: Scalars['ID'];
-  url?: Maybe<Scalars['String']>;
-};
-
-export type OrderComment = {
-  __typename?: 'OrderComment';
-  title?: Maybe<Scalars['String']>;
-  text?: Maybe<Scalars['String']>;
+  postcode?: Maybe<Scalars['String']>;
+  region?: Maybe<Scalars['String']>;
+  street?: Maybe<Scalars['String']>;
 };
 
 export type OrderDeliveryMethod = {
   __typename?: 'OrderDeliveryMethod';
-  name?: Maybe<Scalars['String']>;
   fee?: Maybe<Price>;
+  name?: Maybe<Scalars['String']>;
   tracking?: Maybe<OrderDeliveryMethodTracking>;
 };
 
@@ -1420,24 +1249,24 @@ export type OrderDeliveryMethodTracking = {
 
 export type OrderGiftVoucher = {
   __typename?: 'OrderGiftVoucher';
-  name?: Maybe<Scalars['String']>;
   amount?: Maybe<Scalars['Decimal']>;
   charged?: Maybe<Scalars['Decimal']>;
+  name?: Maybe<Scalars['String']>;
   validUntil?: Maybe<Scalars['DateTime']>;
 };
 
 export type OrderHeader = {
   __typename?: 'OrderHeader';
+  currency?: Maybe<Currency>;
+  /** If this is false, a call to `order` for this order will result in a failure. */
+  hasOrderDetails?: Maybe<Scalars['Boolean']>;
   id: Scalars['ID'];
+  orderDate?: Maybe<Scalars['DateTime']>;
   orderNumber?: Maybe<Scalars['String']>;
   status?: Maybe<OrderStatus>;
   statusTimeline?: Maybe<Array<Maybe<OrderStatus>>>;
-  /** If this is false, a call to `order` for this order will result in a failure. */
-  hasOrderDetails?: Maybe<Scalars['Boolean']>;
   total?: Maybe<Price>;
-  orderDate?: Maybe<Scalars['DateTime']>;
   trackingId?: Maybe<Scalars['String']>;
-  currency?: Maybe<Currency>;
 };
 
 export type OrderHeaderResult = {
@@ -1448,26 +1277,27 @@ export type OrderHeaderResult = {
 
 export type OrderInfo = {
   __typename?: 'OrderInfo';
+  address?: Maybe<OrderAddress>;
+  company?: Maybe<Scalars['String']>;
   firstName?: Maybe<Scalars['String']>;
   lastName?: Maybe<Scalars['String']>;
-  company?: Maybe<Scalars['String']>;
   phone?: Maybe<Scalars['String']>;
-  address?: Maybe<OrderAddress>;
 };
 
 export type OrderItem = {
   __typename?: 'OrderItem';
   articleNumber?: Maybe<Scalars['String']>;
+  discounts?: Maybe<Array<Maybe<OrderItemDiscount>>>;
   /** Name of the Product at the time the order was placed (may since have changed).
    * Use this as a fallback if the 'product' field itself is null.
    */
   name?: Maybe<Scalars['String']>;
-  quantity?: Maybe<Scalars['Int']>;
-  unitPrice?: Maybe<Price>;
-  total?: Maybe<Price>;
-  discounts?: Maybe<Array<Maybe<OrderItemDiscount>>>;
+  preOrderDate?: Maybe<Scalars['DateTime']>;
   /** N.B. this may be null if the Product has since been removed. */
   product?: Maybe<Product>;
+  quantity?: Maybe<Scalars['Int']>;
+  total?: Maybe<Price>;
+  unitPrice?: Maybe<Price>;
   /** N.B. this may be null if the Product itself or the Variant has since been removed. */
   variant?: Maybe<ProductVariant>;
   /** N.B. this may be null if the Product has since been removed. */
@@ -1477,9 +1307,6 @@ export type OrderItem = {
    * be null when the OrderItem is not a Variant.
    */
   variantValue?: Maybe<Scalars['String']>;
-  preOrderDate?: Maybe<Scalars['DateTime']>;
-  /** list of name, value fields from orders coming from external systems. */
-  externalOrderData?: Maybe<Array<Maybe<ExternalOrderData>>>;
 };
 
 export type OrderItemDiscount = {
@@ -1489,29 +1316,29 @@ export type OrderItemDiscount = {
 
 export type OrderPaymentMethod = {
   __typename?: 'OrderPaymentMethod';
-  name?: Maybe<Scalars['String']>;
   fee?: Maybe<Price>;
+  name?: Maybe<Scalars['String']>;
 };
 
 export type OrderStatus = {
   __typename?: 'OrderStatus';
-  id?: Maybe<Scalars['ID']>;
   description?: Maybe<Scalars['String']>;
+  id?: Maybe<Scalars['ID']>;
   timestamp?: Maybe<Scalars['DateTime']>;
 };
 
 export type Package = {
   __typename?: 'Package';
+  /** Total package discount in percentage */
+  discountPercentage?: Maybe<Scalars['Decimal']>;
+  /** Total package discount amount */
+  discountValue?: Maybe<Price>;
   id: Scalars['ID'];
   items: Array<PackageItem>;
-  /** The current package price with any potential discount */
-  price?: Maybe<Price>;
   /** The previous package price without any potential discount */
   previousPrice?: Maybe<Price>;
-  /** Total package discount amount */
-  discountValue?: Maybe<Price>;
-  /** Total package discount in percentage */
-  discountPercentage?: Maybe<Scalars['Decimal']>;
+  /** The current package price with any potential discount */
+  price?: Maybe<Price>;
 };
 
 export type PackageDiscount = PackageDiscountPercentage | PackageDiscountValue;
@@ -1523,20 +1350,20 @@ export type PackageDiscountPercentage = {
 
 export type PackageDiscountValue = {
   __typename?: 'PackageDiscountValue';
-  valueIncVat: Scalars['Decimal'];
   valueExVat: Scalars['Decimal'];
+  valueIncVat: Scalars['Decimal'];
   valueVat: Scalars['Decimal'];
 };
 
 export type PackageItem = {
   __typename?: 'PackageItem';
-  product?: Maybe<Product>;
-  minQuantity: Scalars['Int'];
   discount?: Maybe<PackageDiscount>;
-  /** The current package price with any potential discount */
-  price?: Maybe<Price>;
+  minQuantity: Scalars['Int'];
   /** The previous package price without any potential discount */
   previousPrice?: Maybe<Price>;
+  /** The current package price with any potential discount */
+  price?: Maybe<Price>;
+  product?: Maybe<Product>;
 };
 
 export type PackagePriceInput = {
@@ -1546,55 +1373,28 @@ export type PackagePriceInput = {
 
 export type Page = Document & {
   __typename?: 'Page';
-  id: Scalars['ID'];
-  name: Scalars['String'];
-  mainHeader?: Maybe<Scalars['String']>;
+  breadcrumbText?: Maybe<Scalars['String']>;
   content?: Maybe<Scalars['String']>;
-  hasExternalUrl?: Maybe<Scalars['Boolean']>;
-  /** External URL if page is set to URL, null if not. */
-  externalUrl?: Maybe<Link>;
-  images?: Maybe<Array<Maybe<Image>>>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   head?: Maybe<HtmlHead>;
+  id: Scalars['ID'];
+  images?: Maybe<Array<Maybe<Image>>>;
+  mainHeader?: Maybe<Scalars['String']>;
+  name: Scalars['String'];
   /** The primary route of this Page. NB: Carries a performance cost, as asking for
    * this will result in a separate API call in the backend.
    */
   primaryRoute?: Maybe<Route>;
-  breadcrumbText?: Maybe<Scalars['String']>;
-  /** Get content data set via the Content Editor. NB: Carries a performance cost,
-   * as asking for this will result in a separate API call in the backend.
-   */
-  data?: Maybe<Content>;
-  /** * If this page was fetched by ID using the `page(id)` query, `parent` will be returned even if it is hidden.
-   * * If this page was fetched using the `pages` query, `parent` will not be returned if it is hidden
-   */
-  parent?: Maybe<Page>;
-  /** * If this page was fetched by ID using the `page(id)` query, `subPages` will
-   * be returned even if they are hidden. This can be overridden with the
-   * `includeHidden` flag.
-   * * If this page was fetched using the `pages` query, `subPages` will not be
-   * returned if they are hidden. The `includeHidden` flag has no effect on this.
-   */
-  subPages?: Maybe<Array<Page>>;
-  /** When set to false, the page will be excluded from sitemap. The frontend
-   * implementation should use this value to set meta tags to exclude the page from
-   * being indexed by crawlers. Defaults to true.
-   */
-  allowWebIndexing?: Maybe<Scalars['Boolean']>;
-};
-
-export type PageSubPagesArgs = {
-  includeHidden?: Maybe<Scalars['Boolean']>;
 };
 
 export type PagedResult = {
   __typename?: 'PagedResult';
-  totalResults?: Maybe<Scalars['Int']>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  sortOrders?: Maybe<Array<Maybe<ProductSortOrder>>>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   filters?: Maybe<Array<Maybe<Filter>>>;
   result: Array<Maybe<Product>>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  sortOrders?: Maybe<Array<Maybe<ProductSortOrder>>>;
+  totalResults?: Maybe<Scalars['Int']>;
 };
 
 export type PagedResultFiltersArgs = {
@@ -1608,59 +1408,53 @@ export type PagingInput = {
 
 export type PaymentType = {
   __typename?: 'paymentType';
-  name: Scalars['String'];
   apiClientId: Scalars['String'];
   availableForBusiness: Scalars['Boolean'];
   availableForPrivate: Scalars['Boolean'];
+  name: Scalars['String'];
 };
 
 export type PersonLookup = {
   __typename?: 'PersonLookup';
-  firstName?: Maybe<MaskedProperty>;
-  lastName?: Maybe<MaskedProperty>;
-  co?: Maybe<MaskedProperty>;
   address?: Maybe<MaskedProperty>;
   city?: Maybe<MaskedProperty>;
-  postalCode?: Maybe<MaskedProperty>;
+  co?: Maybe<MaskedProperty>;
   country?: Maybe<MaskedProperty>;
-  phoneNumber?: Maybe<MaskedProperty>;
+  firstName?: Maybe<MaskedProperty>;
+  lastName?: Maybe<MaskedProperty>;
   mobilePhoneNumber?: Maybe<MaskedProperty>;
+  phoneNumber?: Maybe<MaskedProperty>;
+  postalCode?: Maybe<MaskedProperty>;
 };
 
 export type Price = {
   __typename?: 'Price';
-  incVat: Scalars['Decimal'];
   exVat: Scalars['Decimal'];
+  incVat: Scalars['Decimal'];
   vat: Scalars['Decimal'];
 };
 
-export type PriceHistory = {
-  __typename?: 'PriceHistory';
-  timestamp?: Maybe<Scalars['DateTime']>;
-  price?: Maybe<Price>;
-};
-
 export type PrivateCustomer = Customer & {
   __typename?: 'PrivateCustomer';
-  pid?: Maybe<Scalars['String']>;
-  id: Scalars['ID'];
-  memberId?: Maybe<Scalars['String']>;
+  billingAddress?: Maybe<CustomerAddress>;
+  communication?: Maybe<CustomerCommunication>;
+  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
+  dynamicContent?: Maybe<Scalars['String']>;
   email?: Maybe<Scalars['String']>;
+  externalAttributes?: Maybe<Array<Maybe<CustomerExternalAttribute>>>;
   /** Customer id for external system */
   externalId?: Maybe<Scalars['String']>;
-  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  googleUserId?: Maybe<Scalars['String']>;
+  id: Scalars['ID'];
   language?: Maybe<Language>;
-  billingAddress?: Maybe<CustomerAddress>;
-  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
+  memberId?: Maybe<Scalars['String']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   orderHeaders?: Maybe<OrderHeaderResult>;
-  communication?: Maybe<CustomerCommunication>;
+  pid?: Maybe<Scalars['String']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   store?: Maybe<Store>;
-  dynamicContent?: Maybe<Scalars['String']>;
-  externalAttributes?: Maybe<Array<Maybe<CustomerExternalAttribute>>>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  googleUserId?: Maybe<Scalars['String']>;
+  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
 };
 
 export type PrivateCustomerOrderHeadersArgs = {
@@ -1670,102 +1464,61 @@ export type PrivateCustomerOrderHeadersArgs = {
 
 export type Product = Document & {
   __typename?: 'Product';
-  id: Scalars['Int'];
   articleNumber: Scalars['String'];
-  name: Scalars['String'];
-  subName: Scalars['String'];
-  shortDescription: Scalars['String'];
-  description: Scalars['String'];
-  /** Product header if it differs from the actual product name, usually displayed
-   * instead of the product name in the header tag at the product page.
-   */
-  mainHeader: Scalars['String'];
-  publishedDate?: Maybe<Scalars['DateTime']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  canonicalCategory?: Maybe<Category>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  categories?: Maybe<Array<Maybe<Category>>>;
+  badges?: Maybe<Array<Maybe<ProductBadge>>>;
+  barcode?: Maybe<Scalars['String']>;
+  breadcrumbText?: Maybe<Scalars['String']>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   campaigns?: Maybe<Array<Maybe<Category>>>;
-  hasVariants: Scalars['Boolean'];
-  hasVariantsWithDifferingPrices: Scalars['Boolean'];
-  variants?: Maybe<ProductVariants>;
-  images?: Maybe<Array<Maybe<ProductImage>>>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  relatedProducts?: Maybe<Array<Maybe<Product>>>;
+  canonicalCategory?: Maybe<Category>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  badges?: Maybe<Array<Maybe<ProductBadge>>>;
-  /** The current price.
-   * - Will be a Customer specific price if that Customer has a separate price list.
-   * - Will be the member price if Customer is logged in and `Product.hasMemberPrice` is true.
-   * - Will be the non-member price if Customer is not logged in and `Product.hasMemberPrice` is true.
-   */
-  price?: Maybe<Price>;
-  hidePrice?: Maybe<Scalars['Boolean']>;
-  /** The previous price (i.e. this will be higher than `price` if the product is
-   * discounted). Will be a Customer specific previous price, if that Customer has
-   * a separate price list.
-   */
-  previousPrice?: Maybe<Price>;
-  /** Default price for the product in the channel, disregards Customer specific prices. */
-  defaultPrice?: Maybe<Price>;
-  /** Default previous price for the product in the channel, disregards Customer specific prices. */
-  defaultPreviousPrice?: Maybe<Price>;
-  /** Not in use. Always null. */
-  recommendedPrice?: Maybe<Price>;
-  /** The time interval of the discounted price. If the product has variants, the
-   * time interval will be that of the variant which price is shown on the product.
+  categories?: Maybe<Array<Maybe<Category>>>;
+  /** Calculates the price of the product based on the configuration choices that's
+   * been madeNB: Carries a performance cost, as asking for this will result in a
+   * separate API call in the backend.
    */
-  priceDateSpan?: Maybe<ProductPriceDateSpan>;
-  /** Indicates if this product and its variants has member prices. */
-  hasMemberPrice?: Maybe<Scalars['Boolean']>;
-  /** The price a Customer would get if member prices are active and the Customer is logged in.
-   * - Will be null if `Product.hasMemberPrice` is false.
-   * - Will be set if `Product.hasMemberPrice` is true.
+  configurationPrice?: Maybe<ProductConfigurationPrice>;
+  /** Configurations on a product are used to assemble a complete product,
+   *
+   * For example, if the product is a ring then the ring may have two
+   * configurations; measures of circumference and choice of engraving
+   *
+   * In this field, all the configurations of the product will be presented, the configuration name and its various options.
    */
-  memberPrice?: Maybe<Price>;
+  configurations?: Maybe<Array<Maybe<ProductConfiguration>>>;
   /** Specifies input field(s) for the Customer to populate on the Product that will then carry through to the Order.
-   *                     If 'required' is true the Product should not be purchasable until the field is populated.
+   *                     If 'required' is true the Product should not be purchasable
+   * until the field is populated.NB: Carries a performance cost, as asking for
+   * this will result in a separate API call in the backend.
    */
   customerComments?: Maybe<Array<Maybe<ProductComment>>>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  stockStatus?: Maybe<StockStatus>;
   customFields?: Maybe<Array<Maybe<CustomField>>>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  warehouseStock?: Maybe<Array<Maybe<Warehouse>>>;
-  head?: Maybe<HtmlHead>;
-  /** The primary route of this Product. NB: Carries a performance cost, as asking
-   * for this will result in a separate API call in the backend.
-   */
-  primaryRoute?: Maybe<Route>;
-  breadcrumbText?: Maybe<Scalars['String']>;
-  recommendedProducts?: Maybe<RecommendedProducts>;
+  /** Default previous price for the product in the channel, disregards Customer specific prices. */
+  defaultPreviousPrice?: Maybe<Price>;
+  /** Default price for the product in the channel, disregards Customer specific prices. */
+  defaultPrice?: Maybe<Price>;
+  description: Scalars['String'];
   /** The product is recommended to only be purchasable in multiples of the
    * distributionPackageSize. (Different shops may have different levels of
    * leniency on this rule).
    */
   distributionPackageSize: Scalars['Int'];
-  barcode?: Maybe<Scalars['String']>;
-  /** Configurations on a product are used to assemble a complete product,
-   *
-   * For example, if the product is a ring then the ring may have two
-   * configurations; measures of circumference and choice of engraving
-   *
-   * In this field, all the configurations of the product will be presented, the configuration name and its various options.
-   */
-  configurations?: Maybe<Array<Maybe<ProductConfiguration>>>;
   hasConfigurations: Scalars['Boolean'];
-  hasFamilyMembers: Scalars['Boolean'];
-  /** Calculates the price of the product based on the configuration choices that's
-   * been made. NB: Carries a performance cost, as asking for this will result in a
-   * separate API call in the backend.
-   */
-  configurationPrice?: Maybe<ProductConfigurationPrice>;
-  /** Quantity suffix e.g pcs, box, etc. */
-  quantitySuffix?: Maybe<Scalars['String']>;
-  isPreOrder?: Maybe<Scalars['Boolean']>;
-  preOrder?: Maybe<ProductPreOrder>;
+  hasVariants: Scalars['Boolean'];
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  head?: Maybe<HtmlHead>;
+  id: Scalars['Int'];
+  images?: Maybe<Array<Maybe<ProductImage>>>;
+  inPackages?: Maybe<Array<Product>>;
   isPackage?: Maybe<Scalars['Boolean']>;
+  isPreOrder?: Maybe<Scalars['Boolean']>;
+  /** Product header if it differs from the actual product name, usually displayed
+   * instead of the product name in the header tag at the product page.
+   */
+  mainHeader: Scalars['String'];
+  name: Scalars['String'];
   /** ## Description
    * NB: Carries a performance cost, as asking for this will result in a separate API call in the backend.
    * ## Error Codes
@@ -1777,43 +1530,54 @@ export type Product = Document & {
    * Failed to calculate package price
    */
   package?: Maybe<Package>;
+  preOrder?: Maybe<ProductPreOrder>;
+  /** The previous price (i.e. this will be higher than `price` if the product is
+   * discounted). Will be a Customer specific previous price, if that Customer has
+   * a separate price list.
+   */
+  previousPrice?: Maybe<Price>;
+  /** The current price. Will be a Customer specific price, if that Customer has a separate price list. */
+  price?: Maybe<Price>;
+  /** The primary route of this Product. NB: Carries a performance cost, as asking
+   * for this will result in a separate API call in the backend.
+   */
+  primaryRoute?: Maybe<Route>;
+  publishedDate?: Maybe<Scalars['DateTime']>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  quantitySuffix?: Maybe<Scalars['String']>;
+  /** Not in use. Always null. */
+  recommendedPrice?: Maybe<Price>;
+  recommendedProducts?: Maybe<RecommendedProducts>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  relatedProducts?: Maybe<Array<Maybe<Product>>>;
+  shortDescription: Scalars['String'];
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  stockStatus?: Maybe<StockStatus>;
+  subName: Scalars['String'];
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   upsell?: Maybe<Upsell>;
-  inPackages?: Maybe<Array<Product>>;
-  hasUpsell?: Maybe<Scalars['Boolean']>;
-  /** All other products in the same family as the product. NB: Carries a
-   * performance cost, as asking for this will result in a separate API call in the backend.
-   */
-  familyMembers?: Maybe<Array<Product>>;
-  /** Get Product History within the set number of days */
-  history?: Maybe<ProductHistory>;
+  variants?: Maybe<ProductVariants>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  warehouseStock?: Maybe<Array<Maybe<Warehouse>>>;
 };
 
 export type ProductCategoriesArgs = {
   includeHidden?: Maybe<Scalars['Boolean']>;
 };
 
+export type ProductConfigurationPriceArgs = {
+  options?: Maybe<Array<ProductConfigurationPriceInput>>;
+};
+
 export type ProductImagesArgs = {
   includeVariantImages?: Maybe<Scalars['Boolean']>;
   limit?: Maybe<Scalars['Int']>;
 };
 
-export type ProductWarehouseStockArgs = {
-  includeInactive?: Maybe<Scalars['Boolean']>;
-};
-
-export type ProductConfigurationPriceArgs = {
-  options?: Maybe<Array<ProductConfigurationPriceInput>>;
-};
-
 export type ProductPackageArgs = {
   articleNumbers?: Maybe<Array<Maybe<PackagePriceInput>>>;
 };
 
-export type ProductHistoryArgs = {
-  days?: Maybe<Scalars['Int']>;
-};
-
 export type ProductAutoCompleteResult = {
   __typename?: 'ProductAutoCompleteResult';
   result: Array<Maybe<Product>>;
@@ -1821,11 +1585,11 @@ export type ProductAutoCompleteResult = {
 
 export type ProductBadge = {
   __typename?: 'ProductBadge';
-  name?: Maybe<Scalars['String']>;
-  url?: Maybe<Scalars['Uri']>;
   location?: Maybe<ProductBadgeLocation>;
+  name?: Maybe<Scalars['String']>;
   style?: Maybe<Scalars['String']>;
   text?: Maybe<Scalars['String']>;
+  url?: Maybe<Scalars['Uri']>;
 };
 
 export enum ProductBadgeLocation {
@@ -1867,8 +1631,8 @@ export type ProductConfigurationOption = {
 
 export type ProductConfigurationPrice = {
   __typename?: 'ProductConfigurationPrice';
-  price?: Maybe<Price>;
   previousPrice?: Maybe<Price>;
+  price?: Maybe<Price>;
 };
 
 /** Describes how the price is calculated on a configuration option.
@@ -1879,9 +1643,9 @@ export type ProductConfigurationPrice = {
  */
 export type ProductConfigurationPriceCalculation = {
   __typename?: 'ProductConfigurationPriceCalculation';
+  formula?: Maybe<Scalars['String']>;
   id: Scalars['ID'];
   name?: Maybe<Scalars['String']>;
-  formula?: Maybe<Scalars['String']>;
   variables?: Maybe<Array<Maybe<ProductConfigurationPriceCalculationVariable>>>;
 };
 
@@ -1903,27 +1667,22 @@ export enum ProductCustomFieldType {
   MultiLevelList = 'MULTI_LEVEL_LIST'
 }
 
-export type ProductHistory = {
-  __typename?: 'ProductHistory';
-  previousPrice?: Maybe<Array<Maybe<PriceHistory>>>;
-};
-
 export type ProductImage = {
   __typename?: 'ProductImage';
   /** Alternate text for the image, commonly used for the alt attribute of img-tags. */
   alt?: Maybe<Scalars['String']>;
+  modifiedDate?: Maybe<Scalars['String']>;
+  sizes: Array<Maybe<ProductImageSize>>;
   /** Extra information, commonly used for the title attribute of img-tag. Should be shown on hover. */
   title?: Maybe<Scalars['String']>;
-  sizes: Array<Maybe<ProductImageSize>>;
   url?: Maybe<Scalars['Uri']>;
-  modifiedDate?: Maybe<Scalars['String']>;
 };
 
 export type ProductImageSize = {
   __typename?: 'ProductImageSize';
-  width?: Maybe<Scalars['Int']>;
   height?: Maybe<Scalars['Int']>;
   url?: Maybe<Scalars['Uri']>;
+  width?: Maybe<Scalars['Int']>;
 };
 
 export enum ProductOrderOptions {
@@ -1942,78 +1701,46 @@ export type ProductPreOrder = {
   toDate?: Maybe<Scalars['DateTime']>;
 };
 
-export type ProductPriceDateSpan = {
-  __typename?: 'ProductPriceDateSpan';
-  startDate?: Maybe<Scalars['DateTime']>;
-  endDate?: Maybe<Scalars['DateTime']>;
-};
-
 export type ProductSearchResult = {
   __typename?: 'ProductSearchResult';
-  result: Array<Maybe<Product>>;
   filters?: Maybe<Array<Maybe<Filter>>>;
+  result: Array<Maybe<Product>>;
   totalResults?: Maybe<Scalars['Int']>;
 };
 
 export type ProductSortOrder = {
   __typename?: 'ProductSortOrder';
+  defaultDirection: SortDirection;
+  isDefault: Scalars['Boolean'];
   text: Scalars['String'];
   value: ProductOrderOptions;
-  isDefault: Scalars['Boolean'];
-  defaultDirection: SortDirection;
 };
 
 export type ProductVariant = {
   __typename?: 'ProductVariant';
-  id: Scalars['String'];
   articleNumber: Scalars['String'];
-  /** Variant values (combination of option values) */
-  values: Array<Maybe<Scalars['String']>>;
-  /** The current price.
-   * - Will be a Customer specific price if that Customer has a separate price list.
-   * - Will be the member price if Customer is logged in and `Product.hasMemberPrice` is true.
-   * - Will be the non-member price if Customer is not logged in and `Product.hasMemberPrice` is true.
-   */
-  price?: Maybe<Price>;
+  barcode?: Maybe<Scalars['String']>;
+  /** Default previous price for the product in the channel, disregards Customer specific prices. */
+  defaultPreviousPrice?: Maybe<Price>;
+  /** Default price for the product in the channel, disregards Customer specific prices. */
+  defaultPrice?: Maybe<Price>;
+  id: Scalars['String'];
+  images?: Maybe<Array<Maybe<ProductImage>>>;
   /** The previous price (i.e. this will be higher than `price` if the product is
    * discounted). Will be a Customer specific previous price, if that Customer has
    * a separate price list.
    */
   previousPrice?: Maybe<Price>;
-  /** Default price for the product in the channel, disregards Customer specific prices. */
-  defaultPrice?: Maybe<Price>;
-  /** Default previous price for the product in the channel, disregards Customer specific prices. */
-  defaultPreviousPrice?: Maybe<Price>;
+  /** The current price. Will be a Customer specific price, if that Customer has a separate price list. */
+  price?: Maybe<Price>;
   /** Not in use. Always null. */
   recommendedPrice?: Maybe<Price>;
-  /** The time interval of the discounted price. */
-  priceDateSpan?: Maybe<ProductPriceDateSpan>;
-  /** The price a Customer would get if member prices are active and the Customer is logged in.
-   * - Will be null if `Product.hasMemberPrice` is false.
-   * - Will be set if `Product.hasMemberPrice` is true.
-   */
-  memberPrice?: Maybe<Price>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   stockStatus?: Maybe<StockStatus>;
+  /** Variant values (combination of option values) */
+  values: Array<Maybe<Scalars['String']>>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   warehouseStock?: Maybe<Array<Maybe<Warehouse>>>;
-  images?: Maybe<Array<Maybe<ProductImage>>>;
-  barcode?: Maybe<Scalars['String']>;
-  /** Get Product History within the set number of days */
-  history?: Maybe<ProductVariantHistory>;
-};
-
-export type ProductVariantWarehouseStockArgs = {
-  includeInactive?: Maybe<Scalars['Boolean']>;
-};
-
-export type ProductVariantHistoryArgs = {
-  days?: Maybe<Scalars['Int']>;
-};
-
-export type ProductVariantHistory = {
-  __typename?: 'ProductVariantHistory';
-  previousPrice?: Maybe<Array<Maybe<PriceHistory>>>;
 };
 
 export type ProductVariantOption = {
@@ -2032,136 +1759,119 @@ export type ProductVariants = {
 
 export type Query = {
   __typename?: 'Query';
-  store?: Maybe<Store>;
-  stores: Array<Maybe<Store>>;
-  startPage?: Maybe<StartPage>;
-  searchAutoComplete?: Maybe<SearchAutoCompleteResult>;
-  search?: Maybe<SearchResult>;
-  /** get product, category or page by path. */
-  route?: Maybe<Route>;
-  product?: Maybe<Product>;
-  products: Array<Maybe<Product>>;
-  /** Fetch a single page by ID. */
-  page?: Maybe<Page>;
-  /** Fetch all non-hidden pages. If you are using nested pages, only root level pages will be returned. */
-  pages: Array<Maybe<Page>>;
-  /** fetch order by id */
-  order?: Maybe<Order>;
-  /** Fetches my pages content */
-  myPagesContent?: Maybe<MyPagesContent>;
+  cart?: Maybe<Cart>;
+  /** get categories by channel id, culture, root and culture */
+  categories: Array<Maybe<Category>>;
+  /** get category by id */
+  category?: Maybe<Category>;
+  /** get channel by id, null gets default channel */
+  channel?: Maybe<Channel>;
+  /** get all channels */
+  channels: Array<Maybe<Channel>>;
+  customer?: Maybe<Customer>;
+  /** Fetches customer-unique offers */
+  customerLoyalty?: Maybe<CustomerLoyalty>;
   /** get customer product list by id, null gets default product list */
   customerProductList?: Maybe<CustomerProductList>;
   customerProductLists: Array<Maybe<CustomerProductList>>;
-  /** Fetches customer-unique offers */
-  customerLoyalty?: Maybe<CustomerLoyalty>;
-  /** Lookup a customer by a mobile phone number */
-  customerLookup?: Maybe<Customer>;
-  customer?: Maybe<Customer>;
   /** Used in the sign up process when the shop has a third party customer repository, e.g. Voyado.
    *
    * Error codes: INVALID_VALUE (if `key` is null), ExternalCustomerLookupFailed
    */
   externalCustomerLookup?: Maybe<ExternalCustomerResult>;
+  /** Fetches my pages content */
+  myPagesContent?: Maybe<MyPagesContent>;
+  /** fetch order by id */
+  order?: Maybe<Order>;
+  page?: Maybe<Page>;
+  pages: Array<Maybe<Page>>;
   /** Get information on person by Key(personal id number or phone number) */
   personLookup?: Maybe<PersonLookup>;
-  /** Returns content found, either by a list of content Ids, or filtered by tags.
-   * In the case of filtering by ids, not found content Ids are listed as well.
-   */
-  content?: Maybe<MultipleContent>;
-  /** get channel by id, null gets default channel */
-  channel?: Maybe<Channel>;
-  /** get all channels */
-  channels: Array<Maybe<Channel>>;
-  /** get categories by channel id, culture, root and culture */
-  categories: Array<Maybe<Category>>;
-  /** get category by id */
-  category?: Maybe<Category>;
-  cart?: Maybe<Cart>;
+  product?: Maybe<Product>;
+  products: Array<Maybe<Product>>;
+  /** get product, category or page by path. */
+  route?: Maybe<Route>;
+  search?: Maybe<SearchResult>;
+  searchAutoComplete?: Maybe<SearchAutoCompleteResult>;
+  startPage?: Maybe<StartPage>;
+  store?: Maybe<Store>;
+  stores: Array<Maybe<Store>>;
 };
 
-export type QueryStoreArgs = {
-  id: Scalars['Int'];
+export type QueryCartArgs = {
+  id?: Maybe<Scalars['String']>;
 };
 
-export type QueryStoresArgs = {
-  includeInactive?: Scalars['Boolean'];
+export type QueryCategoriesArgs = {
+  root?: Maybe<Scalars['Int']>;
+  levels?: Maybe<Scalars['Int']>;
+  includeHidden?: Maybe<Scalars['Boolean']>;
 };
 
-export type QueryStartPageArgs = {
-  id?: Maybe<Scalars['Int']>;
+export type QueryCategoryArgs = {
+  id: Scalars['Int'];
 };
 
-export type QuerySearchAutoCompleteArgs = {
-  term: Scalars['String'];
+export type QueryChannelArgs = {
+  id?: Maybe<Scalars['String']>;
 };
 
-export type QuerySearchArgs = {
-  term: Scalars['String'];
+export type QueryCustomerProductListArgs = {
+  id?: Maybe<Scalars['ID']>;
+  shareToken?: Maybe<Scalars['String']>;
 };
 
-export type QueryRouteArgs = {
-  path: Scalars['String'];
+export type QueryExternalCustomerLookupArgs = {
+  key?: Maybe<Scalars['String']>;
 };
 
-export type QueryProductArgs = {
-  articleNumber?: Maybe<Scalars['String']>;
+export type QueryOrderArgs = {
   id?: Maybe<Scalars['Int']>;
-  barcode?: Maybe<Scalars['String']>;
-};
-
-export type QueryProductsArgs = {
-  articleNumbers?: Maybe<Array<Maybe<Scalars['String']>>>;
-  ids?: Maybe<Array<Maybe<Scalars['Int']>>>;
-  barcodes?: Maybe<Array<Maybe<Scalars['String']>>>;
+  orderId?: Maybe<Scalars['ID']>;
 };
 
 export type QueryPageArgs = {
   id: Scalars['Int'];
 };
 
-export type QueryOrderArgs = {
-  id?: Maybe<Scalars['Int']>;
-  orderId?: Maybe<Scalars['ID']>;
-};
-
-export type QueryCustomerProductListArgs = {
-  id?: Maybe<Scalars['ID']>;
-  shareToken?: Maybe<Scalars['String']>;
+export type QueryPersonLookupArgs = {
+  key: Scalars['String'];
 };
 
-export type QueryCustomerLookupArgs = {
-  phoneNumber?: Maybe<Scalars['String']>;
+export type QueryProductArgs = {
+  articleNumber?: Maybe<Scalars['String']>;
+  id?: Maybe<Scalars['Int']>;
+  barcode?: Maybe<Scalars['String']>;
 };
 
-export type QueryExternalCustomerLookupArgs = {
-  key?: Maybe<Scalars['String']>;
+export type QueryProductsArgs = {
+  articleNumbers?: Maybe<Array<Maybe<Scalars['String']>>>;
+  ids?: Maybe<Array<Maybe<Scalars['Int']>>>;
+  barcodes?: Maybe<Array<Maybe<Scalars['String']>>>;
 };
 
-export type QueryPersonLookupArgs = {
-  key: Scalars['String'];
+export type QueryRouteArgs = {
+  path: Scalars['String'];
 };
 
-export type QueryContentArgs = {
-  ids?: Maybe<Array<Maybe<Scalars['String']>>>;
-  tags?: Maybe<Array<Maybe<Scalars['String']>>>;
+export type QuerySearchArgs = {
+  term: Scalars['String'];
 };
 
-export type QueryChannelArgs = {
-  id?: Maybe<Scalars['String']>;
+export type QuerySearchAutoCompleteArgs = {
+  term: Scalars['String'];
 };
 
-export type QueryCategoriesArgs = {
-  root?: Maybe<Scalars['Int']>;
-  levels?: Maybe<Scalars['Int']>;
-  includeHidden?: Maybe<Scalars['Boolean']>;
+export type QueryStartPageArgs = {
+  id?: Maybe<Scalars['Int']>;
 };
 
-export type QueryCategoryArgs = {
-  id: Scalars['ID'];
+export type QueryStoreArgs = {
+  id: Scalars['Int'];
 };
 
-export type QueryCartArgs = {
-  id?: Maybe<Scalars['String']>;
+export type QueryStoresArgs = {
+  includeInactive?: Scalars['Boolean'];
 };
 
 export type RangeFilterInput = {
@@ -2174,21 +1884,21 @@ export type RecommendedProducts = {
   __typename?: 'RecommendedProducts';
   /** Customers who bought this product also bought these products. */
   bought?: Maybe<Array<Maybe<Product>>>;
-  /** Customers who viewed this product also viewed these products. */
-  viewed?: Maybe<Array<Maybe<Product>>>;
   /** A shuffled top list of popular products. */
   shuffledToplist?: Maybe<Array<Maybe<Product>>>;
+  /** Customers who viewed this product also viewed these products. */
+  viewed?: Maybe<Array<Maybe<Product>>>;
 };
 
 export type RecommendedProductsBoughtArgs = {
   count?: Maybe<Scalars['Int']>;
 };
 
-export type RecommendedProductsViewedArgs = {
+export type RecommendedProductsShuffledToplistArgs = {
   count?: Maybe<Scalars['Int']>;
 };
 
-export type RecommendedProductsShuffledToplistArgs = {
+export type RecommendedProductsViewedArgs = {
   count?: Maybe<Scalars['Int']>;
 };
 
@@ -2215,10 +1925,12 @@ export type ResetPassword = {
 /** Represents a route to either a Category, a Product, a Page or the StartPage. */
 export type Route = {
   __typename?: 'Route';
-  id: Scalars['String'];
-  path: Scalars['String'];
+  /** Alternative routes for this object, if it exists in another channel and/or in
+   * another language.NB: Carries no additional performance cost.
+   */
+  alternateRoutes?: Maybe<Array<Maybe<AlternateRoute>>>;
   canonicalPath?: Maybe<Scalars['String']>;
-  slug: Scalars['String'];
+  id: Scalars['String'];
   /** The Category, Product, Page or StartPage that the Route resolves to. NB:
    * Carries a performance cost, as asking for this will result in a separate API
    * call in the backend.
@@ -2230,22 +1942,16 @@ export type Route = {
    * categories a shop has, the more expensive this gets), route query in the backend.
    */
   parents?: Maybe<Array<Maybe<Route>>>;
-  /** Alternative routes for this object, if it exists in another channel and/or in
-   * another language.NB: Carries no additional performance cost.
-   */
-  alternateRoutes?: Maybe<Array<Maybe<AlternateRoute>>>;
-  /** N.B. for troubleshooting routes only! */
-  debug?: Maybe<Scalars['String']>;
-  /** Breadcrumb texts; starting with the root parent, ending on this route. */
-  breadcrumbs?: Maybe<Array<Maybe<Scalars['String']>>>;
+  path: Scalars['String'];
+  slug: Scalars['String'];
 };
 
 export type SearchAutoCompleteResult = {
   __typename?: 'SearchAutoCompleteResult';
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  products?: Maybe<ProductAutoCompleteResult>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   categories?: Maybe<CategoryAutoCompleteResult>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  products?: Maybe<ProductAutoCompleteResult>;
 };
 
 export type SearchAutoCompleteResultCategoriesArgs = {
@@ -2254,18 +1960,18 @@ export type SearchAutoCompleteResultCategoriesArgs = {
 
 export type SearchResult = {
   __typename?: 'SearchResult';
-  products?: Maybe<ProductSearchResult>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   categories?: Maybe<CategorySearchResult>;
+  products?: Maybe<ProductSearchResult>;
 };
 
-export type SearchResultProductsArgs = {
+export type SearchResultCategoriesArgs = {
   paging?: Maybe<PagingInput>;
-  filters?: Maybe<FilterInput>;
 };
 
-export type SearchResultCategoriesArgs = {
+export type SearchResultProductsArgs = {
   paging?: Maybe<PagingInput>;
+  filters?: Maybe<FilterInput>;
 };
 
 export type SelectedProductConfiguration = {
@@ -2336,11 +2042,6 @@ export type SignUpDeliveryAddressInput = {
   addressName?: Maybe<Scalars['String']>;
 };
 
-export type SignUpExternalAttribute = {
-  name: Scalars['String'];
-  value: Scalars['String'];
-};
-
 export type SignUpInput = {
   type: CustomerType;
   pid?: Maybe<Scalars['String']>;
@@ -2353,9 +2054,7 @@ export type SignUpInput = {
   deliveryAddresses?: Maybe<Array<Maybe<SignUpDeliveryAddressInput>>>;
   preferences?: Maybe<SignUpPreferencesInput>;
   consents?: Maybe<Array<Maybe<SignUpConsentInput>>>;
-  externalAttributes?: Maybe<Array<Maybe<SignUpExternalAttribute>>>;
   dynamicContent?: Maybe<Scalars['String']>;
-  priceListAccessCode?: Maybe<Scalars['String']>;
 };
 
 export type SignUpPreferencesCommunicationInput = {
@@ -2392,65 +2091,54 @@ export enum SortDirection {
 
 export type StartPage = Document & {
   __typename?: 'StartPage';
+  breadcrumbText?: Maybe<Scalars['String']>;
+  content?: Maybe<Scalars['String']>;
+  /** N.B. not yet in use */
+  data?: Maybe<Content>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  head?: Maybe<HtmlHead>;
   id: Scalars['Int'];
-  name: Scalars['String'];
   images?: Maybe<Array<Maybe<Image>>>;
   isActive?: Maybe<Scalars['Boolean']>;
-  content?: Maybe<Scalars['String']>;
   items?: Maybe<Array<Maybe<StartPageItem>>>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  head?: Maybe<HtmlHead>;
+  name: Scalars['String'];
   /** The primary route of this StartPage */
   primaryRoute?: Maybe<Route>;
-  breadcrumbText?: Maybe<Scalars['String']>;
-  /** Get content data set via the Content Editor. NB: Carries a performance cost,
-   * as asking for this will result in a separate API call in the backend.
-   */
-  data?: Maybe<Content>;
 };
 
 export type StartPageItem = {
   __typename?: 'StartPageItem';
-  id: Scalars['Int'];
-  row?: Maybe<Scalars['Int']>;
   column?: Maybe<Scalars['Int']>;
+  id: Scalars['Int'];
   item: StartPageItemObject;
+  row?: Maybe<Scalars['Int']>;
 };
 
 export type StartPageItemObject = Product | CustomItem;
 
 export type StockStatus = {
   __typename?: 'StockStatus';
-  /** Globally unique id. */
-  id: Scalars['ID'];
-  /** The stock status id, not globally unique. */
-  stockStatusId: Scalars['ID'];
-  text?: Maybe<Scalars['String']>;
   buyable: Scalars['Boolean'];
-  stockNotificationEnabled?: Maybe<Scalars['Boolean']>;
-  stockDate?: Maybe<Scalars['DateTime']>;
+  id: Scalars['ID'];
   maxOrderQuantity?: Maybe<Scalars['Int']>;
+  stockDate?: Maybe<Scalars['DateTime']>;
+  stockNotificationEnabled?: Maybe<Scalars['Boolean']>;
+  text?: Maybe<Scalars['String']>;
 };
 
 export type Store = {
   __typename?: 'Store';
-  id: Scalars['Int'];
-  externalId?: Maybe<Scalars['String']>;
-  name?: Maybe<Scalars['String']>;
-  city?: Maybe<Scalars['String']>;
-  region?: Maybe<Scalars['String']>;
   address1?: Maybe<Scalars['String']>;
   address2?: Maybe<Scalars['String']>;
-  description?: Maybe<Scalars['String']>;
-  other?: Maybe<Scalars['String']>;
-  openHours?: Maybe<Scalars['String']>;
+  city?: Maybe<Scalars['String']>;
   contact?: Maybe<Scalars['String']>;
   coordinates?: Maybe<Coordinates>;
-};
-
-export type StringValue = {
-  __typename?: 'StringValue';
-  value?: Maybe<Scalars['String']>;
+  description?: Maybe<Scalars['String']>;
+  id: Scalars['Int'];
+  name?: Maybe<Scalars['String']>;
+  openHours?: Maybe<Scalars['String']>;
+  other?: Maybe<Scalars['String']>;
+  region?: Maybe<Scalars['String']>;
 };
 
 /** Authorization token that is used for customer actions such as login, delete or update
@@ -2467,15 +2155,7 @@ export type Token = {
 export type Tracking = {
   __typename?: 'Tracking';
   ga?: Maybe<GoogleAnalytics>;
-  ga4?: Maybe<GoogleAnalytics4>;
   gtm?: Maybe<GoogleTagManager>;
-  fca?: Maybe<FacebookConversionsApi>;
-  trackingConsents?: Maybe<TrackingConsents>;
-};
-
-export type TrackingConsents = {
-  __typename?: 'TrackingConsents';
-  useTrackingConsentApi?: Maybe<Scalars['Boolean']>;
 };
 
 export type UpdateCartInput = {
@@ -2495,16 +2175,6 @@ export type UpdateCartMutation = {
   cart?: Maybe<Cart>;
 };
 
-export type UpdateCustomerGroupResult = {
-  __typename?: 'UpdateCustomerGroupResult';
-  success: Scalars['Boolean'];
-};
-
-export type UpdateCustomerPriceListResult = {
-  __typename?: 'UpdateCustomerPriceListResult';
-  success: Scalars['Boolean'];
-};
-
 export type UpdateCustomerProductListInput = {
   id: Scalars['ID'];
   typeId: Scalars['ID'];
@@ -2541,20 +2211,21 @@ export type UpsellDiscountPercentage = {
 
 export type UpsellDiscountValue = {
   __typename?: 'UpsellDiscountValue';
-  valueIncVat: Scalars['Decimal'];
   valueExVat: Scalars['Decimal'];
+  valueIncVat: Scalars['Decimal'];
   valueVat: Scalars['Decimal'];
 };
 
 export type UpsellItem = {
   __typename?: 'UpsellItem';
-  product?: Maybe<Product>;
-  minQuantity: Scalars['Int'];
   discount: UpsellDiscount;
+  minQuantity: Scalars['Int'];
+  product?: Maybe<Product>;
 };
 
 export type Warehouse = {
   __typename?: 'Warehouse';
-  stockLevel?: Maybe<Scalars['Int']>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   location?: Maybe<Store>;
+  stockLevel?: Maybe<Scalars['Int']>;
 };