@jetshop/core 4.3.6 → 4.3.8-non-polyfill

package/types.d.ts

@@ -6,28 +6,15 @@ export type Scalars = {
   Boolean: boolean;
   Int: number;
   Float: number;
-  Uri: any;
-  /** The `Paging` scalar type represents a numeric values between (0; 100> */
-  Paging: any;
   Decimal: any;
+  Uri: 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 `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;
-  /** The `Milliseconds` scalar type represents a period of time represented as the total number of milliseconds. */
-  Milliseconds: any;
-  /** The `Seconds` scalar type represents a period of time represented as the total number of seconds. */
-  Seconds: any;
+  /** The `Paging` scalar type represents a numeric values between <1; 100> */
+  Paging: any;
 };
 
 export type ActivateExternalCustomerByIdInput = {
@@ -46,15 +33,16 @@ export type ActivateExternalCustomerByTokenInput = {
 
 export type ActivateExternalCustomerByTokenResult = {
   __typename?: 'ActivateExternalCustomerByTokenResult';
-  customer?: Maybe<ExternalCustomer>;
   success: Scalars['Boolean'];
+  customer?: Maybe<ExternalCustomer>;
 };
 
 export enum ActivationStatusSource {
   PreexistingCustomer = 'PREEXISTING_CUSTOMER',
   ActivationRequired = 'ACTIVATION_REQUIRED',
   AdditionalUserDataRequired = 'ADDITIONAL_USER_DATA_REQUIRED',
-  NonExistingCustomer = 'NON_EXISTING_CUSTOMER'
+  NonExistingCustomer = 'NON_EXISTING_CUSTOMER',
+  CountryNotValid = 'COUNTRY_NOT_VALID'
 }
 
 export type ActiveFilters = {
@@ -93,10 +81,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 & {
@@ -113,26 +101,33 @@ export type BooleanFilterInput = {
   value?: Maybe<Scalars['Boolean']>;
 };
 
+export type BoolValue = {
+  __typename?: 'BoolValue';
+  value?: Maybe<Scalars['Boolean']>;
+};
+
 export type BusinessCustomer = Customer & {
   __typename?: 'BusinessCustomer';
-  billingAddress?: Maybe<CustomerAddress>;
-  communication?: Maybe<CustomerCommunication>;
-  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
-  dynamicContent?: Maybe<Scalars['String']>;
+  organizationId?: Maybe<Scalars['String']>;
+  organizationNumber?: Maybe<Scalars['String']>;
+  id: Scalars['ID'];
+  memberId?: Maybe<Scalars['String']>;
   email?: Maybe<Scalars['String']>;
-  externalAttributes?: Maybe<Array<Maybe<CustomerExternalAttribute>>>;
   /** Customer id for external system */
   externalId?: Maybe<Scalars['String']>;
-  id: Scalars['ID'];
+  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
   language?: Maybe<Language>;
-  memberId?: Maybe<Scalars['String']>;
+  billingAddress?: Maybe<CustomerAddress>;
+  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   orderHeaders?: Maybe<OrderHeaderResult>;
-  organizationId?: Maybe<Scalars['String']>;
-  organizationNumber?: Maybe<Scalars['String']>;
+  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>;
-  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
+  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']>;
 };
 
 export type BusinessCustomerOrderHeadersArgs = {
@@ -142,40 +137,40 @@ export type BusinessCustomerOrderHeadersArgs = {
 
 export type Cart = {
   __typename?: 'Cart';
-  aggregatedDiscounts?: Maybe<Array<Maybe<Discount>>>;
+  id?: Maybe<Scalars['String']>;
+  totalQuantity?: Maybe<Scalars['Int']>;
+  productTotal?: Maybe<Price>;
+  productPreviousTotal?: Maybe<Price>;
   discountTotal?: Maybe<Price>;
+  aggregatedDiscounts?: Maybe<Array<Maybe<Discount>>>;
   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'];
-  configurations?: Maybe<Array<Maybe<SelectedProductConfiguration>>>;
+  images?: Maybe<Array<Maybe<ProductImage>>>;
+  subHeading?: Maybe<Scalars['String']>;
+  variant?: Maybe<ProductVariant>;
+  variantOptionNames?: Maybe<Array<Maybe<Scalars['String']>>>;
   customerComments?: Maybe<Array<Maybe<CartItemComment>>>;
-  /** Discount total */
-  discount?: Maybe<Price>;
   discounts?: Maybe<Array<Maybe<Discount>>>;
-  id: Scalars['String'];
-  images?: Maybe<Array<Maybe<ProductImage>>>;
-  preOrderDate?: Maybe<Scalars['DateTime']>;
+  /** Total price, including discounts */
+  total: Price;
   /** 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>;
-  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']>>>;
+  configurations?: Maybe<Array<Maybe<SelectedProductConfiguration>>>;
+  preOrderDate?: Maybe<Scalars['DateTime']>;
 };
 
 export type CartItemComment = {
@@ -191,35 +186,52 @@ export type CartMutation = {
 
 export type Category = Document & {
   __typename?: 'Category';
-  breadcrumbText?: Maybe<Scalars['String']>;
-  content?: Maybe<Scalars['String']>;
-  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>;
   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'];
+  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'];
-  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']>;
+  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>;
+  /** 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>;
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  products?: Maybe<PagedResult>;
+  breadcrumbText?: Maybe<Scalars['String']>;
+  hasSubcategories?: Maybe<Scalars['Boolean']>;
   subcategories?: Maybe<Array<Maybe<Category>>>;
+  parentCategory?: Maybe<Category>;
+  parent?: Maybe<Category>;
+  /** 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.
+   */
+  allowWebIndexing?: Maybe<Scalars['Boolean']>;
 };
 
 export type CategoryProductsArgs = {
@@ -230,16 +242,33 @@ 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 = {
@@ -258,43 +287,83 @@ export type ChangeByOneItemQuantityInput = {
  */
 export type Channel = {
   __typename?: 'Channel';
-  countries?: Maybe<Array<Maybe<Country>>>;
-  currencies?: Maybe<Array<Maybe<Currency>>>;
-  defaultCurrency?: Maybe<Currency>;
-  defaultLanguage?: Maybe<Language>;
+  id: Scalars['Int'];
+  name?: Maybe<Scalars['String']>;
   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']>;
+  url?: Maybe<Scalars['Uri']>;
+  settings?: Maybe<ChannelSettings>;
   languages?: Maybe<Array<Maybe<Language>>>;
-  name?: Maybe<Scalars['String']>;
+  defaultLanguage?: Maybe<Language>;
+  currencies?: Maybe<Array<Maybe<Currency>>>;
+  defaultCurrency?: Maybe<Currency>;
+  countries?: Maybe<Array<Maybe<Country>>>;
+  /** The root url of images, this can be used to build image urls if needed. */
+  imageUrl?: 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';
-  countrySettings?: Maybe<Array<Maybe<CountrySettings>>>;
-  nostoAccountId?: Maybe<Scalars['String']>;
   pricesIncVat?: Maybe<Scalars['Boolean']>;
+  countrySettings?: Maybe<Array<Maybe<CountrySettings>>>;
   tracking?: Maybe<Tracking>;
+  nostoAccountId?: Maybe<Scalars['String']>;
 };
 
 export type Consent = {
   __typename?: 'Consent';
   id: Scalars['ID'];
-  isMandatory?: Maybe<Scalars['Boolean']>;
-  linkText?: Maybe<Scalars['String']>;
   name?: Maybe<Scalars['String']>;
-  page?: Maybe<Page>;
-  text?: Maybe<Scalars['String']>;
   title?: Maybe<Scalars['String']>;
+  text?: Maybe<Scalars['String']>;
+  linkText?: Maybe<Scalars['String']>;
+  page?: Maybe<Page>;
+  isMandatory?: Maybe<Scalars['Boolean']>;
+};
+
+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'];
+  properties?: Maybe<Array<Maybe<ContentItemProperty>>>;
+  children?: Maybe<Array<Maybe<ContentItem>>>;
+};
+
+export type ContentItemPropertiesArgs = {
+  getImageAsImageValue?: Maybe<Scalars['Boolean']>;
+};
+
+export type ContentItemProperty = {
+  __typename?: 'ContentItemProperty';
+  name: Scalars['String'];
+  type: Scalars['String'];
+  valueType?: Maybe<ContentPropertyValueType>;
+  value?: Maybe<ContentItemPropertyValue>;
 };
 
+export type ContentItemPropertyValue =
+  | StringValue
+  | ImageValue
+  | BoolValue
+  | Product
+  | Category;
+
+export enum ContentPropertyValueType {
+  Object = 'OBJECT',
+  Scalar = 'SCALAR'
+}
+
 export type Coordinates = {
   __typename?: 'Coordinates';
   latitude: Scalars['Decimal'];
@@ -303,33 +372,33 @@ export type Coordinates = {
 
 export type Country = {
   __typename?: 'Country';
-  code?: Maybe<Scalars['String']>;
   id: Scalars['ID'];
-  isDefault?: Maybe<Scalars['Boolean']>;
+  code?: Maybe<Scalars['String']>;
   name?: Maybe<Scalars['String']>;
+  isDefault?: Maybe<Scalars['Boolean']>;
 };
 
 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`
    */
-  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>>>;
+  privateCustomerConsents?: Maybe<Array<Maybe<Consent>>>;
   /** 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>>>;
-  /** 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>;
+  businessCustomerConsents?: Maybe<Array<Maybe<Consent>>>;
 };
 
 export type CreateCustomerProductListInput = {
@@ -341,44 +410,46 @@ export type CreateCustomerProductListInput = {
 
 export type Currency = {
   __typename?: 'Currency';
-  format?: Maybe<CurrencyFormat>;
   id: Scalars['String'];
-  isDefault?: Maybe<Scalars['Boolean']>;
   name?: Maybe<Scalars['String']>;
+  isDefault?: Maybe<Scalars['Boolean']>;
+  format?: Maybe<CurrencyFormat>;
 };
 
 export type CurrencyFormat = {
   __typename?: 'CurrencyFormat';
-  code: Scalars['String'];
   culture: Scalars['String'];
+  code: 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 = {
-  billingAddress?: Maybe<CustomerAddress>;
-  communication?: Maybe<CustomerCommunication>;
-  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
-  dynamicContent?: Maybe<Scalars['String']>;
+  id: Scalars['ID'];
+  memberId?: Maybe<Scalars['String']>;
   email?: Maybe<Scalars['String']>;
-  externalAttributes?: Maybe<Array<Maybe<CustomerExternalAttribute>>>;
   /** Customer id for external system */
   externalId?: Maybe<Scalars['String']>;
-  id: Scalars['ID'];
+  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
   language?: Maybe<Language>;
-  memberId?: Maybe<Scalars['String']>;
+  billingAddress?: Maybe<CustomerAddress>;
+  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
   /** 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>;
-  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
+  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']>;
 };
 
 export type CustomerOrderHeadersArgs = {
@@ -388,22 +459,22 @@ export type CustomerOrderHeadersArgs = {
 
 export type CustomerAddress = {
   __typename?: 'CustomerAddress';
+  id?: Maybe<Scalars['Int']>;
   addressName?: 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']>;
   firstName?: Maybe<Scalars['String']>;
-  id?: Maybe<Scalars['Int']>;
   lastName?: Maybe<Scalars['String']>;
-  mobilePhone?: Maybe<Scalars['String']>;
-  municipality?: Maybe<Scalars['String']>;
-  phone?: Maybe<Scalars['String']>;
+  companyAtt?: Maybe<Scalars['String']>;
+  company?: Maybe<Scalars['String']>;
+  department?: Maybe<Scalars['String']>;
+  streetName?: Maybe<Scalars['String']>;
+  co?: Maybe<Scalars['String']>;
   postalCode?: Maybe<Scalars['String']>;
+  city?: Maybe<Scalars['String']>;
+  municipality?: Maybe<Scalars['String']>;
   region?: Maybe<Scalars['String']>;
-  streetName?: Maybe<Scalars['String']>;
+  country?: Maybe<Country>;
+  phone?: Maybe<Scalars['String']>;
+  mobilePhone?: Maybe<Scalars['String']>;
 };
 
 export type CustomerCommunication = {
@@ -421,32 +492,36 @@ export type CustomerExternalAttribute = {
 
 export type CustomerField = {
   __typename?: 'CustomerField';
-  fields?: Maybe<Array<Maybe<CustomerField>>>;
   id: Scalars['ID'];
-  name: Scalars['ID'];
-  pattern?: Maybe<Scalars['String']>;
   required: Scalars['Boolean'];
+  pattern?: Maybe<Scalars['String']>;
+  fields?: Maybe<Array<Maybe<CustomerField>>>;
+  name: Scalars['ID'];
 };
 
 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'];
 };
 
 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']>;
-  startDate?: Maybe<Scalars['DateTime']>;
+  /** For display purposes, not guaranteed to match up with a currency on the channel. */
+  currency?: Maybe<Scalars['String']>;
   value?: Maybe<Scalars['Decimal']>;
 };
 
@@ -457,66 +532,68 @@ export type CustomerLoyaltyBonusPoints = {
 
 export type CustomerLoyaltyDiscount = {
   __typename?: 'CustomerLoyaltyDiscount';
-  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  category?: Maybe<Category>;
+  name?: Maybe<Scalars['String']>;
   description?: Maybe<Scalars['String']>;
+  startDate?: Maybe<Scalars['DateTime']>;
   endDate?: Maybe<Scalars['DateTime']>;
   externalData?: Maybe<CustomerLoyaltyDiscountOfferExternalData>;
-  name?: Maybe<Scalars['String']>;
-  startDate?: Maybe<Scalars['DateTime']>;
+  /** 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']>;
 };
 
 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']>;
-  imageUrl?: Maybe<Scalars['String']>;
-  link?: Maybe<Scalars['String']>;
-  name?: Maybe<Scalars['String']>;
   redeemed?: Maybe<Scalars['Boolean']>;
   redeemedOn?: Maybe<Scalars['DateTime']>;
-  startDate?: Maybe<Scalars['DateTime']>;
+  imageUrl?: Maybe<Scalars['String']>;
+  link?: Maybe<Scalars['String']>;
 };
 
 export type CustomerLoyaltyPointCard = {
   __typename?: 'CustomerLoyaltyPointCard';
   externalId?: Maybe<Scalars['String']>;
-  isActive?: Maybe<Scalars['Boolean']>;
-  lastStampTime?: Maybe<Scalars['DateTime']>;
   name?: Maybe<Scalars['String']>;
+  lastStampTime?: Maybe<Scalars['DateTime']>;
   numberOfSlots?: Maybe<Scalars['Int']>;
   numberOfSlotsRemaining?: Maybe<Scalars['Int']>;
+  isActive?: Maybe<Scalars['Boolean']>;
 };
 
 export type CustomerProductList = {
   __typename?: 'CustomerProductList';
-  description?: Maybe<Scalars['String']>;
   id: Scalars['ID'];
-  /** 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']>;
   shareToken?: Maybe<Scalars['String']>;
+  name?: Maybe<Scalars['String']>;
+  description?: 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']>;
-  /** 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>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  product?: Maybe<Product>;
 };
 
 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 = {
@@ -574,13 +651,20 @@ 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']>;
 };
 
@@ -603,42 +687,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';
-  content?: Maybe<Scalars['String']>;
   id: Scalars['Int'];
-  image?: Maybe<Image>;
-  linkUrl?: Maybe<Scalars['Uri']>;
   name: Scalars['String'];
+  content?: Maybe<Scalars['String']>;
+  linkUrl?: Maybe<Scalars['Uri']>;
+  image?: Maybe<Image>;
 };
 
 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 = {
@@ -651,10 +735,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 = {
@@ -664,46 +748,93 @@ export type DeleteCustomerProductListResult = {
 
 export type Discount = {
   __typename?: 'Discount';
-  campaign?: Maybe<Category>;
-  description?: Maybe<Scalars['String']>;
+  externalId?: Maybe<Scalars['ID']>;
   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';
-  address?: Maybe<MaskedProperty>;
-  city?: Maybe<MaskedProperty>;
-  co?: Maybe<MaskedProperty>;
-  country?: Maybe<MaskedProperty>;
-  email?: Maybe<MaskedProperty>;
   externalId?: Maybe<Scalars['String']>;
+  email?: Maybe<MaskedProperty>;
   firstName?: Maybe<MaskedProperty>;
   lastName?: Maybe<MaskedProperty>;
-  mobilePhoneNumber?: Maybe<MaskedProperty>;
+  co?: Maybe<MaskedProperty>;
+  address?: Maybe<MaskedProperty>;
+  city?: Maybe<MaskedProperty>;
+  postalCode?: Maybe<MaskedProperty>;
+  country?: Maybe<MaskedProperty>;
+  countryCode?: Maybe<Scalars['String']>;
   phoneNumber?: Maybe<MaskedProperty>;
+  mobilePhoneNumber?: 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)
- * and externalId will be the only fields set on `customer`.
+ * ACTIVATION_REQUIRED: The customer account needs to be activated. Email (masked),
+ * FirstName (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';
-  customer?: Maybe<ExternalCustomer>;
   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']>;
 };
 
 export type Filter = {
@@ -720,8 +851,8 @@ export type FilterInput = {
 
 export type FreeShippingLimit = {
   __typename?: 'FreeShippingLimit';
-  exVat?: Maybe<Scalars['Decimal']>;
   incVat?: Maybe<Scalars['Decimal']>;
+  exVat?: Maybe<Scalars['Decimal']>;
 };
 
 export type GoogleAnalytics = {
@@ -730,29 +861,43 @@ 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';
-  metaTags?: Maybe<Array<Maybe<HtmlMetaTag>>>;
   title?: Maybe<Scalars['String']>;
+  metaTags?: Maybe<Array<Maybe<HtmlMetaTag>>>;
 };
 
 export type HtmlMetaTag = {
   __typename?: 'HtmlMetaTag';
-  content?: Maybe<Scalars['String']>;
   name?: Maybe<Scalars['String']>;
+  content?: 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 = {
@@ -762,17 +907,23 @@ export type InputComment = {
 
 export type Language = {
   __typename?: 'Language';
-  culture: Scalars['String'];
   id: Scalars['String'];
-  isDefault?: Maybe<Scalars['Boolean']>;
   name: Scalars['String'];
+  culture: Scalars['String'];
+  isDefault?: Maybe<Scalars['Boolean']>;
+};
+
+export type Link = {
+  __typename?: 'Link';
+  target?: Maybe<Scalars['String']>;
+  link?: Maybe<Scalars['Uri']>;
 };
 
 export type ListFilter = Filter & {
   __typename?: 'ListFilter';
   hasActiveItems: Scalars['Boolean'];
-  id: Scalars['String'];
   items: Array<Maybe<ListFilterItem>>;
+  id: Scalars['String'];
   name: Scalars['String'];
 };
 
@@ -784,10 +935,15 @@ export type ListFilterInput = {
 export type ListFilterItem = {
   __typename?: 'ListFilterItem';
   isActive?: Maybe<Scalars['Boolean']>;
-  id: Scalars['String'];
-  resultCount?: Maybe<Scalars['Int']>;
   text: Scalars['String'];
+  id: Scalars['String'];
   value: Scalars['String'];
+  resultCount?: Maybe<Scalars['Int']>;
+};
+
+export type ListStringValue = {
+  __typename?: 'ListStringValue';
+  value?: Maybe<Array<Maybe<Scalars['String']>>>;
 };
 
 export type LoginExternalCustomerInput = {
@@ -803,19 +959,20 @@ export type LoginExternalCustomerResult = {
 export type LoginResponse = {
   __typename?: 'LoginResponse';
   token: Token;
+  customerId?: Maybe<Scalars['Int']>;
 };
 
 export type MaskedProperty = {
   __typename?: 'MaskedProperty';
-  encrypted?: Maybe<Scalars['String']>;
   masked?: Maybe<Scalars['String']>;
+  encrypted?: Maybe<Scalars['String']>;
 };
 
 export type MultiListFilter = Filter & {
   __typename?: 'MultiListFilter';
   isActive: Scalars['Boolean'];
-  id: Scalars['String'];
   lists: Array<Maybe<MultiListFilterList>>;
+  id: Scalars['String'];
   name: Scalars['String'];
 };
 
@@ -828,8 +985,14 @@ export type MultiListFilterList = {
   __typename?: 'MultiListFilterList';
   hasActiveItems: Scalars['Boolean'];
   id: Scalars['String'];
-  items: Array<Maybe<ListFilterItem>>;
   name: Scalars['String'];
+  items: Array<Maybe<ListFilterItem>>;
+};
+
+export type MultipleContent = {
+  __typename?: 'MultipleContent';
+  notFoundIds: Array<Maybe<Scalars['ID']>>;
+  content: Array<Maybe<Content>>;
 };
 
 export type Mutation = {
@@ -844,26 +1007,13 @@ export type Mutation = {
   setMultiListFilter?: Maybe<MultiListFilter>;
   clearMultiListFilter?: Maybe<MultiListFilter>;
   clearMultiListFilterList?: Maybe<MultiListFilter>;
-  /** Error codes: CustomerNotFound, CustomerAlreadyActivated,
-   * UnableToActivateCustomer, UnableToLoginCustomer, InvalidCustomerActivateInput
-   */
-  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.
+  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
    */
-  addToCart?: Maybe<CartMutation>;
+  subscribeToNewsletter?: Maybe<Scalars['Boolean']>;
   /** ## Description
    * Adds items to product list, null id adds items to the default product list.
    * ## Error Codes
@@ -888,14 +1038,6 @@ 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
@@ -907,18 +1049,6 @@ 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
@@ -936,32 +1066,23 @@ 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
+  /** ## Description
+   * Updates an item in product list, null id updates item in the default product list.
+   * ## Error Codes
+   * ### Unauthorized
    *
-   * 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.
+   * ### ProductListNotFound
+   * Argument `id` did not match any list for this customer.
+   * ### UnableToUpdateProductListItem
+   * Error in underlying API call, more info may be contained in the error message.
+   * ### ProductNotFound
+   * Argument `articleNumber` did not match any products or variants.
+   * ### MoreThanOneMatchOnArticleNumber
+   * Argument `articleNumber` matched more than one product/variant.
+   * ### InvalidArticleNumber
+   * Argument `articleNumber` cannot be null or empty.
    */
-  updateCustomer?: Maybe<CustomerUpdateResponse>;
+  updateCustomerProductListItem?: Maybe<CustomerProductListResult>;
   /** ## Description
    * Updates a product list for a logged in customer
    * ## Error Codes
@@ -973,25 +1094,87 @@ export type Mutation = {
    * 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
-   * Updates an item in product list, null id updates item in the default product list.
+   * 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
-   *
-   * ### ProductListNotFound
-   * Argument `id` did not match any list for this customer.
-   * ### UnableToUpdateProductListItem
+   * Unauthorized
+   * ### UnableToUpdateCustomer
    * Error in underlying API call, more info may be contained in the error message.
-   * ### ProductNotFound
-   * Argument `articleNumber` did not match any products or variants.
-   * ### MoreThanOneMatchOnArticleNumber
-   * Argument `articleNumber` matched more than one product/variant.
-   * ### InvalidArticleNumber
-   * Argument `articleNumber` cannot be null or empty.
+   * ### CustomerAlreadyUpdated
+   * Customer already in the customer group
+   * ### CustomerNotFound
+   * No match on customer with access code
    */
-  updateCustomerProductListItem?: Maybe<CustomerProductListResult>;
+  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 = {
@@ -1038,21 +1221,13 @@ export type MutationClearMultiListFilterListArgs = {
   filter: MultiListFilter;
 };
 
-export type MutationActivateExternalCustomerByIdArgs = {
-  input?: Maybe<ActivateExternalCustomerByIdInput>;
-};
-
-export type MutationActivateExternalCustomerByTokenArgs = {
-  input?: Maybe<ActivateExternalCustomerByTokenInput>;
-};
-
-export type MutationAddMultipleToCartArgs = {
-  cartId?: Maybe<Scalars['String']>;
-  items: Array<Maybe<AddMultipleToCartInput>>;
+export type MutationSubscribeToStockNotificationsArgs = {
+  email: Scalars['String'];
+  articleNumber: Scalars['String'];
 };
 
-export type MutationAddToCartArgs = {
-  input: AddToCartInput;
+export type MutationSubscribeToNewsletterArgs = {
+  email: Scalars['String'];
 };
 
 export type MutationAddToCustomerProductListArgs = {
@@ -1064,41 +1239,45 @@ export type MutationCreateCustomerProductListArgs = {
   input: CreateCustomerProductListInput;
 };
 
-export type MutationDecrementItemQuantityArgs = {
-  input: ChangeByOneItemQuantityInput;
-};
-
 export type MutationDeleteCustomerProductListArgs = {
   id: Scalars['ID'];
 };
 
-export type MutationIncrementItemQuantityArgs = {
-  input: ChangeByOneItemQuantityInput;
+export type MutationRemoveFromCustomerProductListArgs = {
+  id?: Maybe<Scalars['ID']>;
+  articleNumbers?: Maybe<Array<Scalars['String']>>;
 };
 
-export type MutationLoginArgs = {
-  password: Scalars['String'];
-  email?: Maybe<Scalars['String']>;
-  pid?: Maybe<Scalars['String']>;
-  externalId?: Maybe<Scalars['String']>;
-  memberNumber?: Maybe<Scalars['String']>;
+export type MutationUpdateCustomerProductListItemArgs = {
+  input: UpdateCustomerProductListItemInput;
 };
 
-export type MutationLoginExternalCustomerArgs = {
-  input?: Maybe<LoginExternalCustomerInput>;
+export type MutationUpdateCustomerProductListArgs = {
+  input: UpdateCustomerProductListInput;
 };
 
-export type MutationRemoveFromCartArgs = {
-  input: RemoveFromCartInput;
+export type MutationActivateExternalCustomerByIdArgs = {
+  input?: Maybe<ActivateExternalCustomerByIdInput>;
 };
 
-export type MutationRemoveFromCustomerProductListArgs = {
-  id?: Maybe<Scalars['ID']>;
-  articleNumbers?: Maybe<Array<Scalars['String']>>;
+export type MutationActivateExternalCustomerByTokenArgs = {
+  input?: Maybe<ActivateExternalCustomerByTokenInput>;
 };
 
-export type MutationRemoveMultipleFromCartArgs = {
-  input: RemoveMultipleFromCartInput;
+export type MutationLoginExternalCustomerArgs = {
+  input?: Maybe<LoginExternalCustomerInput>;
+};
+
+export type MutationLoginArgs = {
+  password?: Maybe<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 = {
@@ -1110,42 +1289,58 @@ export type MutationResetPasswordArgs = {
   newPassword: Scalars['String'];
 };
 
-export type MutationSetItemQuantityArgs = {
-  input: SetItemQuantityInput;
-};
-
 export type MutationSignUpArgs = {
   input: SignUpInput;
 };
 
-export type MutationSubscribeToNewsletterArgs = {
-  email: Scalars['String'];
+export type MutationUpdateCustomerGroupArgs = {
+  customerGroupAccessCode: Scalars['String'];
 };
 
-export type MutationSubscribeToStockNotificationsArgs = {
-  email: Scalars['String'];
-  articleNumber: Scalars['String'];
+export type MutationUpdateCustomerArgs = {
+  input: CustomerUpdateInput;
 };
 
-export type MutationUpdateCartArgs = {
-  input: UpdateCartInput;
+export type MutationUpdateCustomerPriceListArgs = {
+  priceListAccessCode: Scalars['String'];
 };
 
-export type MutationUpdateCustomerArgs = {
-  input: CustomerUpdateInput;
+export type MutationUpdatePasswordArgs = {
+  oldPassword: Scalars['String'];
+  newPassword: Scalars['String'];
 };
 
-export type MutationUpdateCustomerProductListArgs = {
-  input: UpdateCustomerProductListInput;
+export type MutationAddMultipleToCartArgs = {
+  cartId?: Maybe<Scalars['String']>;
+  items: Array<Maybe<AddMultipleToCartInput>>;
 };
 
-export type MutationUpdateCustomerProductListItemArgs = {
-  input: UpdateCustomerProductListItemInput;
+export type MutationAddToCartArgs = {
+  input: AddToCartInput;
 };
 
-export type MutationUpdatePasswordArgs = {
-  oldPassword: Scalars['String'];
-  newPassword: Scalars['String'];
+export type MutationDecrementItemQuantityArgs = {
+  input: ChangeByOneItemQuantityInput;
+};
+
+export type MutationSetItemQuantityArgs = {
+  input: SetItemQuantityInput;
+};
+
+export type MutationIncrementItemQuantityArgs = {
+  input: ChangeByOneItemQuantityInput;
+};
+
+export type MutationRemoveFromCartArgs = {
+  input: RemoveFromCartInput;
+};
+
+export type MutationRemoveMultipleFromCartArgs = {
+  input: RemoveMultipleFromCartInput;
+};
+
+export type MutationUpdateCartArgs = {
+  input: UpdateCartInput;
 };
 
 export type MyPagesContent = {
@@ -1158,26 +1353,28 @@ export type NumericRangeFilter = Filter & {
   __typename?: 'NumericRangeFilter';
   isActive: Scalars['Boolean'];
   value?: Maybe<Array<Maybe<Scalars['Decimal']>>>;
-  id: Scalars['String'];
-  max: Scalars['Decimal'];
   min: Scalars['Decimal'];
+  max: Scalars['Decimal'];
+  id: Scalars['String'];
   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>>>;
-  id: Scalars['ID'];
-  items?: Maybe<Array<Maybe<OrderItem>>>;
-  orderDate?: Maybe<Scalars['Date']>;
-  orderNumber?: Maybe<Scalars['String']>;
-  paymentMethod?: Maybe<OrderPaymentMethod>;
-  status?: Maybe<OrderStatus>;
   total?: Maybe<Price>;
+  orderDate?: Maybe<Scalars['DateTime']>;
+  currency?: Maybe<Currency>;
+  attachments?: Maybe<Array<Maybe<OrderAttachment>>>;
+  orderPurchaseLocation?: Maybe<Scalars['String']>;
 };
 
 export type OrderItemsArgs = {
@@ -1187,18 +1384,24 @@ 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>;
-  postcode?: Maybe<Scalars['String']>;
-  region?: Maybe<Scalars['String']>;
-  street?: Maybe<Scalars['String']>;
+};
+
+export type OrderAttachment = {
+  __typename?: 'OrderAttachment';
+  id: Scalars['ID'];
+  url?: Maybe<Scalars['String']>;
 };
 
 export type OrderDeliveryMethod = {
   __typename?: 'OrderDeliveryMethod';
-  fee?: Maybe<Price>;
   name?: Maybe<Scalars['String']>;
+  fee?: Maybe<Price>;
   tracking?: Maybe<OrderDeliveryMethodTracking>;
 };
 
@@ -1210,24 +1413,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['Date']>;
+  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['Date']>;
   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 = {
@@ -1238,27 +1441,26 @@ 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']>;
-  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>;
+  total?: Maybe<Price>;
+  discounts?: Maybe<Array<Maybe<OrderItemDiscount>>>;
+  /** N.B. this may be null if the Product has since been removed. */
+  product?: Maybe<Product>;
   /** 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. */
@@ -1268,6 +1470,9 @@ 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 = {
@@ -1277,29 +1482,29 @@ export type OrderItemDiscount = {
 
 export type OrderPaymentMethod = {
   __typename?: 'OrderPaymentMethod';
-  fee?: Maybe<Price>;
   name?: Maybe<Scalars['String']>;
+  fee?: Maybe<Price>;
 };
 
 export type OrderStatus = {
   __typename?: 'OrderStatus';
-  description?: Maybe<Scalars['String']>;
   id?: Maybe<Scalars['ID']>;
+  description?: Maybe<Scalars['String']>;
   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 previous package price without any potential discount */
-  previousPrice?: Maybe<Price>;
   /** 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']>;
 };
 
 export type PackageDiscount = PackageDiscountPercentage | PackageDiscountValue;
@@ -1311,20 +1516,20 @@ export type PackageDiscountPercentage = {
 
 export type PackageDiscountValue = {
   __typename?: 'PackageDiscountValue';
-  valueExVat: Scalars['Decimal'];
   valueIncVat: Scalars['Decimal'];
+  valueExVat: Scalars['Decimal'];
   valueVat: Scalars['Decimal'];
 };
 
 export type PackageItem = {
   __typename?: 'PackageItem';
-  discount?: Maybe<PackageDiscount>;
+  product?: Maybe<Product>;
   minQuantity: Scalars['Int'];
-  /** The previous package price without any potential discount */
-  previousPrice?: Maybe<Price>;
+  discount?: Maybe<PackageDiscount>;
   /** The current package price with any potential discount */
   price?: Maybe<Price>;
-  product?: Maybe<Product>;
+  /** The previous package price without any potential discount */
+  previousPrice?: Maybe<Price>;
 };
 
 export type PackagePriceInput = {
@@ -1334,28 +1539,55 @@ export type PackagePriceInput = {
 
 export type Page = Document & {
   __typename?: 'Page';
-  breadcrumbText?: Maybe<Scalars['String']>;
+  id: Scalars['ID'];
+  name: Scalars['String'];
+  mainHeader?: 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 = {
@@ -1369,51 +1601,59 @@ 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>;
-  co?: Maybe<MaskedProperty>;
+  postalCode?: Maybe<MaskedProperty>;
   country?: Maybe<MaskedProperty>;
-  firstName?: Maybe<MaskedProperty>;
-  lastName?: Maybe<MaskedProperty>;
-  mobilePhoneNumber?: Maybe<MaskedProperty>;
   phoneNumber?: Maybe<MaskedProperty>;
-  postalCode?: Maybe<MaskedProperty>;
+  mobilePhoneNumber?: Maybe<MaskedProperty>;
 };
 
 export type Price = {
   __typename?: 'Price';
-  exVat: Scalars['Decimal'];
   incVat: Scalars['Decimal'];
+  exVat: Scalars['Decimal'];
   vat: Scalars['Decimal'];
 };
 
+export type PriceHistory = {
+  __typename?: 'PriceHistory';
+  timestamp?: Maybe<Scalars['DateTime']>;
+  price?: Maybe<Price>;
+};
+
 export type PrivateCustomer = Customer & {
   __typename?: 'PrivateCustomer';
-  billingAddress?: Maybe<CustomerAddress>;
-  communication?: Maybe<CustomerCommunication>;
-  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
-  dynamicContent?: Maybe<Scalars['String']>;
+  pid?: Maybe<Scalars['String']>;
+  id: Scalars['ID'];
+  memberId?: Maybe<Scalars['String']>;
   email?: Maybe<Scalars['String']>;
-  externalAttributes?: Maybe<Array<Maybe<CustomerExternalAttribute>>>;
   /** Customer id for external system */
   externalId?: Maybe<Scalars['String']>;
-  id: Scalars['ID'];
+  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
   language?: Maybe<Language>;
-  memberId?: Maybe<Scalars['String']>;
+  billingAddress?: Maybe<CustomerAddress>;
+  deliveryAddresses?: Maybe<Array<Maybe<CustomerAddress>>>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
   orderHeaders?: Maybe<OrderHeaderResult>;
-  pid?: Maybe<Scalars['String']>;
+  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>;
-  subscribedToNewsletter?: Maybe<Scalars['Boolean']>;
+  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']>;
 };
 
 export type PrivateCustomerOrderHeadersArgs = {
@@ -1423,61 +1663,102 @@ 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. */
-  badges?: Maybe<Array<Maybe<ProductBadge>>>;
-  barcode?: Maybe<Scalars['String']>;
-  breadcrumbText?: Maybe<Scalars['String']>;
+  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>>>;
   /** 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. */
-  canonicalCategory?: Maybe<Category>;
+  relatedProducts?: Maybe<Array<Maybe<Product>>>;
   /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
-  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.
+  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.
    */
-  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.
+  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.
    */
-  configurations?: Maybe<Array<Maybe<ProductConfiguration>>>;
+  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.
+   */
+  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.
+   */
+  memberPrice?: Maybe<Price>;
   /** 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.NB: Carries a performance cost, as asking for
-   * this will result in a separate API call in the backend.
+   *                     If 'required' is true the Product should not be purchasable until the field is populated.
    */
   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>>>;
-  /** 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'];
+  /** 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>;
   /** 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'];
-  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.
+  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.
    */
-  mainHeader: Scalars['String'];
-  name: Scalars['String'];
+  configurationPrice?: Maybe<ProductConfigurationPrice>;
+  /** Quantity suffix e.g pcs, box, etc. */
+  quantitySuffix?: Maybe<Scalars['String']>;
+  isPreOrder?: Maybe<Scalars['Boolean']>;
+  preOrder?: Maybe<ProductPreOrder>;
+  isPackage?: Maybe<Scalars['Boolean']>;
   /** ## Description
    * NB: Carries a performance cost, as asking for this will result in a separate API call in the backend.
    * ## Error Codes
@@ -1489,53 +1770,43 @@ 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['Date']>;
-  /** 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>;
-  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>>>;
+  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>;
 };
 
 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>>;
@@ -1543,11 +1814,11 @@ export type ProductAutoCompleteResult = {
 
 export type ProductBadge = {
   __typename?: 'ProductBadge';
-  location?: Maybe<ProductBadgeLocation>;
   name?: Maybe<Scalars['String']>;
+  url?: Maybe<Scalars['Uri']>;
+  location?: Maybe<ProductBadgeLocation>;
   style?: Maybe<Scalars['String']>;
   text?: Maybe<Scalars['String']>;
-  url?: Maybe<Scalars['Uri']>;
 };
 
 export enum ProductBadgeLocation {
@@ -1589,8 +1860,8 @@ export type ProductConfigurationOption = {
 
 export type ProductConfigurationPrice = {
   __typename?: 'ProductConfigurationPrice';
-  previousPrice?: Maybe<Price>;
   price?: Maybe<Price>;
+  previousPrice?: Maybe<Price>;
 };
 
 /** Describes how the price is calculated on a configuration option.
@@ -1601,9 +1872,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>>>;
 };
 
@@ -1625,21 +1896,27 @@ 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']>;
-  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 {
@@ -1658,46 +1935,78 @@ 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';
-  filters?: Maybe<Array<Maybe<Filter>>>;
   result: Array<Maybe<Product>>;
+  filters?: Maybe<Array<Maybe<Filter>>>;
   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';
-  articleNumber: Scalars['String'];
-  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>>>;
+  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>;
   /** 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>;
+  /** 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. */
+  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 = {
@@ -1716,83 +2025,75 @@ export type ProductVariants = {
 
 export type Query = {
   __typename?: 'Query';
-  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>;
+  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>;
   /** 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>;
-  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 QueryCartArgs = {
-  id?: Maybe<Scalars['String']>;
-};
-
-export type QueryCategoriesArgs = {
-  root?: Maybe<Scalars['Int']>;
-  levels?: Maybe<Scalars['Int']>;
-  includeHidden?: Maybe<Scalars['Boolean']>;
+  /** 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>;
 };
 
-export type QueryCategoryArgs = {
+export type QueryStoreArgs = {
   id: Scalars['Int'];
 };
 
-export type QueryChannelArgs = {
-  id?: Maybe<Scalars['String']>;
-};
-
-export type QueryCustomerProductListArgs = {
-  id?: Maybe<Scalars['ID']>;
-  shareToken?: Maybe<Scalars['String']>;
+export type QueryStoresArgs = {
+  includeInactive?: Scalars['Boolean'];
 };
 
-export type QueryExternalCustomerLookupArgs = {
-  key?: Maybe<Scalars['String']>;
+export type QueryStartPageArgs = {
+  id?: Maybe<Scalars['Int']>;
 };
 
-export type QueryOrderArgs = {
-  id?: Maybe<Scalars['Int']>;
-  orderId?: Maybe<Scalars['ID']>;
+export type QuerySearchAutoCompleteArgs = {
+  term: Scalars['String'];
 };
 
-export type QueryPageArgs = {
-  id: Scalars['Int'];
+export type QuerySearchArgs = {
+  term: Scalars['String'];
 };
 
-export type QueryPersonLookupArgs = {
-  key: Scalars['String'];
+export type QueryRouteArgs = {
+  path: Scalars['String'];
 };
 
 export type QueryProductArgs = {
@@ -1807,24 +2108,53 @@ export type QueryProductsArgs = {
   barcodes?: Maybe<Array<Maybe<Scalars['String']>>>;
 };
 
-export type QueryRouteArgs = {
-  path: Scalars['String'];
+export type QueryPageArgs = {
+  id: Scalars['Int'];
 };
 
-export type QuerySearchArgs = {
-  term: Scalars['String'];
+export type QueryOrderArgs = {
+  id?: Maybe<Scalars['Int']>;
+  orderId?: Maybe<Scalars['ID']>;
 };
 
-export type QuerySearchAutoCompleteArgs = {
-  term: Scalars['String'];
+export type QueryCustomerProductListArgs = {
+  id?: Maybe<Scalars['ID']>;
+  shareToken?: Maybe<Scalars['String']>;
 };
 
-export type QueryStartPageArgs = {
-  id?: Maybe<Scalars['Int']>;
+export type QueryCustomerLookupArgs = {
+  phoneNumber?: Maybe<Scalars['String']>;
 };
 
-export type QueryStoreArgs = {
-  id: Scalars['Int'];
+export type QueryExternalCustomerLookupArgs = {
+  key?: Maybe<Scalars['String']>;
+};
+
+export type QueryPersonLookupArgs = {
+  key: Scalars['String'];
+};
+
+export type QueryContentArgs = {
+  ids?: Maybe<Array<Maybe<Scalars['String']>>>;
+  tags?: Maybe<Array<Maybe<Scalars['String']>>>;
+};
+
+export type QueryChannelArgs = {
+  id?: Maybe<Scalars['String']>;
+};
+
+export type QueryCategoriesArgs = {
+  root?: Maybe<Scalars['Int']>;
+  levels?: Maybe<Scalars['Int']>;
+  includeHidden?: Maybe<Scalars['Boolean']>;
+};
+
+export type QueryCategoryArgs = {
+  id: Scalars['ID'];
+};
+
+export type QueryCartArgs = {
+  id?: Maybe<Scalars['String']>;
 };
 
 export type RangeFilterInput = {
@@ -1837,21 +2167,21 @@ export type RecommendedProducts = {
   __typename?: 'RecommendedProducts';
   /** Customers who bought this product also bought these products. */
   bought?: 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>>>;
+  /** A shuffled top list of popular products. */
+  shuffledToplist?: Maybe<Array<Maybe<Product>>>;
 };
 
 export type RecommendedProductsBoughtArgs = {
   count?: Maybe<Scalars['Int']>;
 };
 
-export type RecommendedProductsShuffledToplistArgs = {
+export type RecommendedProductsViewedArgs = {
   count?: Maybe<Scalars['Int']>;
 };
 
-export type RecommendedProductsViewedArgs = {
+export type RecommendedProductsShuffledToplistArgs = {
   count?: Maybe<Scalars['Int']>;
 };
 
@@ -1878,12 +2208,10 @@ export type ResetPassword = {
 /** Represents a route to either a Category, a Product, a Page or the StartPage. */
 export type Route = {
   __typename?: '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>>>;
-  canonicalPath?: Maybe<Scalars['String']>;
   id: Scalars['String'];
+  path: Scalars['String'];
+  canonicalPath?: Maybe<Scalars['String']>;
+  slug: 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.
@@ -1895,16 +2223,22 @@ export type Route = {
    * categories a shop has, the more expensive this gets), route query in the backend.
    */
   parents?: Maybe<Array<Maybe<Route>>>;
-  path: Scalars['String'];
-  slug: 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>>>;
+  /** 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']>>>;
 };
 
 export type SearchAutoCompleteResult = {
   __typename?: 'SearchAutoCompleteResult';
   /** 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>;
+  /** NB: Carries a performance cost, as asking for this will result in a separate API call in the backend. */
+  categories?: Maybe<CategoryAutoCompleteResult>;
 };
 
 export type SearchAutoCompleteResultCategoriesArgs = {
@@ -1913,18 +2247,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 SearchResultCategoriesArgs = {
+export type SearchResultProductsArgs = {
   paging?: Maybe<PagingInput>;
+  filters?: Maybe<FilterInput>;
 };
 
-export type SearchResultProductsArgs = {
+export type SearchResultCategoriesArgs = {
   paging?: Maybe<PagingInput>;
-  filters?: Maybe<FilterInput>;
 };
 
 export type SelectedProductConfiguration = {
@@ -1995,6 +2329,11 @@ 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']>;
@@ -2007,7 +2346,9 @@ 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 = {
@@ -2044,52 +2385,65 @@ export enum SortDirection {
 
 export type StartPage = Document & {
   __typename?: 'StartPage';
-  breadcrumbText?: Maybe<Scalars['String']>;
-  content?: Maybe<Scalars['String']>;
-  /** 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>>>;
-  name: Scalars['String'];
-  /** The primary route of this StartPage. NB: Carries no additional performance cost. */
+  /** 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 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';
-  column?: Maybe<Scalars['Int']>;
   id: Scalars['Int'];
-  item: StartPageItemObjectGraphType;
   row?: Maybe<Scalars['Int']>;
+  column?: Maybe<Scalars['Int']>;
+  item: StartPageItemObject;
 };
 
-export type StartPageItemObjectGraphType = Product | CustomItem;
+export type StartPageItemObject = Product | CustomItem;
 
 export type StockStatus = {
   __typename?: 'StockStatus';
-  buyable: Scalars['Boolean'];
+  /** Globally unique id. */
   id: Scalars['ID'];
-  maxOrderQuantity?: Maybe<Scalars['Int']>;
-  stockDate?: Maybe<Scalars['Date']>;
-  stockNotificationEnabled?: Maybe<Scalars['Boolean']>;
+  /** 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']>;
+  maxOrderQuantity?: Maybe<Scalars['Int']>;
 };
 
 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']>;
-  city?: Maybe<Scalars['String']>;
-  contact?: Maybe<Scalars['String']>;
-  coordinates?: Maybe<Coordinates>;
   description?: Maybe<Scalars['String']>;
-  id: Scalars['Int'];
-  name?: Maybe<Scalars['String']>;
-  openHours?: Maybe<Scalars['String']>;
   other?: Maybe<Scalars['String']>;
-  region?: Maybe<Scalars['String']>;
+  openHours?: Maybe<Scalars['String']>;
+  contact?: Maybe<Scalars['String']>;
+  coordinates?: Maybe<Coordinates>;
+};
+
+export type StringValue = {
+  __typename?: 'StringValue';
+  value?: Maybe<Scalars['String']>;
 };
 
 /** Authorization token that is used for customer actions such as login, delete or update
@@ -2106,7 +2460,15 @@ 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 = {
@@ -2126,6 +2488,16 @@ 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'];
@@ -2162,21 +2534,20 @@ export type UpsellDiscountPercentage = {
 
 export type UpsellDiscountValue = {
   __typename?: 'UpsellDiscountValue';
-  valueExVat: Scalars['Decimal'];
   valueIncVat: Scalars['Decimal'];
+  valueExVat: Scalars['Decimal'];
   valueVat: Scalars['Decimal'];
 };
 
 export type UpsellItem = {
   __typename?: 'UpsellItem';
-  discount: UpsellDiscount;
-  minQuantity: Scalars['Int'];
   product?: Maybe<Product>;
+  minQuantity: Scalars['Int'];
+  discount: UpsellDiscount;
 };
 
 export type Warehouse = {
   __typename?: 'Warehouse';
-  /** 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']>;
+  location?: Maybe<Store>;
 };