feat(core): Implement productVariants list query in Admin API

packages/asset-server-plugin/e2e/graphql/generated-e2e-asset-server-plugin-types.ts

@@ -56,6 +56,8 @@ export type Query = {
     /** Get a Product either by id or slug. If neither id nor slug is speicified, an error will result. */
     product?: Maybe<Product>;
     /** Get a ProductVariant by id */
+    productVariants: ProductVariantList;
+    /** Get a ProductVariant by id */
     productVariant?: Maybe<ProductVariant>;
     promotion?: Maybe<Promotion>;
     promotions: PromotionList;
@@ -188,6 +190,10 @@ export type QueryProductArgs = {
     slug?: Maybe<Scalars['String']>;
 };
 
+export type QueryProductVariantsArgs = {
+    options?: Maybe<ProductVariantListOptions>;
+};
+
 export type QueryProductVariantArgs = {
     id: Scalars['ID'];
 };
@@ -3948,6 +3954,13 @@ export type ProductListOptions = {
     filter?: Maybe<ProductFilterParameter>;
 };
 
+export type ProductVariantListOptions = {
+    skip?: Maybe<Scalars['Int']>;
+    take?: Maybe<Scalars['Int']>;
+    sort?: Maybe<ProductVariantSortParameter>;
+    filter?: Maybe<ProductVariantFilterParameter>;
+};
+
 export type PromotionListOptions = {
     skip?: Maybe<Scalars['Int']>;
     take?: Maybe<Scalars['Int']>;
@@ -3976,13 +3989,6 @@ export type TaxRateListOptions = {
     filter?: Maybe<TaxRateFilterParameter>;
 };
 
-export type ProductVariantListOptions = {
-    skip?: Maybe<Scalars['Int']>;
-    take?: Maybe<Scalars['Int']>;
-    sort?: Maybe<ProductVariantSortParameter>;
-    filter?: Maybe<ProductVariantFilterParameter>;
-};
-
 export type HistoryEntryListOptions = {
     skip?: Maybe<Scalars['Int']>;
     take?: Maybe<Scalars['Int']>;
@@ -4209,6 +4215,38 @@ export type ProductSortParameter = {
     description?: Maybe<SortOrder>;
 };
 
+export type ProductVariantFilterParameter = {
+    enabled?: Maybe<BooleanOperators>;
+    trackInventory?: Maybe<StringOperators>;
+    stockOnHand?: Maybe<NumberOperators>;
+    stockAllocated?: Maybe<NumberOperators>;
+    outOfStockThreshold?: Maybe<NumberOperators>;
+    useGlobalOutOfStockThreshold?: Maybe<BooleanOperators>;
+    createdAt?: Maybe<DateOperators>;
+    updatedAt?: Maybe<DateOperators>;
+    languageCode?: Maybe<StringOperators>;
+    sku?: Maybe<StringOperators>;
+    name?: Maybe<StringOperators>;
+    price?: Maybe<NumberOperators>;
+    currencyCode?: Maybe<StringOperators>;
+    priceIncludesTax?: Maybe<BooleanOperators>;
+    priceWithTax?: Maybe<NumberOperators>;
+};
+
+export type ProductVariantSortParameter = {
+    stockOnHand?: Maybe<SortOrder>;
+    stockAllocated?: Maybe<SortOrder>;
+    outOfStockThreshold?: Maybe<SortOrder>;
+    id?: Maybe<SortOrder>;
+    productId?: Maybe<SortOrder>;
+    createdAt?: Maybe<SortOrder>;
+    updatedAt?: Maybe<SortOrder>;
+    sku?: Maybe<SortOrder>;
+    name?: Maybe<SortOrder>;
+    price?: Maybe<SortOrder>;
+    priceWithTax?: Maybe<SortOrder>;
+};
+
 export type PromotionFilterParameter = {
     createdAt?: Maybe<DateOperators>;
     updatedAt?: Maybe<DateOperators>;
@@ -4281,38 +4319,6 @@ export type TaxRateSortParameter = {
     value?: Maybe<SortOrder>;
 };
 
-export type ProductVariantFilterParameter = {
-    enabled?: Maybe<BooleanOperators>;
-    trackInventory?: Maybe<StringOperators>;
-    stockOnHand?: Maybe<NumberOperators>;
-    stockAllocated?: Maybe<NumberOperators>;
-    outOfStockThreshold?: Maybe<NumberOperators>;
-    useGlobalOutOfStockThreshold?: Maybe<BooleanOperators>;
-    createdAt?: Maybe<DateOperators>;
-    updatedAt?: Maybe<DateOperators>;
-    languageCode?: Maybe<StringOperators>;
-    sku?: Maybe<StringOperators>;
-    name?: Maybe<StringOperators>;
-    price?: Maybe<NumberOperators>;
-    currencyCode?: Maybe<StringOperators>;
-    priceIncludesTax?: Maybe<BooleanOperators>;
-    priceWithTax?: Maybe<NumberOperators>;
-};
-
-export type ProductVariantSortParameter = {
-    stockOnHand?: Maybe<SortOrder>;
-    stockAllocated?: Maybe<SortOrder>;
-    outOfStockThreshold?: Maybe<SortOrder>;
-    id?: Maybe<SortOrder>;
-    productId?: Maybe<SortOrder>;
-    createdAt?: Maybe<SortOrder>;
-    updatedAt?: Maybe<SortOrder>;
-    sku?: Maybe<SortOrder>;
-    name?: Maybe<SortOrder>;
-    price?: Maybe<SortOrder>;
-    priceWithTax?: Maybe<SortOrder>;
-};
-
 export type HistoryEntryFilterParameter = {
     isPublic?: Maybe<BooleanOperators>;
     createdAt?: Maybe<DateOperators>;

packages/common/src/generated-types.ts

@@ -57,6 +57,8 @@ export type Query = {
   /** Get a Product either by id or slug. If neither id nor slug is speicified, an error will result. */
   product?: Maybe<Product>;
   /** Get a ProductVariant by id */
+  productVariants: ProductVariantList;
+  /** Get a ProductVariant by id */
   productVariant?: Maybe<ProductVariant>;
   promotion?: Maybe<Promotion>;
   promotions: PromotionList;
@@ -217,6 +219,11 @@ export type QueryProductArgs = {
 };
 
 
+export type QueryProductVariantsArgs = {
+  options?: Maybe<ProductVariantListOptions>;
+};
+
+
 export type QueryProductVariantArgs = {
   id: Scalars['ID'];
 };
@@ -4186,6 +4193,13 @@ export type ProductListOptions = {
   filter?: Maybe<ProductFilterParameter>;
 };
 
+export type ProductVariantListOptions = {
+  skip?: Maybe<Scalars['Int']>;
+  take?: Maybe<Scalars['Int']>;
+  sort?: Maybe<ProductVariantSortParameter>;
+  filter?: Maybe<ProductVariantFilterParameter>;
+};
+
 export type PromotionListOptions = {
   skip?: Maybe<Scalars['Int']>;
   take?: Maybe<Scalars['Int']>;
@@ -4214,13 +4228,6 @@ export type TaxRateListOptions = {
   filter?: Maybe<TaxRateFilterParameter>;
 };
 
-export type ProductVariantListOptions = {
-  skip?: Maybe<Scalars['Int']>;
-  take?: Maybe<Scalars['Int']>;
-  sort?: Maybe<ProductVariantSortParameter>;
-  filter?: Maybe<ProductVariantFilterParameter>;
-};
-
 export type HistoryEntryListOptions = {
   skip?: Maybe<Scalars['Int']>;
   take?: Maybe<Scalars['Int']>;
@@ -4447,6 +4454,38 @@ export type ProductSortParameter = {
   description?: Maybe<SortOrder>;
 };
 
+export type ProductVariantFilterParameter = {
+  enabled?: Maybe<BooleanOperators>;
+  trackInventory?: Maybe<StringOperators>;
+  stockOnHand?: Maybe<NumberOperators>;
+  stockAllocated?: Maybe<NumberOperators>;
+  outOfStockThreshold?: Maybe<NumberOperators>;
+  useGlobalOutOfStockThreshold?: Maybe<BooleanOperators>;
+  createdAt?: Maybe<DateOperators>;
+  updatedAt?: Maybe<DateOperators>;
+  languageCode?: Maybe<StringOperators>;
+  sku?: Maybe<StringOperators>;
+  name?: Maybe<StringOperators>;
+  price?: Maybe<NumberOperators>;
+  currencyCode?: Maybe<StringOperators>;
+  priceIncludesTax?: Maybe<BooleanOperators>;
+  priceWithTax?: Maybe<NumberOperators>;
+};
+
+export type ProductVariantSortParameter = {
+  stockOnHand?: Maybe<SortOrder>;
+  stockAllocated?: Maybe<SortOrder>;
+  outOfStockThreshold?: Maybe<SortOrder>;
+  id?: Maybe<SortOrder>;
+  productId?: Maybe<SortOrder>;
+  createdAt?: Maybe<SortOrder>;
+  updatedAt?: Maybe<SortOrder>;
+  sku?: Maybe<SortOrder>;
+  name?: Maybe<SortOrder>;
+  price?: Maybe<SortOrder>;
+  priceWithTax?: Maybe<SortOrder>;
+};
+
 export type PromotionFilterParameter = {
   createdAt?: Maybe<DateOperators>;
   updatedAt?: Maybe<DateOperators>;
@@ -4519,38 +4558,6 @@ export type TaxRateSortParameter = {
   value?: Maybe<SortOrder>;
 };
 
-export type ProductVariantFilterParameter = {
-  enabled?: Maybe<BooleanOperators>;
-  trackInventory?: Maybe<StringOperators>;
-  stockOnHand?: Maybe<NumberOperators>;
-  stockAllocated?: Maybe<NumberOperators>;
-  outOfStockThreshold?: Maybe<NumberOperators>;
-  useGlobalOutOfStockThreshold?: Maybe<BooleanOperators>;
-  createdAt?: Maybe<DateOperators>;
-  updatedAt?: Maybe<DateOperators>;
-  languageCode?: Maybe<StringOperators>;
-  sku?: Maybe<StringOperators>;
-  name?: Maybe<StringOperators>;
-  price?: Maybe<NumberOperators>;
-  currencyCode?: Maybe<StringOperators>;
-  priceIncludesTax?: Maybe<BooleanOperators>;
-  priceWithTax?: Maybe<NumberOperators>;
-};
-
-export type ProductVariantSortParameter = {
-  stockOnHand?: Maybe<SortOrder>;
-  stockAllocated?: Maybe<SortOrder>;
-  outOfStockThreshold?: Maybe<SortOrder>;
-  id?: Maybe<SortOrder>;
-  productId?: Maybe<SortOrder>;
-  createdAt?: Maybe<SortOrder>;
-  updatedAt?: Maybe<SortOrder>;
-  sku?: Maybe<SortOrder>;
-  name?: Maybe<SortOrder>;
-  price?: Maybe<SortOrder>;
-  priceWithTax?: Maybe<SortOrder>;
-};
-
 export type HistoryEntryFilterParameter = {
   isPublic?: Maybe<BooleanOperators>;
   createdAt?: Maybe<DateOperators>;

packages/core/e2e/graphql/generated-e2e-admin-types.ts

@@ -56,6 +56,8 @@ export type Query = {
     /** Get a Product either by id or slug. If neither id nor slug is speicified, an error will result. */
     product?: Maybe<Product>;
     /** Get a ProductVariant by id */
+    productVariants: ProductVariantList;
+    /** Get a ProductVariant by id */
     productVariant?: Maybe<ProductVariant>;
     promotion?: Maybe<Promotion>;
     promotions: PromotionList;
@@ -188,6 +190,10 @@ export type QueryProductArgs = {
     slug?: Maybe<Scalars['String']>;
 };
 
+export type QueryProductVariantsArgs = {
+    options?: Maybe<ProductVariantListOptions>;
+};
+
 export type QueryProductVariantArgs = {
     id: Scalars['ID'];
 };
@@ -3948,6 +3954,13 @@ export type ProductListOptions = {
     filter?: Maybe<ProductFilterParameter>;
 };
 
+export type ProductVariantListOptions = {
+    skip?: Maybe<Scalars['Int']>;
+    take?: Maybe<Scalars['Int']>;
+    sort?: Maybe<ProductVariantSortParameter>;
+    filter?: Maybe<ProductVariantFilterParameter>;
+};
+
 export type PromotionListOptions = {
     skip?: Maybe<Scalars['Int']>;
     take?: Maybe<Scalars['Int']>;
@@ -3976,13 +3989,6 @@ export type TaxRateListOptions = {
     filter?: Maybe<TaxRateFilterParameter>;
 };
 
-export type ProductVariantListOptions = {
-    skip?: Maybe<Scalars['Int']>;
-    take?: Maybe<Scalars['Int']>;
-    sort?: Maybe<ProductVariantSortParameter>;
-    filter?: Maybe<ProductVariantFilterParameter>;
-};
-
 export type HistoryEntryListOptions = {
     skip?: Maybe<Scalars['Int']>;
     take?: Maybe<Scalars['Int']>;
@@ -4209,6 +4215,38 @@ export type ProductSortParameter = {
     description?: Maybe<SortOrder>;
 };
 
+export type ProductVariantFilterParameter = {
+    enabled?: Maybe<BooleanOperators>;
+    trackInventory?: Maybe<StringOperators>;
+    stockOnHand?: Maybe<NumberOperators>;
+    stockAllocated?: Maybe<NumberOperators>;
+    outOfStockThreshold?: Maybe<NumberOperators>;
+    useGlobalOutOfStockThreshold?: Maybe<BooleanOperators>;
+    createdAt?: Maybe<DateOperators>;
+    updatedAt?: Maybe<DateOperators>;
+    languageCode?: Maybe<StringOperators>;
+    sku?: Maybe<StringOperators>;
+    name?: Maybe<StringOperators>;
+    price?: Maybe<NumberOperators>;
+    currencyCode?: Maybe<StringOperators>;
+    priceIncludesTax?: Maybe<BooleanOperators>;
+    priceWithTax?: Maybe<NumberOperators>;
+};
+
+export type ProductVariantSortParameter = {
+    stockOnHand?: Maybe<SortOrder>;
+    stockAllocated?: Maybe<SortOrder>;
+    outOfStockThreshold?: Maybe<SortOrder>;
+    id?: Maybe<SortOrder>;
+    productId?: Maybe<SortOrder>;
+    createdAt?: Maybe<SortOrder>;
+    updatedAt?: Maybe<SortOrder>;
+    sku?: Maybe<SortOrder>;
+    name?: Maybe<SortOrder>;
+    price?: Maybe<SortOrder>;
+    priceWithTax?: Maybe<SortOrder>;
+};
+
 export type PromotionFilterParameter = {
     createdAt?: Maybe<DateOperators>;
     updatedAt?: Maybe<DateOperators>;
@@ -4281,38 +4319,6 @@ export type TaxRateSortParameter = {
     value?: Maybe<SortOrder>;
 };
 
-export type ProductVariantFilterParameter = {
-    enabled?: Maybe<BooleanOperators>;
-    trackInventory?: Maybe<StringOperators>;
-    stockOnHand?: Maybe<NumberOperators>;
-    stockAllocated?: Maybe<NumberOperators>;
-    outOfStockThreshold?: Maybe<NumberOperators>;
-    useGlobalOutOfStockThreshold?: Maybe<BooleanOperators>;
-    createdAt?: Maybe<DateOperators>;
-    updatedAt?: Maybe<DateOperators>;
-    languageCode?: Maybe<StringOperators>;
-    sku?: Maybe<StringOperators>;
-    name?: Maybe<StringOperators>;
-    price?: Maybe<NumberOperators>;
-    currencyCode?: Maybe<StringOperators>;
-    priceIncludesTax?: Maybe<BooleanOperators>;
-    priceWithTax?: Maybe<NumberOperators>;
-};
-
-export type ProductVariantSortParameter = {
-    stockOnHand?: Maybe<SortOrder>;
-    stockAllocated?: Maybe<SortOrder>;
-    outOfStockThreshold?: Maybe<SortOrder>;
-    id?: Maybe<SortOrder>;
-    productId?: Maybe<SortOrder>;
-    createdAt?: Maybe<SortOrder>;
-    updatedAt?: Maybe<SortOrder>;
-    sku?: Maybe<SortOrder>;
-    name?: Maybe<SortOrder>;
-    price?: Maybe<SortOrder>;
-    priceWithTax?: Maybe<SortOrder>;
-};
-
 export type HistoryEntryFilterParameter = {
     isPublic?: Maybe<BooleanOperators>;
     createdAt?: Maybe<DateOperators>;
@@ -5946,6 +5952,16 @@ export type GetProductVariantQueryVariables = Exact<{
 
 export type GetProductVariantQuery = { productVariant?: Maybe<Pick<ProductVariant, 'id' | 'name'>> };
 
+export type GetProductVariantListQueryVariables = Exact<{
+    options?: Maybe<ProductVariantListOptions>;
+}>;
+
+export type GetProductVariantListQuery = {
+    productVariants: Pick<ProductVariantList, 'totalItems'> & {
+        items: Array<Pick<ProductVariant, 'id' | 'name' | 'sku' | 'price'>>;
+    };
+};
+
 export type DeletePromotionMutationVariables = Exact<{
     id: Scalars['ID'];
 }>;
@@ -7970,6 +7986,15 @@ export namespace GetProductVariant {
     export type ProductVariant = NonNullable<GetProductVariantQuery['productVariant']>;
 }
 
+export namespace GetProductVariantList {
+    export type Variables = GetProductVariantListQueryVariables;
+    export type Query = GetProductVariantListQuery;
+    export type ProductVariants = NonNullable<GetProductVariantListQuery['productVariants']>;
+    export type Items = NonNullable<
+        NonNullable<NonNullable<GetProductVariantListQuery['productVariants']>['items']>[number]
+    >;
+}
+
 export namespace DeletePromotion {
     export type Variables = DeletePromotionMutationVariables;
     export type Mutation = DeletePromotionMutation;

packages/core/e2e/product.e2e-spec.ts

@@ -372,41 +372,6 @@ describe('Product resolver', () => {
                 },
             ]);
         });
-
-        it('sort by price', async () => {
-            const { productVariants } = await adminClient.query<
-                GetProductVariantList.Query,
-                GetProductVariantList.Variables
-            >(GET_PRODUCT_VARIANT_LIST, {
-                options: {
-                    take: 3,
-                    sort: {
-                        price: SortOrder.ASC,
-                    },
-                },
-            });
-
-            expect(productVariants.items).toEqual([
-                {
-                    id: 'T_23',
-                    name: 'Skipping Rope',
-                    price: 799,
-                    sku: 'B07CNGXVXT',
-                },
-                {
-                    id: 'T_20',
-                    name: 'Tripod',
-                    price: 1498,
-                    sku: 'B00XI87KV8',
-                },
-                {
-                    id: 'T_32',
-                    name: 'Spiky Cactus',
-                    price: 1550,
-                    sku: 'SC011001',
-                },
-            ]);
-        });
     });
 
     describe('productVariant query', () => {

packages/core/src/api/resolvers/admin/product.resolver.ts

@@ -17,6 +17,7 @@ import {
     QueryProductArgs,
     QueryProductsArgs,
     QueryProductVariantArgs,
+    QueryProductVariantsArgs,
     RemoveOptionGroupFromProductResult,
 } from '@vendure/common/lib/generated-types';
 import { PaginatedList } from '@vendure/common/lib/shared-types';
@@ -70,6 +71,15 @@ export class ProductResolver {
         }
     }
 
+    @Query()
+    @Allow(Permission.ReadCatalog)
+    async productVariants(
+        @Ctx() ctx: RequestContext,
+        @Args() args: QueryProductVariantsArgs,
+    ): Promise<PaginatedList<Translated<ProductVariant>>> {
+        return this.productVariantService.findAll(ctx, args.options || undefined);
+    }
+
     @Query()
     @Allow(Permission.ReadCatalog)
     async productVariant(

packages/core/src/api/schema/admin-api/product.api.graphql

@@ -1,7 +1,10 @@
 type Query {
+    "List Products"
     products(options: ProductListOptions): ProductList!
     "Get a Product either by id or slug. If neither id nor slug is speicified, an error will result."
     product(id: ID, slug: String): Product
+    "List ProductVariants"
+    productVariants(options: ProductVariantListOptions): ProductVariantList!
     "Get a ProductVariant by id"
     productVariant(id: ID!): ProductVariant
 }
@@ -53,6 +56,9 @@ input StockMovementListOptions {
 # generated by generateListOptions function
 input ProductListOptions
 
+# generated by generateListOptions function
+input ProductVariantListOptions
+
 input ProductTranslationInput {
     id: ID
     languageCode: LanguageCode!

packages/core/src/api/schema/common/product.type.graphql

@@ -30,6 +30,11 @@ type ProductList implements PaginatedList {
     totalItems: Int!
 }
 
+type ProductVariantList implements PaginatedList {
+    items: [ProductVariant!]!
+    totalItems: Int!
+}
+
 type ProductVariant implements Node {
     id: ID!
     product: Product!

packages/core/src/service/helpers/list-query-builder/parse-channel-param.ts

@@ -7,7 +7,7 @@ import { WhereCondition } from './parse-filter-params';
 
 /**
  * Creates a WhereCondition for a channel-aware entity, filtering for only those entities
- * which are assigned to the channel speicified by channelId,
+ * which are assigned to the channel specified by channelId,
  */
 export function parseChannelParam<T extends VendureEntity>(
     connection: Connection,

packages/core/src/service/services/product-variant.service.ts

@@ -62,6 +62,30 @@ export class ProductVariantService {
         private roleService: RoleService,
     ) {}
 
+    async findAll(
+        ctx: RequestContext,
+        options?: ListQueryOptions<ProductVariant>,
+    ): Promise<PaginatedList<Translated<ProductVariant>>> {
+        const relations = ['featuredAsset', 'taxCategory', 'channels'];
+        return this.listQueryBuilder
+            .build(ProductVariant, options, {
+                relations,
+                channelId: ctx.channelId,
+                where: { deletedAt: null },
+                ctx,
+            })
+            .getManyAndCount()
+            .then(async ([variants, totalItems]) => {
+                const items = variants.map(variant =>
+                    translateDeep(this.applyChannelPriceAndTax(variant, ctx), ctx.languageCode),
+                );
+                return {
+                    items,
+                    totalItems,
+                };
+            });
+    }
+
     findOne(ctx: RequestContext, productVariantId: ID): Promise<Translated<ProductVariant> | undefined> {
         const relations = ['product', 'product.featuredAsset', 'taxCategory'];
         return this.connection

packages/elasticsearch-plugin/e2e/graphql/generated-e2e-elasticsearch-plugin-types.ts

@@ -56,6 +56,8 @@ export type Query = {
     /** Get a Product either by id or slug. If neither id nor slug is speicified, an error will result. */
     product?: Maybe<Product>;
     /** Get a ProductVariant by id */
+    productVariants: ProductVariantList;
+    /** Get a ProductVariant by id */
     productVariant?: Maybe<ProductVariant>;
     promotion?: Maybe<Promotion>;
     promotions: PromotionList;
@@ -188,6 +190,10 @@ export type QueryProductArgs = {
     slug?: Maybe<Scalars['String']>;
 };
 
+export type QueryProductVariantsArgs = {
+    options?: Maybe<ProductVariantListOptions>;
+};
+
 export type QueryProductVariantArgs = {
     id: Scalars['ID'];
 };
@@ -3948,6 +3954,13 @@ export type ProductListOptions = {
     filter?: Maybe<ProductFilterParameter>;
 };
 
+export type ProductVariantListOptions = {
+    skip?: Maybe<Scalars['Int']>;
+    take?: Maybe<Scalars['Int']>;
+    sort?: Maybe<ProductVariantSortParameter>;
+    filter?: Maybe<ProductVariantFilterParameter>;
+};
+
 export type PromotionListOptions = {
     skip?: Maybe<Scalars['Int']>;
     take?: Maybe<Scalars['Int']>;
@@ -3976,13 +3989,6 @@ export type TaxRateListOptions = {
     filter?: Maybe<TaxRateFilterParameter>;
 };
 
-export type ProductVariantListOptions = {
-    skip?: Maybe<Scalars['Int']>;
-    take?: Maybe<Scalars['Int']>;
-    sort?: Maybe<ProductVariantSortParameter>;
-    filter?: Maybe<ProductVariantFilterParameter>;
-};
-
 export type HistoryEntryListOptions = {
     skip?: Maybe<Scalars['Int']>;
     take?: Maybe<Scalars['Int']>;
@@ -4209,6 +4215,38 @@ export type ProductSortParameter = {
     description?: Maybe<SortOrder>;
 };
 
+export type ProductVariantFilterParameter = {
+    enabled?: Maybe<BooleanOperators>;
+    trackInventory?: Maybe<StringOperators>;
+    stockOnHand?: Maybe<NumberOperators>;
+    stockAllocated?: Maybe<NumberOperators>;
+    outOfStockThreshold?: Maybe<NumberOperators>;
+    useGlobalOutOfStockThreshold?: Maybe<BooleanOperators>;
+    createdAt?: Maybe<DateOperators>;
+    updatedAt?: Maybe<DateOperators>;
+    languageCode?: Maybe<StringOperators>;
+    sku?: Maybe<StringOperators>;
+    name?: Maybe<StringOperators>;
+    price?: Maybe<NumberOperators>;
+    currencyCode?: Maybe<StringOperators>;
+    priceIncludesTax?: Maybe<BooleanOperators>;
+    priceWithTax?: Maybe<NumberOperators>;
+};
+
+export type ProductVariantSortParameter = {
+    stockOnHand?: Maybe<SortOrder>;
+    stockAllocated?: Maybe<SortOrder>;
+    outOfStockThreshold?: Maybe<SortOrder>;
+    id?: Maybe<SortOrder>;
+    productId?: Maybe<SortOrder>;
+    createdAt?: Maybe<SortOrder>;
+    updatedAt?: Maybe<SortOrder>;
+    sku?: Maybe<SortOrder>;
+    name?: Maybe<SortOrder>;
+    price?: Maybe<SortOrder>;
+    priceWithTax?: Maybe<SortOrder>;
+};
+
 export type PromotionFilterParameter = {
     createdAt?: Maybe<DateOperators>;
     updatedAt?: Maybe<DateOperators>;
@@ -4281,38 +4319,6 @@ export type TaxRateSortParameter = {
     value?: Maybe<SortOrder>;
 };
 
-export type ProductVariantFilterParameter = {
-    enabled?: Maybe<BooleanOperators>;
-    trackInventory?: Maybe<StringOperators>;
-    stockOnHand?: Maybe<NumberOperators>;
-    stockAllocated?: Maybe<NumberOperators>;
-    outOfStockThreshold?: Maybe<NumberOperators>;
-    useGlobalOutOfStockThreshold?: Maybe<BooleanOperators>;
-    createdAt?: Maybe<DateOperators>;
-    updatedAt?: Maybe<DateOperators>;
-    languageCode?: Maybe<StringOperators>;
-    sku?: Maybe<StringOperators>;
-    name?: Maybe<StringOperators>;
-    price?: Maybe<NumberOperators>;
-    currencyCode?: Maybe<StringOperators>;
-    priceIncludesTax?: Maybe<BooleanOperators>;
-    priceWithTax?: Maybe<NumberOperators>;
-};
-
-export type ProductVariantSortParameter = {
-    stockOnHand?: Maybe<SortOrder>;
-    stockAllocated?: Maybe<SortOrder>;
-    outOfStockThreshold?: Maybe<SortOrder>;
-    id?: Maybe<SortOrder>;
-    productId?: Maybe<SortOrder>;
-    createdAt?: Maybe<SortOrder>;
-    updatedAt?: Maybe<SortOrder>;
-    sku?: Maybe<SortOrder>;
-    name?: Maybe<SortOrder>;
-    price?: Maybe<SortOrder>;
-    priceWithTax?: Maybe<SortOrder>;
-};
-
 export type HistoryEntryFilterParameter = {
     isPublic?: Maybe<BooleanOperators>;
     createdAt?: Maybe<DateOperators>;