@vendure/payments-plugin 1.9.5 → 2.0.0-beta.0

package/package/mollie/graphql/generated-shop-types.d.ts

@@ -1,17 +1,18 @@
-export declare type Maybe<T> = T | null;
-export declare type Exact<T extends {
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
     [key: string]: unknown;
 }> = {
     [K in keyof T]: T[K];
 };
-export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
     [SubKey in K]?: Maybe<T[SubKey]>;
 };
-export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
     [SubKey in K]: Maybe<T[SubKey]>;
 };
 /** All built-in and custom scalars, mapped to their actual values */
-export declare type Scalars = {
+export type Scalars = {
     ID: string;
     String: string;
     Boolean: boolean;
@@ -21,313 +22,318 @@ export declare type Scalars = {
     DateTime: any;
     /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
     JSON: any;
+    /** The `Money` scalar type represents monetary values and supports signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point). */
+    Money: number;
     /** The `Upload` scalar type represents a file upload. */
     Upload: any;
 };
-export declare type ActiveOrderResult = Order | NoActiveOrderError;
-export declare type AddPaymentToOrderResult = Order | OrderPaymentStateError | IneligiblePaymentMethodError | PaymentFailedError | PaymentDeclinedError | OrderStateTransitionError | NoActiveOrderError;
-export declare type Address = Node & {
+export type ActiveOrderResult = NoActiveOrderError | Order;
+export type AddPaymentToOrderResult = IneligiblePaymentMethodError | NoActiveOrderError | Order | OrderPaymentStateError | OrderStateTransitionError | PaymentDeclinedError | PaymentFailedError;
+export type Address = Node & {
     __typename?: 'Address';
-    id: Scalars['ID'];
+    city?: Maybe<Scalars['String']>;
+    company?: Maybe<Scalars['String']>;
+    country: Country;
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
+    defaultBillingAddress?: Maybe<Scalars['Boolean']>;
+    defaultShippingAddress?: Maybe<Scalars['Boolean']>;
     fullName?: Maybe<Scalars['String']>;
-    company?: Maybe<Scalars['String']>;
+    id: Scalars['ID'];
+    phoneNumber?: Maybe<Scalars['String']>;
+    postalCode?: Maybe<Scalars['String']>;
+    province?: Maybe<Scalars['String']>;
     streetLine1: Scalars['String'];
     streetLine2?: Maybe<Scalars['String']>;
-    city?: Maybe<Scalars['String']>;
-    province?: Maybe<Scalars['String']>;
-    postalCode?: Maybe<Scalars['String']>;
-    country: Country;
-    phoneNumber?: Maybe<Scalars['String']>;
-    defaultShippingAddress?: Maybe<Scalars['Boolean']>;
-    defaultBillingAddress?: Maybe<Scalars['Boolean']>;
-    customFields?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type Adjustment = {
+export type Adjustment = {
     __typename?: 'Adjustment';
     adjustmentSource: Scalars['String'];
-    type: AdjustmentType;
+    amount: Scalars['Money'];
+    data?: Maybe<Scalars['JSON']>;
     description: Scalars['String'];
-    amount: Scalars['Int'];
+    type: AdjustmentType;
 };
 export declare enum AdjustmentType {
-    PROMOTION = "PROMOTION",
     DISTRIBUTED_ORDER_PROMOTION = "DISTRIBUTED_ORDER_PROMOTION",
-    OTHER = "OTHER"
+    OTHER = "OTHER",
+    PROMOTION = "PROMOTION"
 }
 /** Returned when attempting to set the Customer for an Order when already logged in. */
-export declare type AlreadyLoggedInError = ErrorResult & {
+export type AlreadyLoggedInError = ErrorResult & {
     __typename?: 'AlreadyLoggedInError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
-export declare type ApplyCouponCodeResult = Order | CouponCodeExpiredError | CouponCodeInvalidError | CouponCodeLimitError;
-export declare type Asset = Node & {
+export type ApplyCouponCodeResult = CouponCodeExpiredError | CouponCodeInvalidError | CouponCodeLimitError | Order;
+export type Asset = Node & {
     __typename?: 'Asset';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    name: Scalars['String'];
-    type: AssetType;
+    customFields?: Maybe<Scalars['JSON']>;
     fileSize: Scalars['Int'];
-    mimeType: Scalars['String'];
-    width: Scalars['Int'];
+    focalPoint?: Maybe<Coordinate>;
     height: Scalars['Int'];
-    source: Scalars['String'];
+    id: Scalars['ID'];
+    mimeType: Scalars['String'];
+    name: Scalars['String'];
     preview: Scalars['String'];
-    focalPoint?: Maybe<Coordinate>;
-    customFields?: Maybe<Scalars['JSON']>;
+    source: Scalars['String'];
+    tags: Array<Tag>;
+    type: AssetType;
+    updatedAt: Scalars['DateTime'];
+    width: Scalars['Int'];
 };
-export declare type AssetList = PaginatedList & {
+export type AssetList = PaginatedList & {
     __typename?: 'AssetList';
     items: Array<Asset>;
     totalItems: Scalars['Int'];
 };
 export declare enum AssetType {
+    BINARY = "BINARY",
     IMAGE = "IMAGE",
-    VIDEO = "VIDEO",
-    BINARY = "BINARY"
+    VIDEO = "VIDEO"
 }
-export declare type AuthenticationInput = {
-    native?: Maybe<NativeAuthInput>;
+export type AuthenticationInput = {
+    native?: InputMaybe<NativeAuthInput>;
 };
-export declare type AuthenticationMethod = Node & {
+export type AuthenticationMethod = Node & {
     __typename?: 'AuthenticationMethod';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    id: Scalars['ID'];
     strategy: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type AuthenticationResult = CurrentUser | InvalidCredentialsError | NotVerifiedError;
-export declare type BooleanCustomFieldConfig = CustomField & {
+export type AuthenticationResult = CurrentUser | InvalidCredentialsError | NotVerifiedError;
+export type BooleanCustomFieldConfig = CustomField & {
     __typename?: 'BooleanCustomFieldConfig';
-    name: Scalars['String'];
-    type: Scalars['String'];
-    list: Scalars['Boolean'];
-    label?: Maybe<Array<LocalizedString>>;
     description?: Maybe<Array<LocalizedString>>;
-    readonly?: Maybe<Scalars['Boolean']>;
     internal?: Maybe<Scalars['Boolean']>;
+    label?: Maybe<Array<LocalizedString>>;
+    list: Scalars['Boolean'];
+    name: Scalars['String'];
     nullable?: Maybe<Scalars['Boolean']>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    type: Scalars['String'];
     ui?: Maybe<Scalars['JSON']>;
 };
 /** Operators for filtering on a list of Boolean fields */
-export declare type BooleanListOperators = {
+export type BooleanListOperators = {
     inList: Scalars['Boolean'];
 };
 /** Operators for filtering on a Boolean field */
-export declare type BooleanOperators = {
-    eq?: Maybe<Scalars['Boolean']>;
-    isNull?: Maybe<Scalars['Boolean']>;
+export type BooleanOperators = {
+    eq?: InputMaybe<Scalars['Boolean']>;
+    isNull?: InputMaybe<Scalars['Boolean']>;
 };
-export declare type Channel = Node & {
+export type Channel = Node & {
     __typename?: 'Channel';
-    id: Scalars['ID'];
-    createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
     code: Scalars['String'];
-    token: Scalars['String'];
-    defaultTaxZone?: Maybe<Zone>;
-    defaultShippingZone?: Maybe<Zone>;
-    defaultLanguageCode: LanguageCode;
+    createdAt: Scalars['DateTime'];
     currencyCode: CurrencyCode;
-    pricesIncludeTax: Scalars['Boolean'];
     customFields?: Maybe<Scalars['JSON']>;
-};
-export declare type Collection = Node & {
-    __typename?: 'Collection';
+    defaultLanguageCode: LanguageCode;
+    defaultShippingZone?: Maybe<Zone>;
+    defaultTaxZone?: Maybe<Zone>;
     id: Scalars['ID'];
-    createdAt: Scalars['DateTime'];
+    pricesIncludeTax: Scalars['Boolean'];
+    seller?: Maybe<Seller>;
+    token: Scalars['String'];
     updatedAt: Scalars['DateTime'];
-    languageCode?: Maybe<LanguageCode>;
-    name: Scalars['String'];
-    slug: Scalars['String'];
+};
+export type Collection = Node & {
+    __typename?: 'Collection';
+    assets: Array<Asset>;
     breadcrumbs: Array<CollectionBreadcrumb>;
-    position: Scalars['Int'];
+    children?: Maybe<Array<Collection>>;
+    createdAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
     description: Scalars['String'];
     featuredAsset?: Maybe<Asset>;
-    assets: Array<Asset>;
-    parent?: Maybe<Collection>;
-    children?: Maybe<Array<Collection>>;
     filters: Array<ConfigurableOperation>;
-    translations: Array<CollectionTranslation>;
+    id: Scalars['ID'];
+    languageCode?: Maybe<LanguageCode>;
+    name: Scalars['String'];
+    parent?: Maybe<Collection>;
+    position: Scalars['Int'];
     productVariants: ProductVariantList;
-    customFields?: Maybe<Scalars['JSON']>;
+    slug: Scalars['String'];
+    translations: Array<CollectionTranslation>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type CollectionProductVariantsArgs = {
-    options?: Maybe<ProductVariantListOptions>;
+export type CollectionProductVariantsArgs = {
+    options?: InputMaybe<ProductVariantListOptions>;
 };
-export declare type CollectionBreadcrumb = {
+export type CollectionBreadcrumb = {
     __typename?: 'CollectionBreadcrumb';
     id: Scalars['ID'];
     name: Scalars['String'];
     slug: Scalars['String'];
 };
-export declare type CollectionFilterParameter = {
-    id?: Maybe<IdOperators>;
-    createdAt?: Maybe<DateOperators>;
-    updatedAt?: Maybe<DateOperators>;
-    languageCode?: Maybe<StringOperators>;
-    name?: Maybe<StringOperators>;
-    slug?: Maybe<StringOperators>;
-    position?: Maybe<NumberOperators>;
-    description?: Maybe<StringOperators>;
-};
-export declare type CollectionList = PaginatedList & {
+export type CollectionFilterParameter = {
+    createdAt?: InputMaybe<DateOperators>;
+    description?: InputMaybe<StringOperators>;
+    id?: InputMaybe<IdOperators>;
+    languageCode?: InputMaybe<StringOperators>;
+    name?: InputMaybe<StringOperators>;
+    position?: InputMaybe<NumberOperators>;
+    slug?: InputMaybe<StringOperators>;
+    updatedAt?: InputMaybe<DateOperators>;
+};
+export type CollectionList = PaginatedList & {
     __typename?: 'CollectionList';
     items: Array<Collection>;
     totalItems: Scalars['Int'];
 };
-export declare type CollectionListOptions = {
-    /** Skips the first n results, for use in pagination */
-    skip?: Maybe<Scalars['Int']>;
-    /** Takes n results, for use in pagination */
-    take?: Maybe<Scalars['Int']>;
-    /** Specifies which properties to sort the results by */
-    sort?: Maybe<CollectionSortParameter>;
+export type CollectionListOptions = {
     /** Allows the results to be filtered */
-    filter?: Maybe<CollectionFilterParameter>;
+    filter?: InputMaybe<CollectionFilterParameter>;
     /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
-    filterOperator?: Maybe<LogicalOperator>;
+    filterOperator?: InputMaybe<LogicalOperator>;
+    /** Skips the first n results, for use in pagination */
+    skip?: InputMaybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: InputMaybe<CollectionSortParameter>;
+    /** Takes n results, for use in pagination */
+    take?: InputMaybe<Scalars['Int']>;
 };
 /**
  * Which Collections are present in the products returned
  * by the search, and in what quantity.
  */
-export declare type CollectionResult = {
+export type CollectionResult = {
     __typename?: 'CollectionResult';
     collection: Collection;
     count: Scalars['Int'];
 };
-export declare type CollectionSortParameter = {
-    id?: Maybe<SortOrder>;
-    createdAt?: Maybe<SortOrder>;
-    updatedAt?: Maybe<SortOrder>;
-    name?: Maybe<SortOrder>;
-    slug?: Maybe<SortOrder>;
-    position?: Maybe<SortOrder>;
-    description?: Maybe<SortOrder>;
+export type CollectionSortParameter = {
+    createdAt?: InputMaybe<SortOrder>;
+    description?: InputMaybe<SortOrder>;
+    id?: InputMaybe<SortOrder>;
+    name?: InputMaybe<SortOrder>;
+    position?: InputMaybe<SortOrder>;
+    slug?: InputMaybe<SortOrder>;
+    updatedAt?: InputMaybe<SortOrder>;
 };
-export declare type CollectionTranslation = {
+export type CollectionTranslation = {
     __typename?: 'CollectionTranslation';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    description: Scalars['String'];
+    id: Scalars['ID'];
     languageCode: LanguageCode;
     name: Scalars['String'];
     slug: Scalars['String'];
-    description: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type ConfigArg = {
+export type ConfigArg = {
     __typename?: 'ConfigArg';
     name: Scalars['String'];
     value: Scalars['String'];
 };
-export declare type ConfigArgDefinition = {
+export type ConfigArgDefinition = {
     __typename?: 'ConfigArgDefinition';
-    name: Scalars['String'];
-    type: Scalars['String'];
-    list: Scalars['Boolean'];
-    required: Scalars['Boolean'];
     defaultValue?: Maybe<Scalars['JSON']>;
-    label?: Maybe<Scalars['String']>;
     description?: Maybe<Scalars['String']>;
+    label?: Maybe<Scalars['String']>;
+    list: Scalars['Boolean'];
+    name: Scalars['String'];
+    required: Scalars['Boolean'];
+    type: Scalars['String'];
     ui?: Maybe<Scalars['JSON']>;
 };
-export declare type ConfigArgInput = {
+export type ConfigArgInput = {
     name: Scalars['String'];
     /** A JSON stringified representation of the actual value */
     value: Scalars['String'];
 };
-export declare type ConfigurableOperation = {
+export type ConfigurableOperation = {
     __typename?: 'ConfigurableOperation';
-    code: Scalars['String'];
     args: Array<ConfigArg>;
+    code: Scalars['String'];
 };
-export declare type ConfigurableOperationDefinition = {
+export type ConfigurableOperationDefinition = {
     __typename?: 'ConfigurableOperationDefinition';
-    code: Scalars['String'];
     args: Array<ConfigArgDefinition>;
+    code: Scalars['String'];
     description: Scalars['String'];
 };
-export declare type ConfigurableOperationInput = {
-    code: Scalars['String'];
+export type ConfigurableOperationInput = {
     arguments: Array<ConfigArgInput>;
+    code: Scalars['String'];
 };
-export declare type Coordinate = {
+export type Coordinate = {
     __typename?: 'Coordinate';
     x: Scalars['Float'];
     y: Scalars['Float'];
 };
-export declare type Country = Node & {
+export type Country = Node & {
     __typename?: 'Country';
-    id: Scalars['ID'];
+    code: Scalars['String'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
+    enabled: Scalars['Boolean'];
+    id: Scalars['ID'];
     languageCode: LanguageCode;
-    code: Scalars['String'];
     name: Scalars['String'];
-    enabled: Scalars['Boolean'];
     translations: Array<CountryTranslation>;
-    customFields?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type CountryList = PaginatedList & {
+export type CountryList = PaginatedList & {
     __typename?: 'CountryList';
     items: Array<Country>;
     totalItems: Scalars['Int'];
 };
-export declare type CountryTranslation = {
+export type CountryTranslation = {
     __typename?: 'CountryTranslation';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    id: Scalars['ID'];
     languageCode: LanguageCode;
     name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
 /** Returned if the provided coupon code is invalid */
-export declare type CouponCodeExpiredError = ErrorResult & {
+export type CouponCodeExpiredError = ErrorResult & {
     __typename?: 'CouponCodeExpiredError';
+    couponCode: Scalars['String'];
     errorCode: ErrorCode;
     message: Scalars['String'];
-    couponCode: Scalars['String'];
 };
 /** Returned if the provided coupon code is invalid */
-export declare type CouponCodeInvalidError = ErrorResult & {
+export type CouponCodeInvalidError = ErrorResult & {
     __typename?: 'CouponCodeInvalidError';
+    couponCode: Scalars['String'];
     errorCode: ErrorCode;
     message: Scalars['String'];
-    couponCode: Scalars['String'];
 };
 /** Returned if the provided coupon code is invalid */
-export declare type CouponCodeLimitError = ErrorResult & {
+export type CouponCodeLimitError = ErrorResult & {
     __typename?: 'CouponCodeLimitError';
-    errorCode: ErrorCode;
-    message: Scalars['String'];
     couponCode: Scalars['String'];
+    errorCode: ErrorCode;
     limit: Scalars['Int'];
+    message: Scalars['String'];
 };
-export declare type CreateAddressInput = {
-    fullName?: Maybe<Scalars['String']>;
-    company?: Maybe<Scalars['String']>;
-    streetLine1: Scalars['String'];
-    streetLine2?: Maybe<Scalars['String']>;
-    city?: Maybe<Scalars['String']>;
-    province?: Maybe<Scalars['String']>;
-    postalCode?: Maybe<Scalars['String']>;
+export type CreateAddressInput = {
+    city?: InputMaybe<Scalars['String']>;
+    company?: InputMaybe<Scalars['String']>;
     countryCode: Scalars['String'];
-    phoneNumber?: Maybe<Scalars['String']>;
-    defaultShippingAddress?: Maybe<Scalars['Boolean']>;
-    defaultBillingAddress?: Maybe<Scalars['Boolean']>;
-    customFields?: Maybe<Scalars['JSON']>;
+    customFields?: InputMaybe<Scalars['JSON']>;
+    defaultBillingAddress?: InputMaybe<Scalars['Boolean']>;
+    defaultShippingAddress?: InputMaybe<Scalars['Boolean']>;
+    fullName?: InputMaybe<Scalars['String']>;
+    phoneNumber?: InputMaybe<Scalars['String']>;
+    postalCode?: InputMaybe<Scalars['String']>;
+    province?: InputMaybe<Scalars['String']>;
+    streetLine1: Scalars['String'];
+    streetLine2?: InputMaybe<Scalars['String']>;
 };
-export declare type CreateCustomerInput = {
-    title?: Maybe<Scalars['String']>;
+export type CreateCustomerInput = {
+    customFields?: InputMaybe<Scalars['JSON']>;
+    emailAddress: Scalars['String'];
     firstName: Scalars['String'];
     lastName: Scalars['String'];
-    phoneNumber?: Maybe<Scalars['String']>;
-    emailAddress: Scalars['String'];
-    customFields?: Maybe<Scalars['JSON']>;
+    phoneNumber?: InputMaybe<Scalars['String']>;
+    title?: InputMaybe<Scalars['String']>;
 };
 /**
  * @description
@@ -651,137 +657,137 @@ export declare enum CurrencyCode {
     /** Zimbabwean dollar */
     ZWL = "ZWL"
 }
-export declare type CurrentUser = {
+export type CurrentUser = {
     __typename?: 'CurrentUser';
+    channels: Array<CurrentUserChannel>;
     id: Scalars['ID'];
     identifier: Scalars['String'];
-    channels: Array<CurrentUserChannel>;
 };
-export declare type CurrentUserChannel = {
+export type CurrentUserChannel = {
     __typename?: 'CurrentUserChannel';
-    id: Scalars['ID'];
-    token: Scalars['String'];
     code: Scalars['String'];
+    id: Scalars['ID'];
     permissions: Array<Permission>;
+    token: Scalars['String'];
 };
-export declare type CustomField = {
-    name: Scalars['String'];
-    type: Scalars['String'];
-    list: Scalars['Boolean'];
-    label?: Maybe<Array<LocalizedString>>;
+export type CustomField = {
     description?: Maybe<Array<LocalizedString>>;
-    readonly?: Maybe<Scalars['Boolean']>;
     internal?: Maybe<Scalars['Boolean']>;
+    label?: Maybe<Array<LocalizedString>>;
+    list: Scalars['Boolean'];
+    name: Scalars['String'];
     nullable?: Maybe<Scalars['Boolean']>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    type: Scalars['String'];
     ui?: Maybe<Scalars['JSON']>;
 };
-export declare type CustomFieldConfig = StringCustomFieldConfig | LocaleStringCustomFieldConfig | IntCustomFieldConfig | FloatCustomFieldConfig | BooleanCustomFieldConfig | DateTimeCustomFieldConfig | RelationCustomFieldConfig | TextCustomFieldConfig;
-export declare type Customer = Node & {
+export type CustomFieldConfig = BooleanCustomFieldConfig | DateTimeCustomFieldConfig | FloatCustomFieldConfig | IntCustomFieldConfig | LocaleStringCustomFieldConfig | LocaleTextCustomFieldConfig | RelationCustomFieldConfig | StringCustomFieldConfig | TextCustomFieldConfig;
+export type Customer = Node & {
     __typename?: 'Customer';
-    id: Scalars['ID'];
+    addresses?: Maybe<Array<Address>>;
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    title?: Maybe<Scalars['String']>;
+    customFields?: Maybe<Scalars['JSON']>;
+    emailAddress: Scalars['String'];
     firstName: Scalars['String'];
+    id: Scalars['ID'];
     lastName: Scalars['String'];
-    phoneNumber?: Maybe<Scalars['String']>;
-    emailAddress: Scalars['String'];
-    addresses?: Maybe<Array<Address>>;
     orders: OrderList;
+    phoneNumber?: Maybe<Scalars['String']>;
+    title?: Maybe<Scalars['String']>;
+    updatedAt: Scalars['DateTime'];
     user?: Maybe<User>;
-    customFields?: Maybe<Scalars['JSON']>;
 };
-export declare type CustomerOrdersArgs = {
-    options?: Maybe<OrderListOptions>;
+export type CustomerOrdersArgs = {
+    options?: InputMaybe<OrderListOptions>;
 };
-export declare type CustomerFilterParameter = {
-    id?: Maybe<IdOperators>;
-    createdAt?: Maybe<DateOperators>;
-    updatedAt?: Maybe<DateOperators>;
-    title?: Maybe<StringOperators>;
-    firstName?: Maybe<StringOperators>;
-    lastName?: Maybe<StringOperators>;
-    phoneNumber?: Maybe<StringOperators>;
-    emailAddress?: Maybe<StringOperators>;
+export type CustomerFilterParameter = {
+    createdAt?: InputMaybe<DateOperators>;
+    emailAddress?: InputMaybe<StringOperators>;
+    firstName?: InputMaybe<StringOperators>;
+    id?: InputMaybe<IdOperators>;
+    lastName?: InputMaybe<StringOperators>;
+    phoneNumber?: InputMaybe<StringOperators>;
+    title?: InputMaybe<StringOperators>;
+    updatedAt?: InputMaybe<DateOperators>;
 };
-export declare type CustomerGroup = Node & {
+export type CustomerGroup = Node & {
     __typename?: 'CustomerGroup';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    name: Scalars['String'];
-    customers: CustomerList;
     customFields?: Maybe<Scalars['JSON']>;
+    customers: CustomerList;
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type CustomerGroupCustomersArgs = {
-    options?: Maybe<CustomerListOptions>;
+export type CustomerGroupCustomersArgs = {
+    options?: InputMaybe<CustomerListOptions>;
 };
-export declare type CustomerList = PaginatedList & {
+export type CustomerList = PaginatedList & {
     __typename?: 'CustomerList';
     items: Array<Customer>;
     totalItems: Scalars['Int'];
 };
-export declare type CustomerListOptions = {
-    /** Skips the first n results, for use in pagination */
-    skip?: Maybe<Scalars['Int']>;
-    /** Takes n results, for use in pagination */
-    take?: Maybe<Scalars['Int']>;
-    /** Specifies which properties to sort the results by */
-    sort?: Maybe<CustomerSortParameter>;
+export type CustomerListOptions = {
     /** Allows the results to be filtered */
-    filter?: Maybe<CustomerFilterParameter>;
+    filter?: InputMaybe<CustomerFilterParameter>;
     /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
-    filterOperator?: Maybe<LogicalOperator>;
-};
-export declare type CustomerSortParameter = {
-    id?: Maybe<SortOrder>;
-    createdAt?: Maybe<SortOrder>;
-    updatedAt?: Maybe<SortOrder>;
-    title?: Maybe<SortOrder>;
-    firstName?: Maybe<SortOrder>;
-    lastName?: Maybe<SortOrder>;
-    phoneNumber?: Maybe<SortOrder>;
-    emailAddress?: Maybe<SortOrder>;
+    filterOperator?: InputMaybe<LogicalOperator>;
+    /** Skips the first n results, for use in pagination */
+    skip?: InputMaybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: InputMaybe<CustomerSortParameter>;
+    /** Takes n results, for use in pagination */
+    take?: InputMaybe<Scalars['Int']>;
+};
+export type CustomerSortParameter = {
+    createdAt?: InputMaybe<SortOrder>;
+    emailAddress?: InputMaybe<SortOrder>;
+    firstName?: InputMaybe<SortOrder>;
+    id?: InputMaybe<SortOrder>;
+    lastName?: InputMaybe<SortOrder>;
+    phoneNumber?: InputMaybe<SortOrder>;
+    title?: InputMaybe<SortOrder>;
+    updatedAt?: InputMaybe<SortOrder>;
 };
 /** Operators for filtering on a list of Date fields */
-export declare type DateListOperators = {
+export type DateListOperators = {
     inList: Scalars['DateTime'];
 };
 /** Operators for filtering on a DateTime field */
-export declare type DateOperators = {
-    eq?: Maybe<Scalars['DateTime']>;
-    before?: Maybe<Scalars['DateTime']>;
-    after?: Maybe<Scalars['DateTime']>;
-    between?: Maybe<DateRange>;
-    isNull?: Maybe<Scalars['Boolean']>;
-};
-export declare type DateRange = {
-    start: Scalars['DateTime'];
+export type DateOperators = {
+    after?: InputMaybe<Scalars['DateTime']>;
+    before?: InputMaybe<Scalars['DateTime']>;
+    between?: InputMaybe<DateRange>;
+    eq?: InputMaybe<Scalars['DateTime']>;
+    isNull?: InputMaybe<Scalars['Boolean']>;
+};
+export type DateRange = {
     end: Scalars['DateTime'];
+    start: Scalars['DateTime'];
 };
 /**
  * Expects the same validation formats as the `<input type="datetime-local">` HTML element.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/datetime-local#Additional_attributes
  */
-export declare type DateTimeCustomFieldConfig = CustomField & {
+export type DateTimeCustomFieldConfig = CustomField & {
     __typename?: 'DateTimeCustomFieldConfig';
-    name: Scalars['String'];
-    type: Scalars['String'];
-    list: Scalars['Boolean'];
-    label?: Maybe<Array<LocalizedString>>;
     description?: Maybe<Array<LocalizedString>>;
-    readonly?: Maybe<Scalars['Boolean']>;
     internal?: Maybe<Scalars['Boolean']>;
-    nullable?: Maybe<Scalars['Boolean']>;
-    min?: Maybe<Scalars['String']>;
+    label?: Maybe<Array<LocalizedString>>;
+    list: Scalars['Boolean'];
     max?: Maybe<Scalars['String']>;
+    min?: Maybe<Scalars['String']>;
+    name: Scalars['String'];
+    nullable?: Maybe<Scalars['Boolean']>;
+    readonly?: Maybe<Scalars['Boolean']>;
     step?: Maybe<Scalars['Int']>;
+    type: Scalars['String'];
     ui?: Maybe<Scalars['JSON']>;
 };
-export declare type DeletionResponse = {
+export type DeletionResponse = {
     __typename?: 'DeletionResponse';
-    result: DeletionResult;
     message?: Maybe<Scalars['String']>;
+    result: DeletionResult;
 };
 export declare enum DeletionResult {
     /** The entity was successfully deleted */
@@ -789,118 +795,119 @@ export declare enum DeletionResult {
     /** Deletion did not take place, reason given in message */
     NOT_DELETED = "NOT_DELETED"
 }
-export declare type Discount = {
+export type Discount = {
     __typename?: 'Discount';
     adjustmentSource: Scalars['String'];
-    type: AdjustmentType;
+    amount: Scalars['Money'];
+    amountWithTax: Scalars['Money'];
     description: Scalars['String'];
-    amount: Scalars['Int'];
-    amountWithTax: Scalars['Int'];
+    type: AdjustmentType;
 };
 /** Returned when attempting to create a Customer with an email address already registered to an existing User. */
-export declare type EmailAddressConflictError = ErrorResult & {
+export type EmailAddressConflictError = ErrorResult & {
     __typename?: 'EmailAddressConflictError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
 export declare enum ErrorCode {
-    UNKNOWN_ERROR = "UNKNOWN_ERROR",
-    NATIVE_AUTH_STRATEGY_ERROR = "NATIVE_AUTH_STRATEGY_ERROR",
-    INVALID_CREDENTIALS_ERROR = "INVALID_CREDENTIALS_ERROR",
-    ORDER_STATE_TRANSITION_ERROR = "ORDER_STATE_TRANSITION_ERROR",
-    EMAIL_ADDRESS_CONFLICT_ERROR = "EMAIL_ADDRESS_CONFLICT_ERROR",
-    ORDER_LIMIT_ERROR = "ORDER_LIMIT_ERROR",
-    NEGATIVE_QUANTITY_ERROR = "NEGATIVE_QUANTITY_ERROR",
-    INSUFFICIENT_STOCK_ERROR = "INSUFFICIENT_STOCK_ERROR",
-    COUPON_CODE_INVALID_ERROR = "COUPON_CODE_INVALID_ERROR",
+    ALREADY_LOGGED_IN_ERROR = "ALREADY_LOGGED_IN_ERROR",
     COUPON_CODE_EXPIRED_ERROR = "COUPON_CODE_EXPIRED_ERROR",
+    COUPON_CODE_INVALID_ERROR = "COUPON_CODE_INVALID_ERROR",
     COUPON_CODE_LIMIT_ERROR = "COUPON_CODE_LIMIT_ERROR",
-    ORDER_MODIFICATION_ERROR = "ORDER_MODIFICATION_ERROR",
+    EMAIL_ADDRESS_CONFLICT_ERROR = "EMAIL_ADDRESS_CONFLICT_ERROR",
+    GUEST_CHECKOUT_ERROR = "GUEST_CHECKOUT_ERROR",
+    IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR = "IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR",
+    IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR = "IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR",
+    INELIGIBLE_PAYMENT_METHOD_ERROR = "INELIGIBLE_PAYMENT_METHOD_ERROR",
     INELIGIBLE_SHIPPING_METHOD_ERROR = "INELIGIBLE_SHIPPING_METHOD_ERROR",
+    INSUFFICIENT_STOCK_ERROR = "INSUFFICIENT_STOCK_ERROR",
+    INVALID_CREDENTIALS_ERROR = "INVALID_CREDENTIALS_ERROR",
+    MISSING_PASSWORD_ERROR = "MISSING_PASSWORD_ERROR",
+    NATIVE_AUTH_STRATEGY_ERROR = "NATIVE_AUTH_STRATEGY_ERROR",
+    NEGATIVE_QUANTITY_ERROR = "NEGATIVE_QUANTITY_ERROR",
+    NOT_VERIFIED_ERROR = "NOT_VERIFIED_ERROR",
     NO_ACTIVE_ORDER_ERROR = "NO_ACTIVE_ORDER_ERROR",
+    ORDER_LIMIT_ERROR = "ORDER_LIMIT_ERROR",
+    ORDER_MODIFICATION_ERROR = "ORDER_MODIFICATION_ERROR",
     ORDER_PAYMENT_STATE_ERROR = "ORDER_PAYMENT_STATE_ERROR",
-    INELIGIBLE_PAYMENT_METHOD_ERROR = "INELIGIBLE_PAYMENT_METHOD_ERROR",
-    PAYMENT_FAILED_ERROR = "PAYMENT_FAILED_ERROR",
-    PAYMENT_DECLINED_ERROR = "PAYMENT_DECLINED_ERROR",
-    ALREADY_LOGGED_IN_ERROR = "ALREADY_LOGGED_IN_ERROR",
-    MISSING_PASSWORD_ERROR = "MISSING_PASSWORD_ERROR",
-    PASSWORD_VALIDATION_ERROR = "PASSWORD_VALIDATION_ERROR",
+    ORDER_STATE_TRANSITION_ERROR = "ORDER_STATE_TRANSITION_ERROR",
     PASSWORD_ALREADY_SET_ERROR = "PASSWORD_ALREADY_SET_ERROR",
-    VERIFICATION_TOKEN_INVALID_ERROR = "VERIFICATION_TOKEN_INVALID_ERROR",
-    VERIFICATION_TOKEN_EXPIRED_ERROR = "VERIFICATION_TOKEN_EXPIRED_ERROR",
-    IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR = "IDENTIFIER_CHANGE_TOKEN_INVALID_ERROR",
-    IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR = "IDENTIFIER_CHANGE_TOKEN_EXPIRED_ERROR",
-    PASSWORD_RESET_TOKEN_INVALID_ERROR = "PASSWORD_RESET_TOKEN_INVALID_ERROR",
     PASSWORD_RESET_TOKEN_EXPIRED_ERROR = "PASSWORD_RESET_TOKEN_EXPIRED_ERROR",
-    NOT_VERIFIED_ERROR = "NOT_VERIFIED_ERROR"
+    PASSWORD_RESET_TOKEN_INVALID_ERROR = "PASSWORD_RESET_TOKEN_INVALID_ERROR",
+    PASSWORD_VALIDATION_ERROR = "PASSWORD_VALIDATION_ERROR",
+    PAYMENT_DECLINED_ERROR = "PAYMENT_DECLINED_ERROR",
+    PAYMENT_FAILED_ERROR = "PAYMENT_FAILED_ERROR",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR",
+    VERIFICATION_TOKEN_EXPIRED_ERROR = "VERIFICATION_TOKEN_EXPIRED_ERROR",
+    VERIFICATION_TOKEN_INVALID_ERROR = "VERIFICATION_TOKEN_INVALID_ERROR"
 }
-export declare type ErrorResult = {
+export type ErrorResult = {
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
-export declare type Facet = Node & {
+export type Facet = Node & {
     __typename?: 'Facet';
-    id: Scalars['ID'];
+    code: Scalars['String'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
+    id: Scalars['ID'];
     languageCode: LanguageCode;
     name: Scalars['String'];
-    code: Scalars['String'];
-    values: Array<FacetValue>;
     translations: Array<FacetTranslation>;
-    customFields?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
+    values: Array<FacetValue>;
 };
-export declare type FacetFilterParameter = {
-    id?: Maybe<IdOperators>;
-    createdAt?: Maybe<DateOperators>;
-    updatedAt?: Maybe<DateOperators>;
-    languageCode?: Maybe<StringOperators>;
-    name?: Maybe<StringOperators>;
-    code?: Maybe<StringOperators>;
+export type FacetFilterParameter = {
+    code?: InputMaybe<StringOperators>;
+    createdAt?: InputMaybe<DateOperators>;
+    id?: InputMaybe<IdOperators>;
+    languageCode?: InputMaybe<StringOperators>;
+    name?: InputMaybe<StringOperators>;
+    updatedAt?: InputMaybe<DateOperators>;
 };
-export declare type FacetList = PaginatedList & {
+export type FacetList = PaginatedList & {
     __typename?: 'FacetList';
     items: Array<Facet>;
     totalItems: Scalars['Int'];
 };
-export declare type FacetListOptions = {
-    /** Skips the first n results, for use in pagination */
-    skip?: Maybe<Scalars['Int']>;
-    /** Takes n results, for use in pagination */
-    take?: Maybe<Scalars['Int']>;
-    /** Specifies which properties to sort the results by */
-    sort?: Maybe<FacetSortParameter>;
+export type FacetListOptions = {
     /** Allows the results to be filtered */
-    filter?: Maybe<FacetFilterParameter>;
+    filter?: InputMaybe<FacetFilterParameter>;
     /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
-    filterOperator?: Maybe<LogicalOperator>;
+    filterOperator?: InputMaybe<LogicalOperator>;
+    /** Skips the first n results, for use in pagination */
+    skip?: InputMaybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: InputMaybe<FacetSortParameter>;
+    /** Takes n results, for use in pagination */
+    take?: InputMaybe<Scalars['Int']>;
 };
-export declare type FacetSortParameter = {
-    id?: Maybe<SortOrder>;
-    createdAt?: Maybe<SortOrder>;
-    updatedAt?: Maybe<SortOrder>;
-    name?: Maybe<SortOrder>;
-    code?: Maybe<SortOrder>;
+export type FacetSortParameter = {
+    code?: InputMaybe<SortOrder>;
+    createdAt?: InputMaybe<SortOrder>;
+    id?: InputMaybe<SortOrder>;
+    name?: InputMaybe<SortOrder>;
+    updatedAt?: InputMaybe<SortOrder>;
 };
-export declare type FacetTranslation = {
+export type FacetTranslation = {
     __typename?: 'FacetTranslation';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    id: Scalars['ID'];
     languageCode: LanguageCode;
     name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type FacetValue = Node & {
+export type FacetValue = Node & {
     __typename?: 'FacetValue';
-    id: Scalars['ID'];
+    code: Scalars['String'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    languageCode: LanguageCode;
+    customFields?: Maybe<Scalars['JSON']>;
     facet: Facet;
+    id: Scalars['ID'];
+    languageCode: LanguageCode;
     name: Scalars['String'];
-    code: Scalars['String'];
     translations: Array<FacetValueTranslation>;
-    customFields?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
 };
 /**
  * Used to construct boolean expressions for filtering search results
@@ -910,143 +917,154 @@ export declare type FacetValue = Node & {
  * * ID=1 AND ID=2: `{ facetValueFilters: [{ and: 1 }, { and: 2 }] }`
  * * ID=1 AND (ID=2 OR ID=3): `{ facetValueFilters: [{ and: 1 }, { or: [2,3] }] }`
  */
-export declare type FacetValueFilterInput = {
-    and?: Maybe<Scalars['ID']>;
-    or?: Maybe<Array<Scalars['ID']>>;
+export type FacetValueFilterInput = {
+    and?: InputMaybe<Scalars['ID']>;
+    or?: InputMaybe<Array<Scalars['ID']>>;
 };
 /**
  * Which FacetValues are present in the products returned
  * by the search, and in what quantity.
  */
-export declare type FacetValueResult = {
+export type FacetValueResult = {
     __typename?: 'FacetValueResult';
-    facetValue: FacetValue;
     count: Scalars['Int'];
+    facetValue: FacetValue;
 };
-export declare type FacetValueTranslation = {
+export type FacetValueTranslation = {
     __typename?: 'FacetValueTranslation';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    id: Scalars['ID'];
     languageCode: LanguageCode;
     name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type FloatCustomFieldConfig = CustomField & {
+export type FloatCustomFieldConfig = CustomField & {
     __typename?: 'FloatCustomFieldConfig';
-    name: Scalars['String'];
-    type: Scalars['String'];
-    list: Scalars['Boolean'];
-    label?: Maybe<Array<LocalizedString>>;
     description?: Maybe<Array<LocalizedString>>;
-    readonly?: Maybe<Scalars['Boolean']>;
     internal?: Maybe<Scalars['Boolean']>;
-    nullable?: Maybe<Scalars['Boolean']>;
-    min?: Maybe<Scalars['Float']>;
+    label?: Maybe<Array<LocalizedString>>;
+    list: Scalars['Boolean'];
     max?: Maybe<Scalars['Float']>;
+    min?: Maybe<Scalars['Float']>;
+    name: Scalars['String'];
+    nullable?: Maybe<Scalars['Boolean']>;
+    readonly?: Maybe<Scalars['Boolean']>;
     step?: Maybe<Scalars['Float']>;
+    type: Scalars['String'];
     ui?: Maybe<Scalars['JSON']>;
 };
-export declare type Fulfillment = Node & {
+export type Fulfillment = Node & {
     __typename?: 'Fulfillment';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    orderItems: Array<OrderItem>;
-    summary: Array<FulfillmentLineSummary>;
-    state: Scalars['String'];
+    customFields?: Maybe<Scalars['JSON']>;
+    id: Scalars['ID'];
+    lines: Array<FulfillmentLine>;
     method: Scalars['String'];
+    state: Scalars['String'];
+    /** @deprecated Use the `lines` field instead */
+    summary: Array<FulfillmentLine>;
     trackingCode?: Maybe<Scalars['String']>;
-    customFields?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type FulfillmentLineSummary = {
-    __typename?: 'FulfillmentLineSummary';
+export type FulfillmentLine = {
+    __typename?: 'FulfillmentLine';
+    fulfillment: Fulfillment;
+    fulfillmentId: Scalars['ID'];
     orderLine: OrderLine;
+    orderLineId: Scalars['ID'];
     quantity: Scalars['Int'];
 };
 export declare enum GlobalFlag {
-    TRUE = "TRUE",
     FALSE = "FALSE",
-    INHERIT = "INHERIT"
+    INHERIT = "INHERIT",
+    TRUE = "TRUE"
 }
-export declare type HistoryEntry = Node & {
+/** Returned when attempting to set the Customer on a guest checkout when the configured GuestCheckoutStrategy does not allow it. */
+export type GuestCheckoutError = ErrorResult & {
+    __typename?: 'GuestCheckoutError';
+    errorCode: ErrorCode;
+    errorDetail: Scalars['String'];
+    message: Scalars['String'];
+};
+export type HistoryEntry = Node & {
     __typename?: 'HistoryEntry';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    type: HistoryEntryType;
     data: Scalars['JSON'];
+    id: Scalars['ID'];
+    type: HistoryEntryType;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type HistoryEntryFilterParameter = {
-    id?: Maybe<IdOperators>;
-    createdAt?: Maybe<DateOperators>;
-    updatedAt?: Maybe<DateOperators>;
-    type?: Maybe<StringOperators>;
+export type HistoryEntryFilterParameter = {
+    createdAt?: InputMaybe<DateOperators>;
+    id?: InputMaybe<IdOperators>;
+    type?: InputMaybe<StringOperators>;
+    updatedAt?: InputMaybe<DateOperators>;
 };
-export declare type HistoryEntryList = PaginatedList & {
+export type HistoryEntryList = PaginatedList & {
     __typename?: 'HistoryEntryList';
     items: Array<HistoryEntry>;
     totalItems: Scalars['Int'];
 };
-export declare type HistoryEntryListOptions = {
-    /** Skips the first n results, for use in pagination */
-    skip?: Maybe<Scalars['Int']>;
-    /** Takes n results, for use in pagination */
-    take?: Maybe<Scalars['Int']>;
-    /** Specifies which properties to sort the results by */
-    sort?: Maybe<HistoryEntrySortParameter>;
+export type HistoryEntryListOptions = {
     /** Allows the results to be filtered */
-    filter?: Maybe<HistoryEntryFilterParameter>;
+    filter?: InputMaybe<HistoryEntryFilterParameter>;
     /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
-    filterOperator?: Maybe<LogicalOperator>;
+    filterOperator?: InputMaybe<LogicalOperator>;
+    /** Skips the first n results, for use in pagination */
+    skip?: InputMaybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: InputMaybe<HistoryEntrySortParameter>;
+    /** Takes n results, for use in pagination */
+    take?: InputMaybe<Scalars['Int']>;
 };
-export declare type HistoryEntrySortParameter = {
-    id?: Maybe<SortOrder>;
-    createdAt?: Maybe<SortOrder>;
-    updatedAt?: Maybe<SortOrder>;
+export type HistoryEntrySortParameter = {
+    createdAt?: InputMaybe<SortOrder>;
+    id?: InputMaybe<SortOrder>;
+    updatedAt?: InputMaybe<SortOrder>;
 };
 export declare enum HistoryEntryType {
-    CUSTOMER_REGISTERED = "CUSTOMER_REGISTERED",
-    CUSTOMER_VERIFIED = "CUSTOMER_VERIFIED",
-    CUSTOMER_DETAIL_UPDATED = "CUSTOMER_DETAIL_UPDATED",
     CUSTOMER_ADDED_TO_GROUP = "CUSTOMER_ADDED_TO_GROUP",
-    CUSTOMER_REMOVED_FROM_GROUP = "CUSTOMER_REMOVED_FROM_GROUP",
     CUSTOMER_ADDRESS_CREATED = "CUSTOMER_ADDRESS_CREATED",
-    CUSTOMER_ADDRESS_UPDATED = "CUSTOMER_ADDRESS_UPDATED",
     CUSTOMER_ADDRESS_DELETED = "CUSTOMER_ADDRESS_DELETED",
-    CUSTOMER_PASSWORD_UPDATED = "CUSTOMER_PASSWORD_UPDATED",
-    CUSTOMER_PASSWORD_RESET_REQUESTED = "CUSTOMER_PASSWORD_RESET_REQUESTED",
-    CUSTOMER_PASSWORD_RESET_VERIFIED = "CUSTOMER_PASSWORD_RESET_VERIFIED",
+    CUSTOMER_ADDRESS_UPDATED = "CUSTOMER_ADDRESS_UPDATED",
+    CUSTOMER_DETAIL_UPDATED = "CUSTOMER_DETAIL_UPDATED",
     CUSTOMER_EMAIL_UPDATE_REQUESTED = "CUSTOMER_EMAIL_UPDATE_REQUESTED",
     CUSTOMER_EMAIL_UPDATE_VERIFIED = "CUSTOMER_EMAIL_UPDATE_VERIFIED",
     CUSTOMER_NOTE = "CUSTOMER_NOTE",
-    ORDER_STATE_TRANSITION = "ORDER_STATE_TRANSITION",
-    ORDER_PAYMENT_TRANSITION = "ORDER_PAYMENT_TRANSITION",
-    ORDER_FULFILLMENT = "ORDER_FULFILLMENT",
+    CUSTOMER_PASSWORD_RESET_REQUESTED = "CUSTOMER_PASSWORD_RESET_REQUESTED",
+    CUSTOMER_PASSWORD_RESET_VERIFIED = "CUSTOMER_PASSWORD_RESET_VERIFIED",
+    CUSTOMER_PASSWORD_UPDATED = "CUSTOMER_PASSWORD_UPDATED",
+    CUSTOMER_REGISTERED = "CUSTOMER_REGISTERED",
+    CUSTOMER_REMOVED_FROM_GROUP = "CUSTOMER_REMOVED_FROM_GROUP",
+    CUSTOMER_VERIFIED = "CUSTOMER_VERIFIED",
     ORDER_CANCELLATION = "ORDER_CANCELLATION",
-    ORDER_REFUND_TRANSITION = "ORDER_REFUND_TRANSITION",
-    ORDER_FULFILLMENT_TRANSITION = "ORDER_FULFILLMENT_TRANSITION",
-    ORDER_NOTE = "ORDER_NOTE",
     ORDER_COUPON_APPLIED = "ORDER_COUPON_APPLIED",
     ORDER_COUPON_REMOVED = "ORDER_COUPON_REMOVED",
-    ORDER_MODIFIED = "ORDER_MODIFIED"
+    ORDER_FULFILLMENT = "ORDER_FULFILLMENT",
+    ORDER_FULFILLMENT_TRANSITION = "ORDER_FULFILLMENT_TRANSITION",
+    ORDER_MODIFIED = "ORDER_MODIFIED",
+    ORDER_NOTE = "ORDER_NOTE",
+    ORDER_PAYMENT_TRANSITION = "ORDER_PAYMENT_TRANSITION",
+    ORDER_REFUND_TRANSITION = "ORDER_REFUND_TRANSITION",
+    ORDER_STATE_TRANSITION = "ORDER_STATE_TRANSITION"
 }
 /** Operators for filtering on a list of ID fields */
-export declare type IdListOperators = {
+export type IdListOperators = {
     inList: Scalars['ID'];
 };
 /** Operators for filtering on an ID field */
-export declare type IdOperators = {
-    eq?: Maybe<Scalars['String']>;
-    notEq?: Maybe<Scalars['String']>;
-    in?: Maybe<Array<Scalars['String']>>;
-    notIn?: Maybe<Array<Scalars['String']>>;
-    isNull?: Maybe<Scalars['Boolean']>;
+export type IdOperators = {
+    eq?: InputMaybe<Scalars['String']>;
+    in?: InputMaybe<Array<Scalars['String']>>;
+    isNull?: InputMaybe<Scalars['Boolean']>;
+    notEq?: InputMaybe<Scalars['String']>;
+    notIn?: InputMaybe<Array<Scalars['String']>>;
 };
 /**
  * Returned if the token used to change a Customer's email address is valid, but has
  * expired according to the `verificationTokenDuration` setting in the AuthOptions.
  */
-export declare type IdentifierChangeTokenExpiredError = ErrorResult & {
+export type IdentifierChangeTokenExpiredError = ErrorResult & {
     __typename?: 'IdentifierChangeTokenExpiredError';
     errorCode: ErrorCode;
     message: Scalars['String'];
@@ -1055,53 +1073,53 @@ export declare type IdentifierChangeTokenExpiredError = ErrorResult & {
  * Returned if the token used to change a Customer's email address is either
  * invalid or does not match any expected tokens.
  */
-export declare type IdentifierChangeTokenInvalidError = ErrorResult & {
+export type IdentifierChangeTokenInvalidError = ErrorResult & {
     __typename?: 'IdentifierChangeTokenInvalidError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
 /** Returned when attempting to add a Payment using a PaymentMethod for which the Order is not eligible. */
-export declare type IneligiblePaymentMethodError = ErrorResult & {
+export type IneligiblePaymentMethodError = ErrorResult & {
     __typename?: 'IneligiblePaymentMethodError';
+    eligibilityCheckerMessage?: Maybe<Scalars['String']>;
     errorCode: ErrorCode;
     message: Scalars['String'];
-    eligibilityCheckerMessage?: Maybe<Scalars['String']>;
 };
 /** Returned when attempting to set a ShippingMethod for which the Order is not eligible */
-export declare type IneligibleShippingMethodError = ErrorResult & {
+export type IneligibleShippingMethodError = ErrorResult & {
     __typename?: 'IneligibleShippingMethodError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
 /** Returned when attempting to add more items to the Order than are available */
-export declare type InsufficientStockError = ErrorResult & {
+export type InsufficientStockError = ErrorResult & {
     __typename?: 'InsufficientStockError';
     errorCode: ErrorCode;
     message: Scalars['String'];
-    quantityAvailable: Scalars['Int'];
     order: Order;
+    quantityAvailable: Scalars['Int'];
 };
-export declare type IntCustomFieldConfig = CustomField & {
+export type IntCustomFieldConfig = CustomField & {
     __typename?: 'IntCustomFieldConfig';
-    name: Scalars['String'];
-    type: Scalars['String'];
-    list: Scalars['Boolean'];
-    label?: Maybe<Array<LocalizedString>>;
     description?: Maybe<Array<LocalizedString>>;
-    readonly?: Maybe<Scalars['Boolean']>;
     internal?: Maybe<Scalars['Boolean']>;
-    nullable?: Maybe<Scalars['Boolean']>;
-    min?: Maybe<Scalars['Int']>;
+    label?: Maybe<Array<LocalizedString>>;
+    list: Scalars['Boolean'];
     max?: Maybe<Scalars['Int']>;
+    min?: Maybe<Scalars['Int']>;
+    name: Scalars['String'];
+    nullable?: Maybe<Scalars['Boolean']>;
+    readonly?: Maybe<Scalars['Boolean']>;
     step?: Maybe<Scalars['Int']>;
+    type: Scalars['String'];
     ui?: Maybe<Scalars['JSON']>;
 };
 /** Returned if the user authentication credentials are not valid */
-export declare type InvalidCredentialsError = ErrorResult & {
+export type InvalidCredentialsError = ErrorResult & {
     __typename?: 'InvalidCredentialsError';
+    authenticationError: Scalars['String'];
     errorCode: ErrorCode;
     message: Scalars['String'];
-    authenticationError: Scalars['String'];
 };
 /**
  * @description
@@ -1117,62 +1135,54 @@ export declare enum LanguageCode {
     af = "af",
     /** Akan */
     ak = "ak",
-    /** Albanian */
-    sq = "sq",
     /** Amharic */
     am = "am",
     /** Arabic */
     ar = "ar",
-    /** Armenian */
-    hy = "hy",
     /** Assamese */
     as = "as",
     /** Azerbaijani */
     az = "az",
+    /** Belarusian */
+    be = "be",
+    /** Bulgarian */
+    bg = "bg",
     /** Bambara */
     bm = "bm",
     /** Bangla */
     bn = "bn",
-    /** Basque */
-    eu = "eu",
-    /** Belarusian */
-    be = "be",
-    /** Bosnian */
-    bs = "bs",
+    /** Tibetan */
+    bo = "bo",
     /** Breton */
     br = "br",
-    /** Bulgarian */
-    bg = "bg",
-    /** Burmese */
-    my = "my",
+    /** Bosnian */
+    bs = "bs",
     /** Catalan */
     ca = "ca",
     /** Chechen */
     ce = "ce",
-    /** Chinese */
-    zh = "zh",
-    /** Simplified Chinese */
-    zh_Hans = "zh_Hans",
-    /** Traditional Chinese */
-    zh_Hant = "zh_Hant",
-    /** Church Slavic */
-    cu = "cu",
-    /** Cornish */
-    kw = "kw",
     /** Corsican */
     co = "co",
-    /** Croatian */
-    hr = "hr",
     /** Czech */
     cs = "cs",
+    /** Church Slavic */
+    cu = "cu",
+    /** Welsh */
+    cy = "cy",
     /** Danish */
     da = "da",
-    /** Dutch */
-    nl = "nl",
-    /** Flemish */
-    nl_BE = "nl_BE",
+    /** German */
+    de = "de",
+    /** Austrian German */
+    de_AT = "de_AT",
+    /** Swiss High German */
+    de_CH = "de_CH",
     /** Dzongkha */
     dz = "dz",
+    /** Ewe */
+    ee = "ee",
+    /** Greek */
+    el = "el",
     /** English */
     en = "en",
     /** Australian English */
@@ -1185,238 +1195,240 @@ export declare enum LanguageCode {
     en_US = "en_US",
     /** Esperanto */
     eo = "eo",
+    /** Spanish */
+    es = "es",
+    /** European Spanish */
+    es_ES = "es_ES",
+    /** Mexican Spanish */
+    es_MX = "es_MX",
     /** Estonian */
     et = "et",
-    /** Ewe */
-    ee = "ee",
-    /** Faroese */
-    fo = "fo",
+    /** Basque */
+    eu = "eu",
+    /** Persian */
+    fa = "fa",
+    /** Dari */
+    fa_AF = "fa_AF",
+    /** Fulah */
+    ff = "ff",
     /** Finnish */
     fi = "fi",
+    /** Faroese */
+    fo = "fo",
     /** French */
     fr = "fr",
     /** Canadian French */
     fr_CA = "fr_CA",
     /** Swiss French */
     fr_CH = "fr_CH",
-    /** Fulah */
-    ff = "ff",
+    /** Western Frisian */
+    fy = "fy",
+    /** Irish */
+    ga = "ga",
+    /** Scottish Gaelic */
+    gd = "gd",
     /** Galician */
     gl = "gl",
-    /** Ganda */
-    lg = "lg",
-    /** Georgian */
-    ka = "ka",
-    /** German */
-    de = "de",
-    /** Austrian German */
-    de_AT = "de_AT",
-    /** Swiss High German */
-    de_CH = "de_CH",
-    /** Greek */
-    el = "el",
     /** Gujarati */
     gu = "gu",
-    /** Haitian Creole */
-    ht = "ht",
+    /** Manx */
+    gv = "gv",
     /** Hausa */
     ha = "ha",
     /** Hebrew */
     he = "he",
     /** Hindi */
     hi = "hi",
+    /** Croatian */
+    hr = "hr",
+    /** Haitian Creole */
+    ht = "ht",
     /** Hungarian */
     hu = "hu",
-    /** Icelandic */
-    is = "is",
-    /** Igbo */
-    ig = "ig",
-    /** Indonesian */
-    id = "id",
+    /** Armenian */
+    hy = "hy",
     /** Interlingua */
     ia = "ia",
-    /** Irish */
-    ga = "ga",
+    /** Indonesian */
+    id = "id",
+    /** Igbo */
+    ig = "ig",
+    /** Sichuan Yi */
+    ii = "ii",
+    /** Icelandic */
+    is = "is",
     /** Italian */
     it = "it",
     /** Japanese */
     ja = "ja",
     /** Javanese */
     jv = "jv",
+    /** Georgian */
+    ka = "ka",
+    /** Kikuyu */
+    ki = "ki",
+    /** Kazakh */
+    kk = "kk",
     /** Kalaallisut */
     kl = "kl",
-    /** Kannada */
-    kn = "kn",
-    /** Kashmiri */
-    ks = "ks",
-    /** Kazakh */
-    kk = "kk",
     /** Khmer */
     km = "km",
-    /** Kikuyu */
-    ki = "ki",
-    /** Kinyarwanda */
-    rw = "rw",
+    /** Kannada */
+    kn = "kn",
     /** Korean */
     ko = "ko",
+    /** Kashmiri */
+    ks = "ks",
     /** Kurdish */
     ku = "ku",
+    /** Cornish */
+    kw = "kw",
     /** Kyrgyz */
     ky = "ky",
-    /** Lao */
-    lo = "lo",
     /** Latin */
     la = "la",
-    /** Latvian */
-    lv = "lv",
+    /** Luxembourgish */
+    lb = "lb",
+    /** Ganda */
+    lg = "lg",
     /** Lingala */
     ln = "ln",
+    /** Lao */
+    lo = "lo",
     /** Lithuanian */
     lt = "lt",
     /** Luba-Katanga */
     lu = "lu",
-    /** Luxembourgish */
-    lb = "lb",
-    /** Macedonian */
-    mk = "mk",
+    /** Latvian */
+    lv = "lv",
     /** Malagasy */
     mg = "mg",
-    /** Malay */
-    ms = "ms",
-    /** Malayalam */
-    ml = "ml",
-    /** Maltese */
-    mt = "mt",
-    /** Manx */
-    gv = "gv",
     /** Maori */
     mi = "mi",
-    /** Marathi */
-    mr = "mr",
+    /** Macedonian */
+    mk = "mk",
+    /** Malayalam */
+    ml = "ml",
     /** Mongolian */
     mn = "mn",
-    /** Nepali */
-    ne = "ne",
-    /** North Ndebele */
-    nd = "nd",
-    /** Northern Sami */
-    se = "se",
+    /** Marathi */
+    mr = "mr",
+    /** Malay */
+    ms = "ms",
+    /** Maltese */
+    mt = "mt",
+    /** Burmese */
+    my = "my",
     /** Norwegian Bokmål */
     nb = "nb",
+    /** North Ndebele */
+    nd = "nd",
+    /** Nepali */
+    ne = "ne",
+    /** Dutch */
+    nl = "nl",
+    /** Flemish */
+    nl_BE = "nl_BE",
     /** Norwegian Nynorsk */
     nn = "nn",
     /** Nyanja */
     ny = "ny",
-    /** Odia */
-    or = "or",
     /** Oromo */
     om = "om",
+    /** Odia */
+    or = "or",
     /** Ossetic */
     os = "os",
-    /** Pashto */
-    ps = "ps",
-    /** Persian */
-    fa = "fa",
-    /** Dari */
-    fa_AF = "fa_AF",
+    /** Punjabi */
+    pa = "pa",
     /** Polish */
     pl = "pl",
+    /** Pashto */
+    ps = "ps",
     /** Portuguese */
     pt = "pt",
     /** Brazilian Portuguese */
     pt_BR = "pt_BR",
     /** European Portuguese */
     pt_PT = "pt_PT",
-    /** Punjabi */
-    pa = "pa",
     /** Quechua */
     qu = "qu",
-    /** Romanian */
-    ro = "ro",
-    /** Moldavian */
-    ro_MD = "ro_MD",
     /** Romansh */
     rm = "rm",
     /** Rundi */
     rn = "rn",
+    /** Romanian */
+    ro = "ro",
+    /** Moldavian */
+    ro_MD = "ro_MD",
     /** Russian */
     ru = "ru",
-    /** Samoan */
-    sm = "sm",
-    /** Sango */
-    sg = "sg",
+    /** Kinyarwanda */
+    rw = "rw",
     /** Sanskrit */
     sa = "sa",
-    /** Scottish Gaelic */
-    gd = "gd",
-    /** Serbian */
-    sr = "sr",
-    /** Shona */
-    sn = "sn",
-    /** Sichuan Yi */
-    ii = "ii",
     /** Sindhi */
     sd = "sd",
+    /** Northern Sami */
+    se = "se",
+    /** Sango */
+    sg = "sg",
     /** Sinhala */
     si = "si",
     /** Slovak */
     sk = "sk",
     /** Slovenian */
     sl = "sl",
+    /** Samoan */
+    sm = "sm",
+    /** Shona */
+    sn = "sn",
     /** Somali */
     so = "so",
+    /** Albanian */
+    sq = "sq",
+    /** Serbian */
+    sr = "sr",
     /** Southern Sotho */
     st = "st",
-    /** Spanish */
-    es = "es",
-    /** European Spanish */
-    es_ES = "es_ES",
-    /** Mexican Spanish */
-    es_MX = "es_MX",
     /** Sundanese */
     su = "su",
+    /** Swedish */
+    sv = "sv",
     /** Swahili */
     sw = "sw",
     /** Congo Swahili */
     sw_CD = "sw_CD",
-    /** Swedish */
-    sv = "sv",
-    /** Tajik */
-    tg = "tg",
     /** Tamil */
     ta = "ta",
-    /** Tatar */
-    tt = "tt",
     /** Telugu */
     te = "te",
+    /** Tajik */
+    tg = "tg",
     /** Thai */
     th = "th",
-    /** Tibetan */
-    bo = "bo",
     /** Tigrinya */
     ti = "ti",
+    /** Turkmen */
+    tk = "tk",
     /** Tongan */
     to = "to",
     /** Turkish */
     tr = "tr",
-    /** Turkmen */
-    tk = "tk",
+    /** Tatar */
+    tt = "tt",
+    /** Uyghur */
+    ug = "ug",
     /** Ukrainian */
     uk = "uk",
     /** Urdu */
     ur = "ur",
-    /** Uyghur */
-    ug = "ug",
     /** Uzbek */
     uz = "uz",
     /** Vietnamese */
     vi = "vi",
     /** Volapük */
     vo = "vo",
-    /** Welsh */
-    cy = "cy",
-    /** Western Frisian */
-    fy = "fy",
     /** Wolof */
     wo = "wo",
     /** Xhosa */
@@ -1425,24 +1437,42 @@ export declare enum LanguageCode {
     yi = "yi",
     /** Yoruba */
     yo = "yo",
+    /** Chinese */
+    zh = "zh",
+    /** Simplified Chinese */
+    zh_Hans = "zh_Hans",
+    /** Traditional Chinese */
+    zh_Hant = "zh_Hant",
     /** Zulu */
     zu = "zu"
 }
-export declare type LocaleStringCustomFieldConfig = CustomField & {
+export type LocaleStringCustomFieldConfig = CustomField & {
     __typename?: 'LocaleStringCustomFieldConfig';
+    description?: Maybe<Array<LocalizedString>>;
+    internal?: Maybe<Scalars['Boolean']>;
+    label?: Maybe<Array<LocalizedString>>;
+    length?: Maybe<Scalars['Int']>;
+    list: Scalars['Boolean'];
     name: Scalars['String'];
+    nullable?: Maybe<Scalars['Boolean']>;
+    pattern?: Maybe<Scalars['String']>;
+    readonly?: Maybe<Scalars['Boolean']>;
     type: Scalars['String'];
-    list: Scalars['Boolean'];
-    length?: Maybe<Scalars['Int']>;
-    label?: Maybe<Array<LocalizedString>>;
+    ui?: Maybe<Scalars['JSON']>;
+};
+export type LocaleTextCustomFieldConfig = CustomField & {
+    __typename?: 'LocaleTextCustomFieldConfig';
     description?: Maybe<Array<LocalizedString>>;
-    readonly?: Maybe<Scalars['Boolean']>;
     internal?: Maybe<Scalars['Boolean']>;
+    label?: Maybe<Array<LocalizedString>>;
+    list: Scalars['Boolean'];
+    name: Scalars['String'];
     nullable?: Maybe<Scalars['Boolean']>;
-    pattern?: Maybe<Scalars['String']>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    type: Scalars['String'];
     ui?: Maybe<Scalars['JSON']>;
 };
-export declare type LocalizedString = {
+export type LocalizedString = {
     __typename?: 'LocalizedString';
     languageCode: LanguageCode;
     value: Scalars['String'];
@@ -1452,49 +1482,49 @@ export declare enum LogicalOperator {
     OR = "OR"
 }
 /** Returned when attempting to register or verify a customer account without a password, when one is required. */
-export declare type MissingPasswordError = ErrorResult & {
+export type MissingPasswordError = ErrorResult & {
     __typename?: 'MissingPasswordError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
-export declare type MollieAmount = {
+export type MollieAmount = {
     __typename?: 'MollieAmount';
-    value?: Maybe<Scalars['String']>;
     currency?: Maybe<Scalars['String']>;
+    value?: Maybe<Scalars['String']>;
 };
-export declare type MolliePaymentIntent = {
+export type MolliePaymentIntent = {
     __typename?: 'MolliePaymentIntent';
     url: Scalars['String'];
 };
-export declare type MolliePaymentIntentError = ErrorResult & {
+export type MolliePaymentIntentError = ErrorResult & {
     __typename?: 'MolliePaymentIntentError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
-export declare type MolliePaymentIntentInput = {
+export type MolliePaymentIntentInput = {
+    molliePaymentMethodCode?: InputMaybe<Scalars['String']>;
     paymentMethodCode: Scalars['String'];
-    molliePaymentMethodCode?: Maybe<Scalars['String']>;
 };
-export declare type MolliePaymentIntentResult = MolliePaymentIntent | MolliePaymentIntentError;
-export declare type MolliePaymentMethod = {
+export type MolliePaymentIntentResult = MolliePaymentIntent | MolliePaymentIntentError;
+export type MolliePaymentMethod = {
     __typename?: 'MolliePaymentMethod';
-    id: Scalars['ID'];
     code: Scalars['String'];
     description?: Maybe<Scalars['String']>;
-    minimumAmount?: Maybe<MollieAmount>;
-    maximumAmount?: Maybe<MollieAmount>;
+    id: Scalars['ID'];
     image?: Maybe<MolliePaymentMethodImages>;
+    maximumAmount?: Maybe<MollieAmount>;
+    minimumAmount?: Maybe<MollieAmount>;
 };
-export declare type MolliePaymentMethodImages = {
+export type MolliePaymentMethodImages = {
     __typename?: 'MolliePaymentMethodImages';
     size1x?: Maybe<Scalars['String']>;
     size2x?: Maybe<Scalars['String']>;
     svg?: Maybe<Scalars['String']>;
 };
-export declare type MolliePaymentMethodsInput = {
+export type MolliePaymentMethodsInput = {
     paymentMethodCode: Scalars['String'];
 };
-export declare type Mutation = {
+export type Mutation = {
     __typename?: 'Mutation';
     /** Adds an item to the order. If custom fields are defined on the OrderLine entity, a third argument 'customFields' will be available. */
     addItemToOrder: UpdateOrderItemsResult;
@@ -1559,7 +1589,12 @@ export declare type Mutation = {
     setOrderCustomFields: ActiveOrderResult;
     /** Sets the shipping address for this order */
     setOrderShippingAddress: ActiveOrderResult;
-    /** Sets the shipping method by id, which can be obtained with the `eligibleShippingMethods` query */
+    /**
+     * Sets the shipping method by id, which can be obtained with the `eligibleShippingMethods` query.
+     * An Order can have multiple shipping methods, in which case you can pass an array of ids. In this case,
+     * you should configure a custom ShippingLineAssignmentStrategy in order to know which OrderLines each
+     * shipping method will apply to.
+     */
     setOrderShippingMethod: SetOrderShippingMethodResult;
     /** Transitions an Order to a new state. Valid next states can be found by querying `nextOrderStates` */
     transitionOrderToState?: Maybe<TransitionOrderToStateResult>;
@@ -1582,109 +1617,109 @@ export declare type Mutation = {
      */
     verifyCustomerAccount: VerifyCustomerAccountResult;
 };
-export declare type MutationAddItemToOrderArgs = {
+export type MutationAddItemToOrderArgs = {
     productVariantId: Scalars['ID'];
     quantity: Scalars['Int'];
 };
-export declare type MutationAddPaymentToOrderArgs = {
+export type MutationAddPaymentToOrderArgs = {
     input: PaymentInput;
 };
-export declare type MutationAdjustOrderLineArgs = {
+export type MutationAdjustOrderLineArgs = {
     orderLineId: Scalars['ID'];
     quantity: Scalars['Int'];
 };
-export declare type MutationApplyCouponCodeArgs = {
+export type MutationApplyCouponCodeArgs = {
     couponCode: Scalars['String'];
 };
-export declare type MutationAuthenticateArgs = {
+export type MutationAuthenticateArgs = {
     input: AuthenticationInput;
-    rememberMe?: Maybe<Scalars['Boolean']>;
+    rememberMe?: InputMaybe<Scalars['Boolean']>;
 };
-export declare type MutationCreateCustomerAddressArgs = {
+export type MutationCreateCustomerAddressArgs = {
     input: CreateAddressInput;
 };
-export declare type MutationCreateMolliePaymentIntentArgs = {
+export type MutationCreateMolliePaymentIntentArgs = {
     input: MolliePaymentIntentInput;
 };
-export declare type MutationDeleteCustomerAddressArgs = {
+export type MutationDeleteCustomerAddressArgs = {
     id: Scalars['ID'];
 };
-export declare type MutationLoginArgs = {
-    username: Scalars['String'];
+export type MutationLoginArgs = {
     password: Scalars['String'];
-    rememberMe?: Maybe<Scalars['Boolean']>;
+    rememberMe?: InputMaybe<Scalars['Boolean']>;
+    username: Scalars['String'];
 };
-export declare type MutationRefreshCustomerVerificationArgs = {
+export type MutationRefreshCustomerVerificationArgs = {
     emailAddress: Scalars['String'];
 };
-export declare type MutationRegisterCustomerAccountArgs = {
+export type MutationRegisterCustomerAccountArgs = {
     input: RegisterCustomerInput;
 };
-export declare type MutationRemoveCouponCodeArgs = {
+export type MutationRemoveCouponCodeArgs = {
     couponCode: Scalars['String'];
 };
-export declare type MutationRemoveOrderLineArgs = {
+export type MutationRemoveOrderLineArgs = {
     orderLineId: Scalars['ID'];
 };
-export declare type MutationRequestPasswordResetArgs = {
+export type MutationRequestPasswordResetArgs = {
     emailAddress: Scalars['String'];
 };
-export declare type MutationRequestUpdateCustomerEmailAddressArgs = {
-    password: Scalars['String'];
+export type MutationRequestUpdateCustomerEmailAddressArgs = {
     newEmailAddress: Scalars['String'];
+    password: Scalars['String'];
 };
-export declare type MutationResetPasswordArgs = {
-    token: Scalars['String'];
+export type MutationResetPasswordArgs = {
     password: Scalars['String'];
+    token: Scalars['String'];
 };
-export declare type MutationSetCustomerForOrderArgs = {
+export type MutationSetCustomerForOrderArgs = {
     input: CreateCustomerInput;
 };
-export declare type MutationSetOrderBillingAddressArgs = {
+export type MutationSetOrderBillingAddressArgs = {
     input: CreateAddressInput;
 };
-export declare type MutationSetOrderCustomFieldsArgs = {
+export type MutationSetOrderCustomFieldsArgs = {
     input: UpdateOrderInput;
 };
-export declare type MutationSetOrderShippingAddressArgs = {
+export type MutationSetOrderShippingAddressArgs = {
     input: CreateAddressInput;
 };
-export declare type MutationSetOrderShippingMethodArgs = {
-    shippingMethodId: Scalars['ID'];
+export type MutationSetOrderShippingMethodArgs = {
+    shippingMethodId: Array<Scalars['ID']>;
 };
-export declare type MutationTransitionOrderToStateArgs = {
+export type MutationTransitionOrderToStateArgs = {
     state: Scalars['String'];
 };
-export declare type MutationUpdateCustomerArgs = {
+export type MutationUpdateCustomerArgs = {
     input: UpdateCustomerInput;
 };
-export declare type MutationUpdateCustomerAddressArgs = {
+export type MutationUpdateCustomerAddressArgs = {
     input: UpdateAddressInput;
 };
-export declare type MutationUpdateCustomerEmailAddressArgs = {
+export type MutationUpdateCustomerEmailAddressArgs = {
     token: Scalars['String'];
 };
-export declare type MutationUpdateCustomerPasswordArgs = {
+export type MutationUpdateCustomerPasswordArgs = {
     currentPassword: Scalars['String'];
     newPassword: Scalars['String'];
 };
-export declare type MutationVerifyCustomerAccountArgs = {
+export type MutationVerifyCustomerAccountArgs = {
+    password?: InputMaybe<Scalars['String']>;
     token: Scalars['String'];
-    password?: Maybe<Scalars['String']>;
 };
-export declare type NativeAuthInput = {
-    username: Scalars['String'];
+export type NativeAuthInput = {
     password: Scalars['String'];
+    username: Scalars['String'];
 };
 /** Returned when attempting an operation that relies on the NativeAuthStrategy, if that strategy is not configured. */
-export declare type NativeAuthStrategyError = ErrorResult & {
+export type NativeAuthStrategyError = ErrorResult & {
     __typename?: 'NativeAuthStrategyError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
-export declare type NativeAuthenticationResult = CurrentUser | InvalidCredentialsError | NotVerifiedError | NativeAuthStrategyError;
+export type NativeAuthenticationResult = CurrentUser | InvalidCredentialsError | NativeAuthStrategyError | NotVerifiedError;
 /** Returned when attempting to set a negative OrderLine quantity. */
-export declare type NegativeQuantityError = ErrorResult & {
+export type NegativeQuantityError = ErrorResult & {
     __typename?: 'NegativeQuantityError';
     errorCode: ErrorCode;
     message: Scalars['String'];
@@ -1693,141 +1728,138 @@ export declare type NegativeQuantityError = ErrorResult & {
  * Returned when invoking a mutation which depends on there being an active Order on the
  * current session.
  */
-export declare type NoActiveOrderError = ErrorResult & {
+export type NoActiveOrderError = ErrorResult & {
     __typename?: 'NoActiveOrderError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
-export declare type Node = {
+export type Node = {
     id: Scalars['ID'];
 };
 /**
  * Returned if `authOptions.requireVerification` is set to `true` (which is the default)
  * and an unverified user attempts to authenticate.
  */
-export declare type NotVerifiedError = ErrorResult & {
+export type NotVerifiedError = ErrorResult & {
     __typename?: 'NotVerifiedError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
 /** Operators for filtering on a list of Number fields */
-export declare type NumberListOperators = {
+export type NumberListOperators = {
     inList: Scalars['Float'];
 };
 /** Operators for filtering on a Int or Float field */
-export declare type NumberOperators = {
-    eq?: Maybe<Scalars['Float']>;
-    lt?: Maybe<Scalars['Float']>;
-    lte?: Maybe<Scalars['Float']>;
-    gt?: Maybe<Scalars['Float']>;
-    gte?: Maybe<Scalars['Float']>;
-    between?: Maybe<NumberRange>;
-    isNull?: Maybe<Scalars['Boolean']>;
-};
-export declare type NumberRange = {
-    start: Scalars['Float'];
+export type NumberOperators = {
+    between?: InputMaybe<NumberRange>;
+    eq?: InputMaybe<Scalars['Float']>;
+    gt?: InputMaybe<Scalars['Float']>;
+    gte?: InputMaybe<Scalars['Float']>;
+    isNull?: InputMaybe<Scalars['Boolean']>;
+    lt?: InputMaybe<Scalars['Float']>;
+    lte?: InputMaybe<Scalars['Float']>;
+};
+export type NumberRange = {
     end: Scalars['Float'];
+    start: Scalars['Float'];
 };
-export declare type Order = Node & {
+export type Order = Node & {
     __typename?: 'Order';
-    id: Scalars['ID'];
-    createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    /**
-     * The date & time that the Order was placed, i.e. the Customer
-     * completed the checkout and the Order is no longer "active"
-     */
-    orderPlacedAt?: Maybe<Scalars['DateTime']>;
-    /** A unique code for the Order */
-    code: Scalars['String'];
-    state: Scalars['String'];
     /** An order is active as long as the payment process has not been completed */
     active: Scalars['Boolean'];
-    customer?: Maybe<Customer>;
-    shippingAddress?: Maybe<OrderAddress>;
     billingAddress?: Maybe<OrderAddress>;
+    /** A unique code for the Order */
+    code: Scalars['String'];
+    /** An array of all coupon codes applied to the Order */
+    couponCodes: Array<Scalars['String']>;
+    createdAt: Scalars['DateTime'];
+    currencyCode: CurrencyCode;
+    customFields?: Maybe<Scalars['JSON']>;
+    customer?: Maybe<Customer>;
+    discounts: Array<Discount>;
+    fulfillments?: Maybe<Array<Fulfillment>>;
+    history: HistoryEntryList;
+    id: Scalars['ID'];
     lines: Array<OrderLine>;
     /**
-     * Surcharges are arbitrary modifications to the Order total which are neither
-     * ProductVariants nor discounts resulting from applied Promotions. For example,
-     * one-off discounts based on customer interaction, or surcharges based on payment
-     * methods.
+     * The date & time that the Order was placed, i.e. the Customer
+     * completed the checkout and the Order is no longer "active"
      */
-    surcharges: Array<Surcharge>;
-    discounts: Array<Discount>;
-    /** An array of all coupon codes applied to the Order */
-    couponCodes: Array<Scalars['String']>;
+    orderPlacedAt?: Maybe<Scalars['DateTime']>;
+    payments?: Maybe<Array<Payment>>;
     /** Promotions applied to the order. Only gets populated after the payment process has completed. */
     promotions: Array<Promotion>;
-    payments?: Maybe<Array<Payment>>;
-    fulfillments?: Maybe<Array<Fulfillment>>;
-    totalQuantity: Scalars['Int'];
+    shipping: Scalars['Money'];
+    shippingAddress?: Maybe<OrderAddress>;
+    shippingLines: Array<ShippingLine>;
+    shippingWithTax: Scalars['Money'];
+    state: Scalars['String'];
     /**
      * The subTotal is the total of all OrderLines in the Order. This figure also includes any Order-level
      * discounts which have been prorated (proportionally distributed) amongst the OrderItems.
      * To get a total of all OrderLines which does not account for prorated discounts, use the
      * sum of `OrderLine.discountedLinePrice` values.
      */
-    subTotal: Scalars['Int'];
+    subTotal: Scalars['Money'];
     /** Same as subTotal, but inclusive of tax */
-    subTotalWithTax: Scalars['Int'];
-    currencyCode: CurrencyCode;
-    shippingLines: Array<ShippingLine>;
-    shipping: Scalars['Int'];
-    shippingWithTax: Scalars['Int'];
-    /** Equal to subTotal plus shipping */
-    total: Scalars['Int'];
-    /** The final payable amount. Equal to subTotalWithTax plus shippingWithTax */
-    totalWithTax: Scalars['Int'];
+    subTotalWithTax: Scalars['Money'];
+    /**
+     * Surcharges are arbitrary modifications to the Order total which are neither
+     * ProductVariants nor discounts resulting from applied Promotions. For example,
+     * one-off discounts based on customer interaction, or surcharges based on payment
+     * methods.
+     */
+    surcharges: Array<Surcharge>;
     /** A summary of the taxes being applied to this Order */
     taxSummary: Array<OrderTaxSummary>;
-    history: HistoryEntryList;
-    customFields?: Maybe<Scalars['JSON']>;
+    /** Equal to subTotal plus shipping */
+    total: Scalars['Money'];
+    totalQuantity: Scalars['Int'];
+    /** The final payable amount. Equal to subTotalWithTax plus shippingWithTax */
+    totalWithTax: Scalars['Money'];
+    type: OrderType;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type OrderHistoryArgs = {
-    options?: Maybe<HistoryEntryListOptions>;
+export type OrderHistoryArgs = {
+    options?: InputMaybe<HistoryEntryListOptions>;
 };
-export declare type OrderAddress = {
+export type OrderAddress = {
     __typename?: 'OrderAddress';
-    fullName?: Maybe<Scalars['String']>;
-    company?: Maybe<Scalars['String']>;
-    streetLine1?: Maybe<Scalars['String']>;
-    streetLine2?: Maybe<Scalars['String']>;
     city?: Maybe<Scalars['String']>;
-    province?: Maybe<Scalars['String']>;
-    postalCode?: Maybe<Scalars['String']>;
+    company?: Maybe<Scalars['String']>;
     country?: Maybe<Scalars['String']>;
     countryCode?: Maybe<Scalars['String']>;
-    phoneNumber?: Maybe<Scalars['String']>;
     customFields?: Maybe<Scalars['JSON']>;
+    fullName?: Maybe<Scalars['String']>;
+    phoneNumber?: Maybe<Scalars['String']>;
+    postalCode?: Maybe<Scalars['String']>;
+    province?: Maybe<Scalars['String']>;
+    streetLine1?: Maybe<Scalars['String']>;
+    streetLine2?: Maybe<Scalars['String']>;
 };
-export declare type OrderFilterParameter = {
-    id?: Maybe<IdOperators>;
-    createdAt?: Maybe<DateOperators>;
-    updatedAt?: Maybe<DateOperators>;
-    orderPlacedAt?: Maybe<DateOperators>;
-    code?: Maybe<StringOperators>;
-    state?: Maybe<StringOperators>;
-    active?: Maybe<BooleanOperators>;
-    totalQuantity?: Maybe<NumberOperators>;
-    subTotal?: Maybe<NumberOperators>;
-    subTotalWithTax?: Maybe<NumberOperators>;
-    currencyCode?: Maybe<StringOperators>;
-    shipping?: Maybe<NumberOperators>;
-    shippingWithTax?: Maybe<NumberOperators>;
-    total?: Maybe<NumberOperators>;
-    totalWithTax?: Maybe<NumberOperators>;
-};
-export declare type OrderItem = Node & {
+export type OrderFilterParameter = {
+    active?: InputMaybe<BooleanOperators>;
+    code?: InputMaybe<StringOperators>;
+    createdAt?: InputMaybe<DateOperators>;
+    currencyCode?: InputMaybe<StringOperators>;
+    id?: InputMaybe<IdOperators>;
+    orderPlacedAt?: InputMaybe<DateOperators>;
+    shipping?: InputMaybe<NumberOperators>;
+    shippingWithTax?: InputMaybe<NumberOperators>;
+    state?: InputMaybe<StringOperators>;
+    subTotal?: InputMaybe<NumberOperators>;
+    subTotalWithTax?: InputMaybe<NumberOperators>;
+    total?: InputMaybe<NumberOperators>;
+    totalQuantity?: InputMaybe<NumberOperators>;
+    totalWithTax?: InputMaybe<NumberOperators>;
+    type?: InputMaybe<StringOperators>;
+    updatedAt?: InputMaybe<DateOperators>;
+};
+export type OrderItem = Node & {
     __typename?: 'OrderItem';
-    id: Scalars['ID'];
-    createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    adjustments: Array<Adjustment>;
     cancelled: Scalars['Boolean'];
-    /** The price of a single unit, excluding tax and discounts */
-    unitPrice: Scalars['Int'];
-    /** The price of a single unit, including tax but excluding discounts */
-    unitPriceWithTax: Scalars['Int'];
+    createdAt: Scalars['DateTime'];
     /**
      * The price of a single unit including discounts, excluding tax.
      *
@@ -1836,46 +1868,44 @@ export declare type OrderItem = Node & {
      * correct price to display to customers to avoid confusion
      * about the internal handling of distributed Order-level discounts.
      */
-    discountedUnitPrice: Scalars['Int'];
+    discountedUnitPrice: Scalars['Money'];
     /** The price of a single unit including discounts and tax */
-    discountedUnitPriceWithTax: Scalars['Int'];
+    discountedUnitPriceWithTax: Scalars['Money'];
+    fulfillment?: Maybe<Fulfillment>;
+    id: Scalars['ID'];
     /**
      * The actual unit price, taking into account both item discounts _and_ prorated (proportionally-distributed)
      * Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
      * and refund calculations.
      */
-    proratedUnitPrice: Scalars['Int'];
+    proratedUnitPrice: Scalars['Money'];
     /** The proratedUnitPrice including tax */
-    proratedUnitPriceWithTax: Scalars['Int'];
-    unitTax: Scalars['Int'];
-    taxRate: Scalars['Float'];
-    adjustments: Array<Adjustment>;
-    taxLines: Array<TaxLine>;
-    fulfillment?: Maybe<Fulfillment>;
+    proratedUnitPriceWithTax: Scalars['Money'];
     refundId?: Maybe<Scalars['ID']>;
+    taxLines: Array<TaxLine>;
+    taxRate: Scalars['Float'];
+    /** The price of a single unit, excluding tax and discounts */
+    unitPrice: Scalars['Money'];
+    /** The price of a single unit, including tax but excluding discounts */
+    unitPriceWithTax: Scalars['Money'];
+    unitTax: Scalars['Money'];
+    updatedAt: Scalars['DateTime'];
 };
 /** Returned when the maximum order size limit has been reached. */
-export declare type OrderLimitError = ErrorResult & {
+export type OrderLimitError = ErrorResult & {
     __typename?: 'OrderLimitError';
     errorCode: ErrorCode;
-    message: Scalars['String'];
     maxItems: Scalars['Int'];
+    message: Scalars['String'];
 };
-export declare type OrderLine = Node & {
+export type OrderLine = Node & {
     __typename?: 'OrderLine';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    productVariant: ProductVariant;
-    featuredAsset?: Maybe<Asset>;
-    /** The price of a single unit, excluding tax and discounts */
-    unitPrice: Scalars['Int'];
-    /** The price of a single unit, including tax but excluding discounts */
-    unitPriceWithTax: Scalars['Int'];
-    /** Non-zero if the unitPrice has changed since it was initially added to Order */
-    unitPriceChangeSinceAdded: Scalars['Int'];
-    /** Non-zero if the unitPriceWithTax has changed since it was initially added to Order */
-    unitPriceWithTaxChangeSinceAdded: Scalars['Int'];
+    customFields?: Maybe<Scalars['JSON']>;
+    /** The price of the line including discounts, excluding tax */
+    discountedLinePrice: Scalars['Money'];
+    /** The price of the line including discounts and tax */
+    discountedLinePriceWithTax: Scalars['Money'];
     /**
      * The price of a single unit including discounts, excluding tax.
      *
@@ -1884,118 +1914,131 @@ export declare type OrderLine = Node & {
      * correct price to display to customers to avoid confusion
      * about the internal handling of distributed Order-level discounts.
      */
-    discountedUnitPrice: Scalars['Int'];
+    discountedUnitPrice: Scalars['Money'];
     /** The price of a single unit including discounts and tax */
-    discountedUnitPriceWithTax: Scalars['Int'];
-    /**
-     * The actual unit price, taking into account both item discounts _and_ prorated (proportionally-distributed)
-     * Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
-     * and refund calculations.
-     */
-    proratedUnitPrice: Scalars['Int'];
-    /** The proratedUnitPrice including tax */
-    proratedUnitPriceWithTax: Scalars['Int'];
-    quantity: Scalars['Int'];
-    items: Array<OrderItem>;
-    taxRate: Scalars['Float'];
+    discountedUnitPriceWithTax: Scalars['Money'];
+    discounts: Array<Discount>;
+    featuredAsset?: Maybe<Asset>;
+    fulfillmentLines?: Maybe<Array<FulfillmentLine>>;
+    id: Scalars['ID'];
     /** The total price of the line excluding tax and discounts. */
-    linePrice: Scalars['Int'];
+    linePrice: Scalars['Money'];
     /** The total price of the line including tax but excluding discounts. */
-    linePriceWithTax: Scalars['Int'];
-    /** The price of the line including discounts, excluding tax */
-    discountedLinePrice: Scalars['Int'];
-    /** The price of the line including discounts and tax */
-    discountedLinePriceWithTax: Scalars['Int'];
+    linePriceWithTax: Scalars['Money'];
+    /** The total tax on this line */
+    lineTax: Scalars['Money'];
+    order: Order;
+    /** The quantity at the time the Order was placed */
+    orderPlacedQuantity: Scalars['Int'];
+    productVariant: ProductVariant;
     /**
      * The actual line price, taking into account both item discounts _and_ prorated (proportionally-distributed)
      * Order-level discounts. This value is the true economic value of the OrderLine, and is used in tax
      * and refund calculations.
      */
-    proratedLinePrice: Scalars['Int'];
+    proratedLinePrice: Scalars['Money'];
     /** The proratedLinePrice including tax */
-    proratedLinePriceWithTax: Scalars['Int'];
-    /** The total tax on this line */
-    lineTax: Scalars['Int'];
-    discounts: Array<Discount>;
+    proratedLinePriceWithTax: Scalars['Money'];
+    /**
+     * The actual unit price, taking into account both item discounts _and_ prorated (proportionally-distributed)
+     * Order-level discounts. This value is the true economic value of the OrderItem, and is used in tax
+     * and refund calculations.
+     */
+    proratedUnitPrice: Scalars['Money'];
+    /** The proratedUnitPrice including tax */
+    proratedUnitPriceWithTax: Scalars['Money'];
+    quantity: Scalars['Int'];
     taxLines: Array<TaxLine>;
-    order: Order;
-    fulfillments?: Maybe<Array<Fulfillment>>;
-    customFields?: Maybe<Scalars['JSON']>;
+    taxRate: Scalars['Float'];
+    /** The price of a single unit, excluding tax and discounts */
+    unitPrice: Scalars['Money'];
+    /** Non-zero if the unitPrice has changed since it was initially added to Order */
+    unitPriceChangeSinceAdded: Scalars['Money'];
+    /** The price of a single unit, including tax but excluding discounts */
+    unitPriceWithTax: Scalars['Money'];
+    /** Non-zero if the unitPriceWithTax has changed since it was initially added to Order */
+    unitPriceWithTaxChangeSinceAdded: Scalars['Money'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type OrderList = PaginatedList & {
+export type OrderList = PaginatedList & {
     __typename?: 'OrderList';
     items: Array<Order>;
     totalItems: Scalars['Int'];
 };
-export declare type OrderListOptions = {
-    /** Skips the first n results, for use in pagination */
-    skip?: Maybe<Scalars['Int']>;
-    /** Takes n results, for use in pagination */
-    take?: Maybe<Scalars['Int']>;
-    /** Specifies which properties to sort the results by */
-    sort?: Maybe<OrderSortParameter>;
+export type OrderListOptions = {
     /** Allows the results to be filtered */
-    filter?: Maybe<OrderFilterParameter>;
+    filter?: InputMaybe<OrderFilterParameter>;
     /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
-    filterOperator?: Maybe<LogicalOperator>;
+    filterOperator?: InputMaybe<LogicalOperator>;
+    /** Skips the first n results, for use in pagination */
+    skip?: InputMaybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: InputMaybe<OrderSortParameter>;
+    /** Takes n results, for use in pagination */
+    take?: InputMaybe<Scalars['Int']>;
 };
 /** Returned when attempting to modify the contents of an Order that is not in the `AddingItems` state. */
-export declare type OrderModificationError = ErrorResult & {
+export type OrderModificationError = ErrorResult & {
     __typename?: 'OrderModificationError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
 /** Returned when attempting to add a Payment to an Order that is not in the `ArrangingPayment` state. */
-export declare type OrderPaymentStateError = ErrorResult & {
+export type OrderPaymentStateError = ErrorResult & {
     __typename?: 'OrderPaymentStateError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
-export declare type OrderSortParameter = {
-    id?: Maybe<SortOrder>;
-    createdAt?: Maybe<SortOrder>;
-    updatedAt?: Maybe<SortOrder>;
-    orderPlacedAt?: Maybe<SortOrder>;
-    code?: Maybe<SortOrder>;
-    state?: Maybe<SortOrder>;
-    totalQuantity?: Maybe<SortOrder>;
-    subTotal?: Maybe<SortOrder>;
-    subTotalWithTax?: Maybe<SortOrder>;
-    shipping?: Maybe<SortOrder>;
-    shippingWithTax?: Maybe<SortOrder>;
-    total?: Maybe<SortOrder>;
-    totalWithTax?: Maybe<SortOrder>;
+export type OrderSortParameter = {
+    code?: InputMaybe<SortOrder>;
+    createdAt?: InputMaybe<SortOrder>;
+    id?: InputMaybe<SortOrder>;
+    orderPlacedAt?: InputMaybe<SortOrder>;
+    shipping?: InputMaybe<SortOrder>;
+    shippingWithTax?: InputMaybe<SortOrder>;
+    state?: InputMaybe<SortOrder>;
+    subTotal?: InputMaybe<SortOrder>;
+    subTotalWithTax?: InputMaybe<SortOrder>;
+    total?: InputMaybe<SortOrder>;
+    totalQuantity?: InputMaybe<SortOrder>;
+    totalWithTax?: InputMaybe<SortOrder>;
+    updatedAt?: InputMaybe<SortOrder>;
 };
 /** Returned if there is an error in transitioning the Order state */
-export declare type OrderStateTransitionError = ErrorResult & {
+export type OrderStateTransitionError = ErrorResult & {
     __typename?: 'OrderStateTransitionError';
     errorCode: ErrorCode;
-    message: Scalars['String'];
-    transitionError: Scalars['String'];
     fromState: Scalars['String'];
+    message: Scalars['String'];
     toState: Scalars['String'];
+    transitionError: Scalars['String'];
 };
 /**
  * A summary of the taxes being applied to this order, grouped
  * by taxRate.
  */
-export declare type OrderTaxSummary = {
+export type OrderTaxSummary = {
     __typename?: 'OrderTaxSummary';
     /** A description of this tax */
     description: Scalars['String'];
+    /** The total net price or OrderItems to which this taxRate applies */
+    taxBase: Scalars['Money'];
     /** The taxRate as a percentage */
     taxRate: Scalars['Float'];
-    /** The total net price or OrderItems to which this taxRate applies */
-    taxBase: Scalars['Int'];
     /** The total tax being applied to the Order at this taxRate */
-    taxTotal: Scalars['Int'];
+    taxTotal: Scalars['Money'];
 };
-export declare type PaginatedList = {
+export declare enum OrderType {
+    Aggregate = "Aggregate",
+    Regular = "Regular",
+    Seller = "Seller"
+}
+export type PaginatedList = {
     items: Array<Node>;
     totalItems: Scalars['Int'];
 };
 /** Returned when attempting to verify a customer account with a password, when a password has already been set. */
-export declare type PasswordAlreadySetError = ErrorResult & {
+export type PasswordAlreadySetError = ErrorResult & {
     __typename?: 'PasswordAlreadySetError';
     errorCode: ErrorCode;
     message: Scalars['String'];
@@ -2004,7 +2047,7 @@ export declare type PasswordAlreadySetError = ErrorResult & {
  * Returned if the token used to reset a Customer's password is valid, but has
  * expired according to the `verificationTokenDuration` setting in the AuthOptions.
  */
-export declare type PasswordResetTokenExpiredError = ErrorResult & {
+export type PasswordResetTokenExpiredError = ErrorResult & {
     __typename?: 'PasswordResetTokenExpiredError';
     errorCode: ErrorCode;
     message: Scalars['String'];
@@ -2013,78 +2056,88 @@ export declare type PasswordResetTokenExpiredError = ErrorResult & {
  * Returned if the token used to reset a Customer's password is either
  * invalid or does not match any expected tokens.
  */
-export declare type PasswordResetTokenInvalidError = ErrorResult & {
+export type PasswordResetTokenInvalidError = ErrorResult & {
     __typename?: 'PasswordResetTokenInvalidError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
 /** Returned when attempting to register or verify a customer account where the given password fails password validation. */
-export declare type PasswordValidationError = ErrorResult & {
+export type PasswordValidationError = ErrorResult & {
     __typename?: 'PasswordValidationError';
     errorCode: ErrorCode;
     message: Scalars['String'];
     validationErrorMessage: Scalars['String'];
 };
-export declare type Payment = Node & {
+export type Payment = Node & {
     __typename?: 'Payment';
-    id: Scalars['ID'];
+    amount: Scalars['Money'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    errorMessage?: Maybe<Scalars['String']>;
+    id: Scalars['ID'];
+    metadata?: Maybe<Scalars['JSON']>;
     method: Scalars['String'];
-    amount: Scalars['Int'];
+    refunds: Array<Refund>;
     state: Scalars['String'];
     transactionId?: Maybe<Scalars['String']>;
-    errorMessage?: Maybe<Scalars['String']>;
-    refunds: Array<Refund>;
-    metadata?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
 };
 /** Returned when a Payment is declined by the payment provider. */
-export declare type PaymentDeclinedError = ErrorResult & {
+export type PaymentDeclinedError = ErrorResult & {
     __typename?: 'PaymentDeclinedError';
     errorCode: ErrorCode;
     message: Scalars['String'];
     paymentErrorMessage: Scalars['String'];
 };
 /** Returned when a Payment fails due to an error. */
-export declare type PaymentFailedError = ErrorResult & {
+export type PaymentFailedError = ErrorResult & {
     __typename?: 'PaymentFailedError';
     errorCode: ErrorCode;
     message: Scalars['String'];
     paymentErrorMessage: Scalars['String'];
 };
 /** Passed as input to the `addPaymentToOrder` mutation. */
-export declare type PaymentInput = {
-    /** This field should correspond to the `code` property of a PaymentMethod. */
-    method: Scalars['String'];
+export type PaymentInput = {
     /**
      * This field should contain arbitrary data passed to the specified PaymentMethodHandler's `createPayment()` method
      * as the "metadata" argument. For example, it could contain an ID for the payment and other
      * data generated by the payment provider.
      */
     metadata: Scalars['JSON'];
+    /** This field should correspond to the `code` property of a PaymentMethod. */
+    method: Scalars['String'];
 };
-export declare type PaymentMethod = Node & {
+export type PaymentMethod = Node & {
     __typename?: 'PaymentMethod';
-    id: Scalars['ID'];
-    createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    name: Scalars['String'];
+    checker?: Maybe<ConfigurableOperation>;
     code: Scalars['String'];
+    createdAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
     description: Scalars['String'];
     enabled: Scalars['Boolean'];
-    checker?: Maybe<ConfigurableOperation>;
     handler: ConfigurableOperation;
-    customFields?: Maybe<Scalars['JSON']>;
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    translations: Array<PaymentMethodTranslation>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type PaymentMethodQuote = {
+export type PaymentMethodQuote = {
     __typename?: 'PaymentMethodQuote';
-    id: Scalars['ID'];
     code: Scalars['String'];
-    name: Scalars['String'];
+    customFields?: Maybe<Scalars['JSON']>;
     description: Scalars['String'];
-    isEligible: Scalars['Boolean'];
     eligibilityMessage?: Maybe<Scalars['String']>;
-    customFields?: Maybe<Scalars['JSON']>;
+    id: Scalars['ID'];
+    isEligible: Scalars['Boolean'];
+    name: Scalars['String'];
+};
+export type PaymentMethodTranslation = {
+    __typename?: 'PaymentMethodTranslation';
+    createdAt: Scalars['DateTime'];
+    description: Scalars['String'];
+    id: Scalars['ID'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
 /**
  * @description
@@ -2121,383 +2174,402 @@ export declare type PaymentMethodQuote = {
 export declare enum Permission {
     /** Authenticated means simply that the user is logged in */
     Authenticated = "Authenticated",
-    /** SuperAdmin has unrestricted access to all operations */
-    SuperAdmin = "SuperAdmin",
-    /** Owner means the user owns this entity, e.g. a Customer's own Order */
-    Owner = "Owner",
-    /** Public means any unauthenticated user may perform the operation */
-    Public = "Public",
-    /** Grants permission to update GlobalSettings */
-    UpdateGlobalSettings = "UpdateGlobalSettings",
+    /** Grants permission to create Administrator */
+    CreateAdministrator = "CreateAdministrator",
+    /** Grants permission to create Asset */
+    CreateAsset = "CreateAsset",
     /** Grants permission to create Products, Facets, Assets, Collections */
     CreateCatalog = "CreateCatalog",
-    /** Grants permission to read Products, Facets, Assets, Collections */
-    ReadCatalog = "ReadCatalog",
-    /** Grants permission to update Products, Facets, Assets, Collections */
-    UpdateCatalog = "UpdateCatalog",
-    /** Grants permission to delete Products, Facets, Assets, Collections */
-    DeleteCatalog = "DeleteCatalog",
+    /** Grants permission to create Channel */
+    CreateChannel = "CreateChannel",
+    /** Grants permission to create Collection */
+    CreateCollection = "CreateCollection",
+    /** Grants permission to create Country */
+    CreateCountry = "CreateCountry",
+    /** Grants permission to create Customer */
+    CreateCustomer = "CreateCustomer",
+    /** Grants permission to create CustomerGroup */
+    CreateCustomerGroup = "CreateCustomerGroup",
+    /** Grants permission to create Facet */
+    CreateFacet = "CreateFacet",
+    /** Grants permission to create Order */
+    CreateOrder = "CreateOrder",
+    /** Grants permission to create PaymentMethod */
+    CreatePaymentMethod = "CreatePaymentMethod",
+    /** Grants permission to create Product */
+    CreateProduct = "CreateProduct",
+    /** Grants permission to create Promotion */
+    CreatePromotion = "CreatePromotion",
+    /** Grants permission to create Seller */
+    CreateSeller = "CreateSeller",
     /** Grants permission to create PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
     CreateSettings = "CreateSettings",
-    /** Grants permission to read PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
-    ReadSettings = "ReadSettings",
-    /** Grants permission to update PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
-    UpdateSettings = "UpdateSettings",
-    /** Grants permission to delete PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
-    DeleteSettings = "DeleteSettings",
-    /** Grants permission to create Administrator */
-    CreateAdministrator = "CreateAdministrator",
-    /** Grants permission to read Administrator */
-    ReadAdministrator = "ReadAdministrator",
-    /** Grants permission to update Administrator */
-    UpdateAdministrator = "UpdateAdministrator",
+    /** Grants permission to create ShippingMethod */
+    CreateShippingMethod = "CreateShippingMethod",
+    /** Grants permission to create System */
+    CreateSystem = "CreateSystem",
+    /** Grants permission to create Tag */
+    CreateTag = "CreateTag",
+    /** Grants permission to create TaxCategory */
+    CreateTaxCategory = "CreateTaxCategory",
+    /** Grants permission to create TaxRate */
+    CreateTaxRate = "CreateTaxRate",
+    /** Grants permission to create Zone */
+    CreateZone = "CreateZone",
     /** Grants permission to delete Administrator */
     DeleteAdministrator = "DeleteAdministrator",
-    /** Grants permission to create Asset */
-    CreateAsset = "CreateAsset",
-    /** Grants permission to read Asset */
-    ReadAsset = "ReadAsset",
-    /** Grants permission to update Asset */
-    UpdateAsset = "UpdateAsset",
     /** Grants permission to delete Asset */
     DeleteAsset = "DeleteAsset",
-    /** Grants permission to create Channel */
-    CreateChannel = "CreateChannel",
-    /** Grants permission to read Channel */
-    ReadChannel = "ReadChannel",
-    /** Grants permission to update Channel */
-    UpdateChannel = "UpdateChannel",
+    /** Grants permission to delete Products, Facets, Assets, Collections */
+    DeleteCatalog = "DeleteCatalog",
     /** Grants permission to delete Channel */
     DeleteChannel = "DeleteChannel",
-    /** Grants permission to create Collection */
-    CreateCollection = "CreateCollection",
-    /** Grants permission to read Collection */
-    ReadCollection = "ReadCollection",
-    /** Grants permission to update Collection */
-    UpdateCollection = "UpdateCollection",
     /** Grants permission to delete Collection */
     DeleteCollection = "DeleteCollection",
-    /** Grants permission to create Country */
-    CreateCountry = "CreateCountry",
-    /** Grants permission to read Country */
-    ReadCountry = "ReadCountry",
-    /** Grants permission to update Country */
-    UpdateCountry = "UpdateCountry",
     /** Grants permission to delete Country */
     DeleteCountry = "DeleteCountry",
-    /** Grants permission to create Customer */
-    CreateCustomer = "CreateCustomer",
-    /** Grants permission to read Customer */
-    ReadCustomer = "ReadCustomer",
-    /** Grants permission to update Customer */
-    UpdateCustomer = "UpdateCustomer",
     /** Grants permission to delete Customer */
     DeleteCustomer = "DeleteCustomer",
-    /** Grants permission to create CustomerGroup */
-    CreateCustomerGroup = "CreateCustomerGroup",
-    /** Grants permission to read CustomerGroup */
-    ReadCustomerGroup = "ReadCustomerGroup",
-    /** Grants permission to update CustomerGroup */
-    UpdateCustomerGroup = "UpdateCustomerGroup",
     /** Grants permission to delete CustomerGroup */
     DeleteCustomerGroup = "DeleteCustomerGroup",
-    /** Grants permission to create Facet */
-    CreateFacet = "CreateFacet",
-    /** Grants permission to read Facet */
-    ReadFacet = "ReadFacet",
-    /** Grants permission to update Facet */
-    UpdateFacet = "UpdateFacet",
     /** Grants permission to delete Facet */
     DeleteFacet = "DeleteFacet",
-    /** Grants permission to create Order */
-    CreateOrder = "CreateOrder",
-    /** Grants permission to read Order */
-    ReadOrder = "ReadOrder",
-    /** Grants permission to update Order */
-    UpdateOrder = "UpdateOrder",
     /** Grants permission to delete Order */
     DeleteOrder = "DeleteOrder",
-    /** Grants permission to create PaymentMethod */
-    CreatePaymentMethod = "CreatePaymentMethod",
-    /** Grants permission to read PaymentMethod */
-    ReadPaymentMethod = "ReadPaymentMethod",
-    /** Grants permission to update PaymentMethod */
-    UpdatePaymentMethod = "UpdatePaymentMethod",
     /** Grants permission to delete PaymentMethod */
     DeletePaymentMethod = "DeletePaymentMethod",
-    /** Grants permission to create Product */
-    CreateProduct = "CreateProduct",
-    /** Grants permission to read Product */
-    ReadProduct = "ReadProduct",
-    /** Grants permission to update Product */
-    UpdateProduct = "UpdateProduct",
     /** Grants permission to delete Product */
     DeleteProduct = "DeleteProduct",
-    /** Grants permission to create Promotion */
-    CreatePromotion = "CreatePromotion",
-    /** Grants permission to read Promotion */
-    ReadPromotion = "ReadPromotion",
-    /** Grants permission to update Promotion */
-    UpdatePromotion = "UpdatePromotion",
     /** Grants permission to delete Promotion */
     DeletePromotion = "DeletePromotion",
-    /** Grants permission to create ShippingMethod */
-    CreateShippingMethod = "CreateShippingMethod",
-    /** Grants permission to read ShippingMethod */
-    ReadShippingMethod = "ReadShippingMethod",
-    /** Grants permission to update ShippingMethod */
-    UpdateShippingMethod = "UpdateShippingMethod",
+    /** Grants permission to delete Seller */
+    DeleteSeller = "DeleteSeller",
+    /** Grants permission to delete PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
+    DeleteSettings = "DeleteSettings",
     /** Grants permission to delete ShippingMethod */
     DeleteShippingMethod = "DeleteShippingMethod",
-    /** Grants permission to create Tag */
-    CreateTag = "CreateTag",
-    /** Grants permission to read Tag */
-    ReadTag = "ReadTag",
-    /** Grants permission to update Tag */
-    UpdateTag = "UpdateTag",
+    /** Grants permission to delete System */
+    DeleteSystem = "DeleteSystem",
     /** Grants permission to delete Tag */
     DeleteTag = "DeleteTag",
-    /** Grants permission to create TaxCategory */
-    CreateTaxCategory = "CreateTaxCategory",
-    /** Grants permission to read TaxCategory */
-    ReadTaxCategory = "ReadTaxCategory",
-    /** Grants permission to update TaxCategory */
-    UpdateTaxCategory = "UpdateTaxCategory",
     /** Grants permission to delete TaxCategory */
     DeleteTaxCategory = "DeleteTaxCategory",
-    /** Grants permission to create TaxRate */
-    CreateTaxRate = "CreateTaxRate",
-    /** Grants permission to read TaxRate */
-    ReadTaxRate = "ReadTaxRate",
-    /** Grants permission to update TaxRate */
-    UpdateTaxRate = "UpdateTaxRate",
     /** Grants permission to delete TaxRate */
     DeleteTaxRate = "DeleteTaxRate",
-    /** Grants permission to create System */
-    CreateSystem = "CreateSystem",
+    /** Grants permission to delete Zone */
+    DeleteZone = "DeleteZone",
+    /** Owner means the user owns this entity, e.g. a Customer's own Order */
+    Owner = "Owner",
+    /** Public means any unauthenticated user may perform the operation */
+    Public = "Public",
+    /** Grants permission to read Administrator */
+    ReadAdministrator = "ReadAdministrator",
+    /** Grants permission to read Asset */
+    ReadAsset = "ReadAsset",
+    /** Grants permission to read Products, Facets, Assets, Collections */
+    ReadCatalog = "ReadCatalog",
+    /** Grants permission to read Channel */
+    ReadChannel = "ReadChannel",
+    /** Grants permission to read Collection */
+    ReadCollection = "ReadCollection",
+    /** Grants permission to read Country */
+    ReadCountry = "ReadCountry",
+    /** Grants permission to read Customer */
+    ReadCustomer = "ReadCustomer",
+    /** Grants permission to read CustomerGroup */
+    ReadCustomerGroup = "ReadCustomerGroup",
+    /** Grants permission to read Facet */
+    ReadFacet = "ReadFacet",
+    /** Grants permission to read Order */
+    ReadOrder = "ReadOrder",
+    /** Grants permission to read PaymentMethod */
+    ReadPaymentMethod = "ReadPaymentMethod",
+    /** Grants permission to read Product */
+    ReadProduct = "ReadProduct",
+    /** Grants permission to read Promotion */
+    ReadPromotion = "ReadPromotion",
+    /** Grants permission to read Seller */
+    ReadSeller = "ReadSeller",
+    /** Grants permission to read PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
+    ReadSettings = "ReadSettings",
+    /** Grants permission to read ShippingMethod */
+    ReadShippingMethod = "ReadShippingMethod",
     /** Grants permission to read System */
     ReadSystem = "ReadSystem",
-    /** Grants permission to update System */
-    UpdateSystem = "UpdateSystem",
-    /** Grants permission to delete System */
-    DeleteSystem = "DeleteSystem",
-    /** Grants permission to create Zone */
-    CreateZone = "CreateZone",
+    /** Grants permission to read Tag */
+    ReadTag = "ReadTag",
+    /** Grants permission to read TaxCategory */
+    ReadTaxCategory = "ReadTaxCategory",
+    /** Grants permission to read TaxRate */
+    ReadTaxRate = "ReadTaxRate",
     /** Grants permission to read Zone */
     ReadZone = "ReadZone",
+    /** SuperAdmin has unrestricted access to all operations */
+    SuperAdmin = "SuperAdmin",
+    /** Grants permission to update Administrator */
+    UpdateAdministrator = "UpdateAdministrator",
+    /** Grants permission to update Asset */
+    UpdateAsset = "UpdateAsset",
+    /** Grants permission to update Products, Facets, Assets, Collections */
+    UpdateCatalog = "UpdateCatalog",
+    /** Grants permission to update Channel */
+    UpdateChannel = "UpdateChannel",
+    /** Grants permission to update Collection */
+    UpdateCollection = "UpdateCollection",
+    /** Grants permission to update Country */
+    UpdateCountry = "UpdateCountry",
+    /** Grants permission to update Customer */
+    UpdateCustomer = "UpdateCustomer",
+    /** Grants permission to update CustomerGroup */
+    UpdateCustomerGroup = "UpdateCustomerGroup",
+    /** Grants permission to update Facet */
+    UpdateFacet = "UpdateFacet",
+    /** Grants permission to update GlobalSettings */
+    UpdateGlobalSettings = "UpdateGlobalSettings",
+    /** Grants permission to update Order */
+    UpdateOrder = "UpdateOrder",
+    /** Grants permission to update PaymentMethod */
+    UpdatePaymentMethod = "UpdatePaymentMethod",
+    /** Grants permission to update Product */
+    UpdateProduct = "UpdateProduct",
+    /** Grants permission to update Promotion */
+    UpdatePromotion = "UpdatePromotion",
+    /** Grants permission to update Seller */
+    UpdateSeller = "UpdateSeller",
+    /** Grants permission to update PaymentMethods, ShippingMethods, TaxCategories, TaxRates, Zones, Countries, System & GlobalSettings */
+    UpdateSettings = "UpdateSettings",
+    /** Grants permission to update ShippingMethod */
+    UpdateShippingMethod = "UpdateShippingMethod",
+    /** Grants permission to update System */
+    UpdateSystem = "UpdateSystem",
+    /** Grants permission to update Tag */
+    UpdateTag = "UpdateTag",
+    /** Grants permission to update TaxCategory */
+    UpdateTaxCategory = "UpdateTaxCategory",
+    /** Grants permission to update TaxRate */
+    UpdateTaxRate = "UpdateTaxRate",
     /** Grants permission to update Zone */
-    UpdateZone = "UpdateZone",
-    /** Grants permission to delete Zone */
-    DeleteZone = "DeleteZone"
+    UpdateZone = "UpdateZone"
 }
 /** The price range where the result has more than one price */
-export declare type PriceRange = {
+export type PriceRange = {
     __typename?: 'PriceRange';
-    min: Scalars['Int'];
-    max: Scalars['Int'];
+    max: Scalars['Money'];
+    min: Scalars['Money'];
 };
-export declare type Product = Node & {
+export type Product = Node & {
     __typename?: 'Product';
-    id: Scalars['ID'];
+    assets: Array<Asset>;
+    collections: Array<Collection>;
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
+    description: Scalars['String'];
+    facetValues: Array<FacetValue>;
+    featuredAsset?: Maybe<Asset>;
+    id: Scalars['ID'];
     languageCode: LanguageCode;
     name: Scalars['String'];
+    optionGroups: Array<ProductOptionGroup>;
     slug: Scalars['String'];
-    description: Scalars['String'];
-    featuredAsset?: Maybe<Asset>;
-    assets: Array<Asset>;
-    /** Returns all ProductVariants */
-    variants: Array<ProductVariant>;
+    translations: Array<ProductTranslation>;
+    updatedAt: Scalars['DateTime'];
     /** Returns a paginated, sortable, filterable list of ProductVariants */
     variantList: ProductVariantList;
-    optionGroups: Array<ProductOptionGroup>;
-    facetValues: Array<FacetValue>;
-    translations: Array<ProductTranslation>;
-    collections: Array<Collection>;
-    customFields?: Maybe<Scalars['JSON']>;
+    /** Returns all ProductVariants */
+    variants: Array<ProductVariant>;
 };
-export declare type ProductVariantListArgs = {
-    options?: Maybe<ProductVariantListOptions>;
+export type ProductVariantListArgs = {
+    options?: InputMaybe<ProductVariantListOptions>;
 };
-export declare type ProductFilterParameter = {
-    id?: Maybe<IdOperators>;
-    createdAt?: Maybe<DateOperators>;
-    updatedAt?: Maybe<DateOperators>;
-    languageCode?: Maybe<StringOperators>;
-    name?: Maybe<StringOperators>;
-    slug?: Maybe<StringOperators>;
-    description?: Maybe<StringOperators>;
+export type ProductFilterParameter = {
+    createdAt?: InputMaybe<DateOperators>;
+    description?: InputMaybe<StringOperators>;
+    id?: InputMaybe<IdOperators>;
+    languageCode?: InputMaybe<StringOperators>;
+    name?: InputMaybe<StringOperators>;
+    slug?: InputMaybe<StringOperators>;
+    updatedAt?: InputMaybe<DateOperators>;
 };
-export declare type ProductList = PaginatedList & {
+export type ProductList = PaginatedList & {
     __typename?: 'ProductList';
     items: Array<Product>;
     totalItems: Scalars['Int'];
 };
-export declare type ProductListOptions = {
-    /** Skips the first n results, for use in pagination */
-    skip?: Maybe<Scalars['Int']>;
-    /** Takes n results, for use in pagination */
-    take?: Maybe<Scalars['Int']>;
-    /** Specifies which properties to sort the results by */
-    sort?: Maybe<ProductSortParameter>;
+export type ProductListOptions = {
     /** Allows the results to be filtered */
-    filter?: Maybe<ProductFilterParameter>;
+    filter?: InputMaybe<ProductFilterParameter>;
     /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
-    filterOperator?: Maybe<LogicalOperator>;
+    filterOperator?: InputMaybe<LogicalOperator>;
+    /** Skips the first n results, for use in pagination */
+    skip?: InputMaybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: InputMaybe<ProductSortParameter>;
+    /** Takes n results, for use in pagination */
+    take?: InputMaybe<Scalars['Int']>;
 };
-export declare type ProductOption = Node & {
+export type ProductOption = Node & {
     __typename?: 'ProductOption';
-    id: Scalars['ID'];
+    code: Scalars['String'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
+    group: ProductOptionGroup;
+    groupId: Scalars['ID'];
+    id: Scalars['ID'];
     languageCode: LanguageCode;
-    code: Scalars['String'];
     name: Scalars['String'];
-    groupId: Scalars['ID'];
-    group: ProductOptionGroup;
     translations: Array<ProductOptionTranslation>;
-    customFields?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type ProductOptionGroup = Node & {
+export type ProductOptionGroup = Node & {
     __typename?: 'ProductOptionGroup';
-    id: Scalars['ID'];
+    code: Scalars['String'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
+    id: Scalars['ID'];
     languageCode: LanguageCode;
-    code: Scalars['String'];
     name: Scalars['String'];
     options: Array<ProductOption>;
     translations: Array<ProductOptionGroupTranslation>;
-    customFields?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type ProductOptionGroupTranslation = {
+export type ProductOptionGroupTranslation = {
     __typename?: 'ProductOptionGroupTranslation';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    id: Scalars['ID'];
     languageCode: LanguageCode;
     name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type ProductOptionTranslation = {
+export type ProductOptionTranslation = {
     __typename?: 'ProductOptionTranslation';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    id: Scalars['ID'];
     languageCode: LanguageCode;
     name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type ProductSortParameter = {
-    id?: Maybe<SortOrder>;
-    createdAt?: Maybe<SortOrder>;
-    updatedAt?: Maybe<SortOrder>;
-    name?: Maybe<SortOrder>;
-    slug?: Maybe<SortOrder>;
-    description?: Maybe<SortOrder>;
+export type ProductSortParameter = {
+    createdAt?: InputMaybe<SortOrder>;
+    description?: InputMaybe<SortOrder>;
+    id?: InputMaybe<SortOrder>;
+    name?: InputMaybe<SortOrder>;
+    slug?: InputMaybe<SortOrder>;
+    updatedAt?: InputMaybe<SortOrder>;
 };
-export declare type ProductTranslation = {
+export type ProductTranslation = {
     __typename?: 'ProductTranslation';
+    createdAt: Scalars['DateTime'];
+    description: Scalars['String'];
     id: Scalars['ID'];
-    createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
     languageCode: LanguageCode;
     name: Scalars['String'];
     slug: Scalars['String'];
-    description: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type ProductVariant = Node & {
+export type ProductVariant = Node & {
     __typename?: 'ProductVariant';
+    assets: Array<Asset>;
+    createdAt: Scalars['DateTime'];
+    currencyCode: CurrencyCode;
+    customFields?: Maybe<Scalars['JSON']>;
+    facetValues: Array<FacetValue>;
+    featuredAsset?: Maybe<Asset>;
     id: Scalars['ID'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+    options: Array<ProductOption>;
+    price: Scalars['Money'];
+    priceWithTax: Scalars['Money'];
     product: Product;
     productId: Scalars['ID'];
-    createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    languageCode: LanguageCode;
     sku: Scalars['String'];
-    name: Scalars['String'];
-    featuredAsset?: Maybe<Asset>;
-    assets: Array<Asset>;
-    price: Scalars['Int'];
-    currencyCode: CurrencyCode;
-    priceWithTax: Scalars['Int'];
     stockLevel: Scalars['String'];
-    taxRateApplied: TaxRate;
     taxCategory: TaxCategory;
-    options: Array<ProductOption>;
-    facetValues: Array<FacetValue>;
+    taxRateApplied: TaxRate;
     translations: Array<ProductVariantTranslation>;
-    customFields?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type ProductVariantFilterParameter = {
-    id?: Maybe<IdOperators>;
-    productId?: Maybe<IdOperators>;
-    createdAt?: Maybe<DateOperators>;
-    updatedAt?: Maybe<DateOperators>;
-    languageCode?: Maybe<StringOperators>;
-    sku?: Maybe<StringOperators>;
-    name?: Maybe<StringOperators>;
-    price?: Maybe<NumberOperators>;
-    currencyCode?: Maybe<StringOperators>;
-    priceWithTax?: Maybe<NumberOperators>;
-    stockLevel?: Maybe<StringOperators>;
-};
-export declare type ProductVariantList = PaginatedList & {
+export type ProductVariantFilterParameter = {
+    createdAt?: InputMaybe<DateOperators>;
+    currencyCode?: InputMaybe<StringOperators>;
+    id?: InputMaybe<IdOperators>;
+    languageCode?: InputMaybe<StringOperators>;
+    name?: InputMaybe<StringOperators>;
+    price?: InputMaybe<NumberOperators>;
+    priceWithTax?: InputMaybe<NumberOperators>;
+    productId?: InputMaybe<IdOperators>;
+    sku?: InputMaybe<StringOperators>;
+    stockLevel?: InputMaybe<StringOperators>;
+    updatedAt?: InputMaybe<DateOperators>;
+};
+export type ProductVariantList = PaginatedList & {
     __typename?: 'ProductVariantList';
     items: Array<ProductVariant>;
     totalItems: Scalars['Int'];
 };
-export declare type ProductVariantListOptions = {
-    /** Skips the first n results, for use in pagination */
-    skip?: Maybe<Scalars['Int']>;
-    /** Takes n results, for use in pagination */
-    take?: Maybe<Scalars['Int']>;
-    /** Specifies which properties to sort the results by */
-    sort?: Maybe<ProductVariantSortParameter>;
+export type ProductVariantListOptions = {
     /** Allows the results to be filtered */
-    filter?: Maybe<ProductVariantFilterParameter>;
+    filter?: InputMaybe<ProductVariantFilterParameter>;
     /** Specifies whether multiple "filter" arguments should be combines with a logical AND or OR operation. Defaults to AND. */
-    filterOperator?: Maybe<LogicalOperator>;
-};
-export declare type ProductVariantSortParameter = {
-    id?: Maybe<SortOrder>;
-    productId?: Maybe<SortOrder>;
-    createdAt?: Maybe<SortOrder>;
-    updatedAt?: Maybe<SortOrder>;
-    sku?: Maybe<SortOrder>;
-    name?: Maybe<SortOrder>;
-    price?: Maybe<SortOrder>;
-    priceWithTax?: Maybe<SortOrder>;
-    stockLevel?: Maybe<SortOrder>;
-};
-export declare type ProductVariantTranslation = {
+    filterOperator?: InputMaybe<LogicalOperator>;
+    /** Skips the first n results, for use in pagination */
+    skip?: InputMaybe<Scalars['Int']>;
+    /** Specifies which properties to sort the results by */
+    sort?: InputMaybe<ProductVariantSortParameter>;
+    /** Takes n results, for use in pagination */
+    take?: InputMaybe<Scalars['Int']>;
+};
+export type ProductVariantSortParameter = {
+    createdAt?: InputMaybe<SortOrder>;
+    id?: InputMaybe<SortOrder>;
+    name?: InputMaybe<SortOrder>;
+    price?: InputMaybe<SortOrder>;
+    priceWithTax?: InputMaybe<SortOrder>;
+    productId?: InputMaybe<SortOrder>;
+    sku?: InputMaybe<SortOrder>;
+    stockLevel?: InputMaybe<SortOrder>;
+    updatedAt?: InputMaybe<SortOrder>;
+};
+export type ProductVariantTranslation = {
     __typename?: 'ProductVariantTranslation';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    id: Scalars['ID'];
     languageCode: LanguageCode;
     name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type Promotion = Node & {
+export type Promotion = Node & {
     __typename?: 'Promotion';
-    id: Scalars['ID'];
+    actions: Array<ConfigurableOperation>;
+    conditions: Array<ConfigurableOperation>;
+    couponCode?: Maybe<Scalars['String']>;
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    startsAt?: Maybe<Scalars['DateTime']>;
+    customFields?: Maybe<Scalars['JSON']>;
+    description: Scalars['String'];
+    enabled: Scalars['Boolean'];
     endsAt?: Maybe<Scalars['DateTime']>;
-    couponCode?: Maybe<Scalars['String']>;
-    perCustomerUsageLimit?: Maybe<Scalars['Int']>;
+    id: Scalars['ID'];
     name: Scalars['String'];
-    enabled: Scalars['Boolean'];
-    conditions: Array<ConfigurableOperation>;
-    actions: Array<ConfigurableOperation>;
-    customFields?: Maybe<Scalars['JSON']>;
+    perCustomerUsageLimit?: Maybe<Scalars['Int']>;
+    startsAt?: Maybe<Scalars['DateTime']>;
+    translations: Array<PromotionTranslation>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type PromotionList = PaginatedList & {
+export type PromotionList = PaginatedList & {
     __typename?: 'PromotionList';
     items: Array<Promotion>;
     totalItems: Scalars['Int'];
 };
-export declare type Query = {
+export type PromotionTranslation = {
+    __typename?: 'PromotionTranslation';
+    createdAt: Scalars['DateTime'];
+    description: Scalars['String'];
+    id: Scalars['ID'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
+};
+export type Query = {
     __typename?: 'Query';
     /** The active Channel */
     activeChannel: Channel;
@@ -2547,370 +2619,388 @@ export declare type Query = {
     /** Search Products based on the criteria set by the `SearchInput` */
     search: SearchResponse;
 };
-export declare type QueryCollectionArgs = {
-    id?: Maybe<Scalars['ID']>;
-    slug?: Maybe<Scalars['String']>;
+export type QueryCollectionArgs = {
+    id?: InputMaybe<Scalars['ID']>;
+    slug?: InputMaybe<Scalars['String']>;
 };
-export declare type QueryCollectionsArgs = {
-    options?: Maybe<CollectionListOptions>;
+export type QueryCollectionsArgs = {
+    options?: InputMaybe<CollectionListOptions>;
 };
-export declare type QueryFacetArgs = {
+export type QueryFacetArgs = {
     id: Scalars['ID'];
 };
-export declare type QueryFacetsArgs = {
-    options?: Maybe<FacetListOptions>;
+export type QueryFacetsArgs = {
+    options?: InputMaybe<FacetListOptions>;
 };
-export declare type QueryMolliePaymentMethodsArgs = {
+export type QueryMolliePaymentMethodsArgs = {
     input: MolliePaymentMethodsInput;
 };
-export declare type QueryOrderArgs = {
+export type QueryOrderArgs = {
     id: Scalars['ID'];
 };
-export declare type QueryOrderByCodeArgs = {
+export type QueryOrderByCodeArgs = {
     code: Scalars['String'];
 };
-export declare type QueryProductArgs = {
-    id?: Maybe<Scalars['ID']>;
-    slug?: Maybe<Scalars['String']>;
+export type QueryProductArgs = {
+    id?: InputMaybe<Scalars['ID']>;
+    slug?: InputMaybe<Scalars['String']>;
 };
-export declare type QueryProductsArgs = {
-    options?: Maybe<ProductListOptions>;
+export type QueryProductsArgs = {
+    options?: InputMaybe<ProductListOptions>;
 };
-export declare type QuerySearchArgs = {
+export type QuerySearchArgs = {
     input: SearchInput;
 };
-export declare type RefreshCustomerVerificationResult = Success | NativeAuthStrategyError;
-export declare type Refund = Node & {
+export type RefreshCustomerVerificationResult = NativeAuthStrategyError | Success;
+export type Refund = Node & {
     __typename?: 'Refund';
-    id: Scalars['ID'];
+    adjustment: Scalars['Money'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    items: Scalars['Int'];
-    shipping: Scalars['Int'];
-    adjustment: Scalars['Int'];
-    total: Scalars['Int'];
+    id: Scalars['ID'];
+    items: Scalars['Money'];
+    lines: Array<RefundLine>;
+    metadata?: Maybe<Scalars['JSON']>;
     method?: Maybe<Scalars['String']>;
+    paymentId: Scalars['ID'];
+    reason?: Maybe<Scalars['String']>;
+    shipping: Scalars['Money'];
     state: Scalars['String'];
+    total: Scalars['Money'];
     transactionId?: Maybe<Scalars['String']>;
-    reason?: Maybe<Scalars['String']>;
-    orderItems: Array<OrderItem>;
-    paymentId: Scalars['ID'];
-    metadata?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type RegisterCustomerAccountResult = Success | MissingPasswordError | PasswordValidationError | NativeAuthStrategyError;
-export declare type RegisterCustomerInput = {
+export type RefundLine = {
+    __typename?: 'RefundLine';
+    orderLine: OrderLine;
+    orderLineId: Scalars['ID'];
+    quantity: Scalars['Int'];
+    refund: Refund;
+    refundId: Scalars['ID'];
+};
+export type RegisterCustomerAccountResult = MissingPasswordError | NativeAuthStrategyError | PasswordValidationError | Success;
+export type RegisterCustomerInput = {
     emailAddress: Scalars['String'];
-    title?: Maybe<Scalars['String']>;
-    firstName?: Maybe<Scalars['String']>;
-    lastName?: Maybe<Scalars['String']>;
-    phoneNumber?: Maybe<Scalars['String']>;
-    password?: Maybe<Scalars['String']>;
+    firstName?: InputMaybe<Scalars['String']>;
+    lastName?: InputMaybe<Scalars['String']>;
+    password?: InputMaybe<Scalars['String']>;
+    phoneNumber?: InputMaybe<Scalars['String']>;
+    title?: InputMaybe<Scalars['String']>;
 };
-export declare type RelationCustomFieldConfig = CustomField & {
+export type RelationCustomFieldConfig = CustomField & {
     __typename?: 'RelationCustomFieldConfig';
-    name: Scalars['String'];
-    type: Scalars['String'];
-    list: Scalars['Boolean'];
-    label?: Maybe<Array<LocalizedString>>;
     description?: Maybe<Array<LocalizedString>>;
-    readonly?: Maybe<Scalars['Boolean']>;
+    entity: Scalars['String'];
     internal?: Maybe<Scalars['Boolean']>;
+    label?: Maybe<Array<LocalizedString>>;
+    list: Scalars['Boolean'];
+    name: Scalars['String'];
     nullable?: Maybe<Scalars['Boolean']>;
-    entity: Scalars['String'];
+    readonly?: Maybe<Scalars['Boolean']>;
     scalarFields: Array<Scalars['String']>;
+    type: Scalars['String'];
     ui?: Maybe<Scalars['JSON']>;
 };
-export declare type RemoveOrderItemsResult = Order | OrderModificationError;
-export declare type RequestPasswordResetResult = Success | NativeAuthStrategyError;
-export declare type RequestUpdateCustomerEmailAddressResult = Success | InvalidCredentialsError | EmailAddressConflictError | NativeAuthStrategyError;
-export declare type ResetPasswordResult = CurrentUser | PasswordResetTokenInvalidError | PasswordResetTokenExpiredError | PasswordValidationError | NativeAuthStrategyError | NotVerifiedError;
-export declare type Role = Node & {
+export type RemoveOrderItemsResult = Order | OrderModificationError;
+export type RequestPasswordResetResult = NativeAuthStrategyError | Success;
+export type RequestUpdateCustomerEmailAddressResult = EmailAddressConflictError | InvalidCredentialsError | NativeAuthStrategyError | Success;
+export type ResetPasswordResult = CurrentUser | NativeAuthStrategyError | NotVerifiedError | PasswordResetTokenExpiredError | PasswordResetTokenInvalidError | PasswordValidationError;
+export type Role = Node & {
     __typename?: 'Role';
-    id: Scalars['ID'];
-    createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    channels: Array<Channel>;
     code: Scalars['String'];
+    createdAt: Scalars['DateTime'];
     description: Scalars['String'];
+    id: Scalars['ID'];
     permissions: Array<Permission>;
-    channels: Array<Channel>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type RoleList = PaginatedList & {
+export type RoleList = PaginatedList & {
     __typename?: 'RoleList';
     items: Array<Role>;
     totalItems: Scalars['Int'];
 };
-export declare type SearchInput = {
-    term?: Maybe<Scalars['String']>;
-    facetValueIds?: Maybe<Array<Scalars['ID']>>;
-    facetValueOperator?: Maybe<LogicalOperator>;
-    facetValueFilters?: Maybe<Array<FacetValueFilterInput>>;
-    collectionId?: Maybe<Scalars['ID']>;
-    collectionSlug?: Maybe<Scalars['String']>;
-    groupByProduct?: Maybe<Scalars['Boolean']>;
-    take?: Maybe<Scalars['Int']>;
-    skip?: Maybe<Scalars['Int']>;
-    sort?: Maybe<SearchResultSortParameter>;
-};
-export declare type SearchReindexResponse = {
+export type SearchInput = {
+    collectionId?: InputMaybe<Scalars['ID']>;
+    collectionSlug?: InputMaybe<Scalars['String']>;
+    facetValueFilters?: InputMaybe<Array<FacetValueFilterInput>>;
+    /** @deprecated Use `facetValueFilters` instead */
+    facetValueIds?: InputMaybe<Array<Scalars['ID']>>;
+    /** @deprecated Use `facetValueFilters` instead */
+    facetValueOperator?: InputMaybe<LogicalOperator>;
+    groupByProduct?: InputMaybe<Scalars['Boolean']>;
+    skip?: InputMaybe<Scalars['Int']>;
+    sort?: InputMaybe<SearchResultSortParameter>;
+    take?: InputMaybe<Scalars['Int']>;
+    term?: InputMaybe<Scalars['String']>;
+};
+export type SearchReindexResponse = {
     __typename?: 'SearchReindexResponse';
     success: Scalars['Boolean'];
 };
-export declare type SearchResponse = {
+export type SearchResponse = {
     __typename?: 'SearchResponse';
+    collections: Array<CollectionResult>;
+    facetValues: Array<FacetValueResult>;
     items: Array<SearchResult>;
     totalItems: Scalars['Int'];
-    facetValues: Array<FacetValueResult>;
-    collections: Array<CollectionResult>;
 };
-export declare type SearchResult = {
+export type SearchResult = {
     __typename?: 'SearchResult';
-    sku: Scalars['String'];
-    slug: Scalars['String'];
-    productId: Scalars['ID'];
-    productName: Scalars['String'];
-    productAsset?: Maybe<SearchResultAsset>;
-    productVariantId: Scalars['ID'];
-    productVariantName: Scalars['String'];
-    productVariantAsset?: Maybe<SearchResultAsset>;
-    price: SearchResultPrice;
-    priceWithTax: SearchResultPrice;
+    /** An array of ids of the Collections in which this result appears */
+    collectionIds: Array<Scalars['ID']>;
     currencyCode: CurrencyCode;
     description: Scalars['String'];
     facetIds: Array<Scalars['ID']>;
     facetValueIds: Array<Scalars['ID']>;
-    /** An array of ids of the Collections in which this result appears */
-    collectionIds: Array<Scalars['ID']>;
+    price: SearchResultPrice;
+    priceWithTax: SearchResultPrice;
+    productAsset?: Maybe<SearchResultAsset>;
+    productId: Scalars['ID'];
+    productName: Scalars['String'];
+    productVariantAsset?: Maybe<SearchResultAsset>;
+    productVariantId: Scalars['ID'];
+    productVariantName: Scalars['String'];
     /** A relevance score for the result. Differs between database implementations */
     score: Scalars['Float'];
+    sku: Scalars['String'];
+    slug: Scalars['String'];
 };
-export declare type SearchResultAsset = {
+export type SearchResultAsset = {
     __typename?: 'SearchResultAsset';
+    focalPoint?: Maybe<Coordinate>;
     id: Scalars['ID'];
     preview: Scalars['String'];
-    focalPoint?: Maybe<Coordinate>;
 };
 /** The price of a search result product, either as a range or as a single price */
-export declare type SearchResultPrice = PriceRange | SinglePrice;
-export declare type SearchResultSortParameter = {
-    name?: Maybe<SortOrder>;
-    price?: Maybe<SortOrder>;
-};
-export declare type SetCustomerForOrderResult = Order | AlreadyLoggedInError | EmailAddressConflictError | NoActiveOrderError;
-export declare type SetOrderShippingMethodResult = Order | OrderModificationError | IneligibleShippingMethodError | NoActiveOrderError;
-export declare type ShippingLine = {
+export type SearchResultPrice = PriceRange | SinglePrice;
+export type SearchResultSortParameter = {
+    name?: InputMaybe<SortOrder>;
+    price?: InputMaybe<SortOrder>;
+};
+export type Seller = Node & {
+    __typename?: 'Seller';
+    createdAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
+};
+export type SetCustomerForOrderResult = AlreadyLoggedInError | EmailAddressConflictError | GuestCheckoutError | NoActiveOrderError | Order;
+export type SetOrderShippingMethodResult = IneligibleShippingMethodError | NoActiveOrderError | Order | OrderModificationError;
+export type ShippingLine = {
     __typename?: 'ShippingLine';
+    discountedPrice: Scalars['Money'];
+    discountedPriceWithTax: Scalars['Money'];
+    discounts: Array<Discount>;
     id: Scalars['ID'];
+    price: Scalars['Money'];
+    priceWithTax: Scalars['Money'];
     shippingMethod: ShippingMethod;
-    price: Scalars['Int'];
-    priceWithTax: Scalars['Int'];
-    discountedPrice: Scalars['Int'];
-    discountedPriceWithTax: Scalars['Int'];
-    discounts: Array<Discount>;
 };
-export declare type ShippingMethod = Node & {
+export type ShippingMethod = Node & {
     __typename?: 'ShippingMethod';
-    id: Scalars['ID'];
-    createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    languageCode: LanguageCode;
+    calculator: ConfigurableOperation;
+    checker: ConfigurableOperation;
     code: Scalars['String'];
-    name: Scalars['String'];
+    createdAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
     description: Scalars['String'];
     fulfillmentHandlerCode: Scalars['String'];
-    checker: ConfigurableOperation;
-    calculator: ConfigurableOperation;
+    id: Scalars['ID'];
+    languageCode: LanguageCode;
+    name: Scalars['String'];
     translations: Array<ShippingMethodTranslation>;
-    customFields?: Maybe<Scalars['JSON']>;
+    updatedAt: Scalars['DateTime'];
 };
-export declare type ShippingMethodList = PaginatedList & {
+export type ShippingMethodList = PaginatedList & {
     __typename?: 'ShippingMethodList';
     items: Array<ShippingMethod>;
     totalItems: Scalars['Int'];
 };
-export declare type ShippingMethodQuote = {
+export type ShippingMethodQuote = {
     __typename?: 'ShippingMethodQuote';
-    id: Scalars['ID'];
-    price: Scalars['Int'];
-    priceWithTax: Scalars['Int'];
     code: Scalars['String'];
-    name: Scalars['String'];
+    customFields?: Maybe<Scalars['JSON']>;
     description: Scalars['String'];
+    id: Scalars['ID'];
     /** Any optional metadata returned by the ShippingCalculator in the ShippingCalculationResult */
     metadata?: Maybe<Scalars['JSON']>;
-    customFields?: Maybe<Scalars['JSON']>;
+    name: Scalars['String'];
+    price: Scalars['Money'];
+    priceWithTax: Scalars['Money'];
 };
-export declare type ShippingMethodTranslation = {
+export type ShippingMethodTranslation = {
     __typename?: 'ShippingMethodTranslation';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    description: Scalars['String'];
+    id: Scalars['ID'];
     languageCode: LanguageCode;
     name: Scalars['String'];
-    description: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
 /** The price value where the result has a single price */
-export declare type SinglePrice = {
+export type SinglePrice = {
     __typename?: 'SinglePrice';
-    value: Scalars['Int'];
+    value: Scalars['Money'];
 };
 export declare enum SortOrder {
     ASC = "ASC",
     DESC = "DESC"
 }
-export declare type StringCustomFieldConfig = CustomField & {
+export type StringCustomFieldConfig = CustomField & {
     __typename?: 'StringCustomFieldConfig';
-    name: Scalars['String'];
-    type: Scalars['String'];
-    list: Scalars['Boolean'];
-    length?: Maybe<Scalars['Int']>;
-    label?: Maybe<Array<LocalizedString>>;
     description?: Maybe<Array<LocalizedString>>;
-    readonly?: Maybe<Scalars['Boolean']>;
     internal?: Maybe<Scalars['Boolean']>;
+    label?: Maybe<Array<LocalizedString>>;
+    length?: Maybe<Scalars['Int']>;
+    list: Scalars['Boolean'];
+    name: Scalars['String'];
     nullable?: Maybe<Scalars['Boolean']>;
-    pattern?: Maybe<Scalars['String']>;
     options?: Maybe<Array<StringFieldOption>>;
+    pattern?: Maybe<Scalars['String']>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    type: Scalars['String'];
     ui?: Maybe<Scalars['JSON']>;
 };
-export declare type StringFieldOption = {
+export type StringFieldOption = {
     __typename?: 'StringFieldOption';
-    value: Scalars['String'];
     label?: Maybe<Array<LocalizedString>>;
+    value: Scalars['String'];
 };
 /** Operators for filtering on a list of String fields */
-export declare type StringListOperators = {
+export type StringListOperators = {
     inList: Scalars['String'];
 };
 /** Operators for filtering on a String field */
-export declare type StringOperators = {
-    eq?: Maybe<Scalars['String']>;
-    notEq?: Maybe<Scalars['String']>;
-    contains?: Maybe<Scalars['String']>;
-    notContains?: Maybe<Scalars['String']>;
-    in?: Maybe<Array<Scalars['String']>>;
-    notIn?: Maybe<Array<Scalars['String']>>;
-    regex?: Maybe<Scalars['String']>;
-    isNull?: Maybe<Scalars['Boolean']>;
+export type StringOperators = {
+    contains?: InputMaybe<Scalars['String']>;
+    eq?: InputMaybe<Scalars['String']>;
+    in?: InputMaybe<Array<Scalars['String']>>;
+    isNull?: InputMaybe<Scalars['Boolean']>;
+    notContains?: InputMaybe<Scalars['String']>;
+    notEq?: InputMaybe<Scalars['String']>;
+    notIn?: InputMaybe<Array<Scalars['String']>>;
+    regex?: InputMaybe<Scalars['String']>;
 };
 /** Indicates that an operation succeeded, where we do not want to return any more specific information. */
-export declare type Success = {
+export type Success = {
     __typename?: 'Success';
     success: Scalars['Boolean'];
 };
-export declare type Surcharge = Node & {
+export type Surcharge = Node & {
     __typename?: 'Surcharge';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
     description: Scalars['String'];
+    id: Scalars['ID'];
+    price: Scalars['Money'];
+    priceWithTax: Scalars['Money'];
     sku?: Maybe<Scalars['String']>;
     taxLines: Array<TaxLine>;
-    price: Scalars['Int'];
-    priceWithTax: Scalars['Int'];
     taxRate: Scalars['Float'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type Tag = Node & {
+export type Tag = Node & {
     __typename?: 'Tag';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
+    id: Scalars['ID'];
     updatedAt: Scalars['DateTime'];
     value: Scalars['String'];
 };
-export declare type TagList = PaginatedList & {
+export type TagList = PaginatedList & {
     __typename?: 'TagList';
     items: Array<Tag>;
     totalItems: Scalars['Int'];
 };
-export declare type TaxCategory = Node & {
+export type TaxCategory = Node & {
     __typename?: 'TaxCategory';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    name: Scalars['String'];
-    isDefault: Scalars['Boolean'];
     customFields?: Maybe<Scalars['JSON']>;
+    id: Scalars['ID'];
+    isDefault: Scalars['Boolean'];
+    name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };
-export declare type TaxLine = {
+export type TaxLine = {
     __typename?: 'TaxLine';
     description: Scalars['String'];
     taxRate: Scalars['Float'];
 };
-export declare type TaxRate = Node & {
+export type TaxRate = Node & {
     __typename?: 'TaxRate';
-    id: Scalars['ID'];
+    category: TaxCategory;
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    name: Scalars['String'];
+    customFields?: Maybe<Scalars['JSON']>;
+    customerGroup?: Maybe<CustomerGroup>;
     enabled: Scalars['Boolean'];
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
     value: Scalars['Float'];
-    category: TaxCategory;
     zone: Zone;
-    customerGroup?: Maybe<CustomerGroup>;
-    customFields?: Maybe<Scalars['JSON']>;
 };
-export declare type TaxRateList = PaginatedList & {
+export type TaxRateList = PaginatedList & {
     __typename?: 'TaxRateList';
     items: Array<TaxRate>;
     totalItems: Scalars['Int'];
 };
-export declare type TextCustomFieldConfig = CustomField & {
+export type TextCustomFieldConfig = CustomField & {
     __typename?: 'TextCustomFieldConfig';
-    name: Scalars['String'];
-    type: Scalars['String'];
-    list: Scalars['Boolean'];
-    label?: Maybe<Array<LocalizedString>>;
     description?: Maybe<Array<LocalizedString>>;
-    readonly?: Maybe<Scalars['Boolean']>;
     internal?: Maybe<Scalars['Boolean']>;
+    label?: Maybe<Array<LocalizedString>>;
+    list: Scalars['Boolean'];
+    name: Scalars['String'];
     nullable?: Maybe<Scalars['Boolean']>;
+    readonly?: Maybe<Scalars['Boolean']>;
+    type: Scalars['String'];
     ui?: Maybe<Scalars['JSON']>;
 };
-export declare type TransitionOrderToStateResult = Order | OrderStateTransitionError;
-export declare type UpdateAddressInput = {
+export type TransitionOrderToStateResult = Order | OrderStateTransitionError;
+export type UpdateAddressInput = {
+    city?: InputMaybe<Scalars['String']>;
+    company?: InputMaybe<Scalars['String']>;
+    countryCode?: InputMaybe<Scalars['String']>;
+    customFields?: InputMaybe<Scalars['JSON']>;
+    defaultBillingAddress?: InputMaybe<Scalars['Boolean']>;
+    defaultShippingAddress?: InputMaybe<Scalars['Boolean']>;
+    fullName?: InputMaybe<Scalars['String']>;
     id: Scalars['ID'];
-    fullName?: Maybe<Scalars['String']>;
-    company?: Maybe<Scalars['String']>;
-    streetLine1?: Maybe<Scalars['String']>;
-    streetLine2?: Maybe<Scalars['String']>;
-    city?: Maybe<Scalars['String']>;
-    province?: Maybe<Scalars['String']>;
-    postalCode?: Maybe<Scalars['String']>;
-    countryCode?: Maybe<Scalars['String']>;
-    phoneNumber?: Maybe<Scalars['String']>;
-    defaultShippingAddress?: Maybe<Scalars['Boolean']>;
-    defaultBillingAddress?: Maybe<Scalars['Boolean']>;
-    customFields?: Maybe<Scalars['JSON']>;
-};
-export declare type UpdateCustomerEmailAddressResult = Success | IdentifierChangeTokenInvalidError | IdentifierChangeTokenExpiredError | NativeAuthStrategyError;
-export declare type UpdateCustomerInput = {
-    title?: Maybe<Scalars['String']>;
-    firstName?: Maybe<Scalars['String']>;
-    lastName?: Maybe<Scalars['String']>;
-    phoneNumber?: Maybe<Scalars['String']>;
-    customFields?: Maybe<Scalars['JSON']>;
-};
-export declare type UpdateCustomerPasswordResult = Success | InvalidCredentialsError | PasswordValidationError | NativeAuthStrategyError;
-export declare type UpdateOrderInput = {
-    customFields?: Maybe<Scalars['JSON']>;
-};
-export declare type UpdateOrderItemsResult = Order | OrderModificationError | OrderLimitError | NegativeQuantityError | InsufficientStockError;
-export declare type User = Node & {
+    phoneNumber?: InputMaybe<Scalars['String']>;
+    postalCode?: InputMaybe<Scalars['String']>;
+    province?: InputMaybe<Scalars['String']>;
+    streetLine1?: InputMaybe<Scalars['String']>;
+    streetLine2?: InputMaybe<Scalars['String']>;
+};
+export type UpdateCustomerEmailAddressResult = IdentifierChangeTokenExpiredError | IdentifierChangeTokenInvalidError | NativeAuthStrategyError | Success;
+export type UpdateCustomerInput = {
+    customFields?: InputMaybe<Scalars['JSON']>;
+    firstName?: InputMaybe<Scalars['String']>;
+    lastName?: InputMaybe<Scalars['String']>;
+    phoneNumber?: InputMaybe<Scalars['String']>;
+    title?: InputMaybe<Scalars['String']>;
+};
+export type UpdateCustomerPasswordResult = InvalidCredentialsError | NativeAuthStrategyError | PasswordValidationError | Success;
+export type UpdateOrderInput = {
+    customFields?: InputMaybe<Scalars['JSON']>;
+};
+export type UpdateOrderItemsResult = InsufficientStockError | NegativeQuantityError | Order | OrderLimitError | OrderModificationError;
+export type User = Node & {
     __typename?: 'User';
-    id: Scalars['ID'];
+    authenticationMethods: Array<AuthenticationMethod>;
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
+    customFields?: Maybe<Scalars['JSON']>;
+    id: Scalars['ID'];
     identifier: Scalars['String'];
-    verified: Scalars['Boolean'];
-    roles: Array<Role>;
     lastLogin?: Maybe<Scalars['DateTime']>;
-    authenticationMethods: Array<AuthenticationMethod>;
-    customFields?: Maybe<Scalars['JSON']>;
+    roles: Array<Role>;
+    updatedAt: Scalars['DateTime'];
+    verified: Scalars['Boolean'];
 };
 /**
  * Returned if the verification token (used to verify a Customer's email address) is valid, but has
  * expired according to the `verificationTokenDuration` setting in the AuthOptions.
  */
-export declare type VerificationTokenExpiredError = ErrorResult & {
+export type VerificationTokenExpiredError = ErrorResult & {
     __typename?: 'VerificationTokenExpiredError';
     errorCode: ErrorCode;
     message: Scalars['String'];
@@ -2919,18 +3009,18 @@ export declare type VerificationTokenExpiredError = ErrorResult & {
  * Returned if the verification token (used to verify a Customer's email address) is either
  * invalid or does not match any expected tokens.
  */
-export declare type VerificationTokenInvalidError = ErrorResult & {
+export type VerificationTokenInvalidError = ErrorResult & {
     __typename?: 'VerificationTokenInvalidError';
     errorCode: ErrorCode;
     message: Scalars['String'];
 };
-export declare type VerifyCustomerAccountResult = CurrentUser | VerificationTokenInvalidError | VerificationTokenExpiredError | MissingPasswordError | PasswordValidationError | PasswordAlreadySetError | NativeAuthStrategyError;
-export declare type Zone = Node & {
+export type VerifyCustomerAccountResult = CurrentUser | MissingPasswordError | NativeAuthStrategyError | PasswordAlreadySetError | PasswordValidationError | VerificationTokenExpiredError | VerificationTokenInvalidError;
+export type Zone = Node & {
     __typename?: 'Zone';
-    id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
-    updatedAt: Scalars['DateTime'];
-    name: Scalars['String'];
-    members: Array<Country>;
     customFields?: Maybe<Scalars['JSON']>;
+    id: Scalars['ID'];
+    members: Array<Country>;
+    name: Scalars['String'];
+    updatedAt: Scalars['DateTime'];
 };