@wix/ditto-codegen-public 1.0.161 → 1.0.163

package/dist/docs-output/api-docs/stores-readOnlyVariantsV3-queryVariants-doc.txt

@@ -0,0 +1,290 @@
+<stores_readOnlyVariantsV3_queryVariants>
+<description>
+# Method name:
+
+stores.readOnlyVariantsV3.queryVariants(options: QueryVariantsOptions)
+
+# Method Link:
+
+https://dev.wix.com/docs/sdk/backend-modules/stores/catalog-v3/read-only-variants-v3/query-variants
+
+# Method Description:
+
+Retrieve product variants using structured queries with cursor-based pagination.
+
+Use this endpoint for simple filtering operations on `id` and `productId`.
+For complex queries with free-text search and aggregations, use Search Variants instead.
+
+Up to 1,000 variants can be returned per request.
+
+
+|PROPERTY	|SUPPORTED FILTERS & SORTING	
+|:---:|:---:|
+|`_id`|[`eq()`](/variants-query-builder/eq),[`ne()`](/variants-query-builder/ne),[`exists()`](/variants-query-builder/exists),[`in()`](/variants-query-builder/in),[`hasSome()`](/variants-query-builder/has-some),[`startsWith()`](/variants-query-builder/starts-with),[`gt()`](/variants-query-builder/gt),[`lt()`](/variants-query-builder/lt),[`le()`](/variants-query-builder/le),[`ge()`](/variants-query-builder/ge),[`ascending()`](/variants-query-builder/ascending),[`descending()`](/variants-query-builder/descending)|
+|`productData.productId`|[`eq()`](/variants-query-builder/eq),[`ne()`](/variants-query-builder/ne),[`exists()`](/variants-query-builder/exists),[`in()`](/variants-query-builder/in),[`hasSome()`](/variants-query-builder/has-some),[`startsWith()`](/variants-query-builder/starts-with),[`gt()`](/variants-query-builder/gt),[`lt()`](/variants-query-builder/lt),[`le()`](/variants-query-builder/le),[`ge()`](/variants-query-builder/ge),[`ascending()`](/variants-query-builder/ascending),[`descending()`](/variants-query-builder/descending)|
+
+# Method Permissions:
+
+- WIX_STORES.READ_ONLY_VARIANT_READ
+- WIX_STORES.READ_ONLY_VARIANT_READ_HIDDEN
+
+# Method Permissions Scopes IDs:
+
+undefined
+
+
+
+# Method Code Examples:
+
+## queryVariants
+
+```javascript
+import { readOnlyVariantsV3 } from '@wix/stores';
+
+async function queryVariants() {
+ const { items } = await readOnlyVariantsV3.queryVariants().find();
+};
+```
+
+## queryVariants (with elevated permissions)
+
+```javascript
+import { readOnlyVariantsV3 } from '@wix/stores';
+import { auth } from '@wix/essentials';
+
+async function myQueryVariantsMethod(query, options) {
+ const elevatedQueryVariants = auth.elevate(readOnlyVariantsV3.queryVariants);
+ const response = await elevatedQueryVariants(query, options);
+}
+```
+
+
+
+## default
+
+```javascript
+try {
+     const { items } = await readOnlyVariantsV3.queryVariants().find();
+     return items;
+   } catch (error) {
+     console.error(error);
+     throw error;
+  }
+```
+</description>
+<type_definition>
+```
+Method: stores.readOnlyVariantsV3.queryVariants(options)
+Description: Retrieve product variants using structured queries with cursor-based pagination.  Use this endpoint for simple filtering operations on `id` and `productId`. For complex queries with free-text search and aggregations, use Search Variants instead.  Up to 1,000 variants can be returned per request.   |PROPERTY	|SUPPORTED FILTERS & SORTING	 |:---:|:---:| |`_id`|[`eq()`](/variants-query-builder/eq),[`ne()`](/variants-query-builder/ne),[`exists()`](/variants-query-builder/exists),[`in()`](/variants-query-builder/in),[`hasSome()`](/variants-query-builder/has-some),[`startsWith()`](/variants-query-builder/starts-with),[`gt()`](/variants-query-builder/gt),[`lt()`](/variants-query-builder/lt),[`le()`](/variants-query-builder/le),[`ge()`](/variants-query-builder/ge),[`ascending()`](/variants-query-builder/ascending),[`descending()`](/variants-query-builder/descending)| |`productData.productId`|[`eq()`](/variants-query-builder/eq),[`ne()`](/variants-query-builder/ne),[`exists()`](/variants-query-builder/exists),[`in()`](/variants-query-builder/in),[`hasSome()`](/variants-query-builder/has-some),[`startsWith()`](/variants-query-builder/starts-with),[`gt()`](/variants-query-builder/gt),[`lt()`](/variants-query-builder/lt),[`le()`](/variants-query-builder/le),[`ge()`](/variants-query-builder/ge),[`ascending()`](/variants-query-builder/ascending),[`descending()`](/variants-query-builder/descending)|
+Method parameters:
+  param name:  options | type: QueryVariantsOptions | description:  none 
+      - name: fields  | type: Array<RequestedFields> | description:  List of additional fields to include in the response. See VariantOps.RequestedFields for available options. 
+            enum: 
+                 CURRENCY: Include currency information in product data.  Returns the currency code (ISO-4217 format) used for pricing this variant. Defaults to the site's currency unless specified in request headers.
+                 MERCHANT_DATA: Include merchant-specific data such as cost and profit information.  Returns revenue details including cost, profit, and profit margin. Requires `SCOPE.STORES.PRODUCT_READ_ADMIN` permission scope.
+                 SUBSCRIPTION_PRICES_INFO: Include subscription pricing information.  Returns calculated prices for different subscription plans with applied discounts. Only relevant for variants that are part of subscription offerings.
+                 UNKNOWN_REQUESTED_FIELD: Unknown requested field.
+                 WEIGHT_MEASUREMENT_UNIT_INFO: Include weight measurement unit information.  Returns the weight measurement unit (kg, lb, etc.) used for the variant. Useful for shipping calculations and product comparisons.
+Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().ascending(propertyNames)
+    Description: Adds a sort to a query, sorting by the specified properties in ascending order.  The `ascending()` function refines a `VariantsQueryBuilder` to sort by the value of `propertyName` in ascending order. You can specify multiple properties for sorting in ascending order by passing each property name as an additional argument. `ascending()` sorts the results in the order the properties are passed. You can sort the following types: - Number: Sorts numerically. - Date: Sorts by date and time. - String: Sorts lexicographically, so `'abc'` comes after `'XYZ'`. If a property contains a number stored as a string (for example, `'0'`), that value is sorted alphabetically and not numerically. If a property doesn't have a value, that value is ranked lowest.
+    Method parameters:
+      param name:  propertyNames | type: Array<string> | description:  Properties used in the sort. To sort by multiple properties, pass properties as additional arguments. 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().descending(propertyNames)
+    Description: Adds a sort to a query, sorting by the specified properties in descending order.  The `descending()` function refines a `VariantsQueryBuilder` to sort by the value of `propertyName` in descending order. You can specify multiple properties for sorting in descending order by passing each property name as an additional argument. `descending()` sorts the results in the order the properties are passed. You can sort the following types: - Number: Sorts numerically. - Date: Sorts by date and time. - String: Sorts lexicographically, so `'abc'` comes after `'XYZ'`. If a property contains a number stored as a string (for example, `'0'`), that value is sorted alphabetically and not numerically. If a property doesn't have a value, that value is ranked lowest.
+    Method parameters:
+      param name:  propertyNames | type: Array<string> | description:  Properties used in the sort. To sort by multiple properties, pass properties as additional arguments. 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().eq(propertyName, value)
+    Description: Refines a query to match items where the specified property equals the specified value.  The `eq()` function refines a `VariantsQueryBuilder` to match only items where the value of the specified `propertyName` equals the specified `value`. `eq()` matches only values of the same type. For example, `0` stored as a number doesn't match `'0'` stored as a string. Matching strings with `eq()` is case-sensitive, so `'text'` isn't equal to `'Text'`.
+    Method parameters:
+      param name:  propertyName | type: string | description:  Property whose value is compared with `value`. 
+      param name:  value | type: any | description:  Value to compare against. 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().exists(propertyName, value)
+    Description: Refines a query to match items where the specified property contains a value.  The `exists()` function refines a `VariantsQueryBuilder` to only match items where the value of the specified `propertyName` doesn't equal null or undefined.  `exists()` checks for either existence or non-existence based on the boolean parameter. Note that `exists()` does match items where the value of the specified `propertyName` is an empty string or an invalid value. `exists()` is only useful for properties which don't contain default values and therefore their values may be unassigned.
+    Method parameters:
+      param name:  propertyName | type: string | description:  none 
+      param name:  value | type: boolean | description:  none 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().find()
+    Description: Returns the query results.  The `find()` function returns a Promise that resolves to the query results and metadata. The Promise is rejected if `find()` is called with insufficient permissions or if any of the previous functions used to refine the query are invalid.
+    Return type: PROMISE<VariantsQueryResult>
+          - name: cursors  | type: Cursors | description:  Returns the query cursors.  `cursors` returns the query's `next` and `prev` cursors. 
+              - name: cursors.next  | type: string | description:  Cursor string pointing to the next page in the list of results. 
+              - name: cursors.prev  | type: string | description:  Cursor pointing to the previous page in the list of results. 
+          - name: items  | type: Array<ReadOnlyVariant> | description:  Returns an array of `readOnlyVariantsV3` items that match the query.  `items` contains the current page of results retrieved by the query. If no results match the query, `items` is an empty array. The page size is defined by the [`limit()`](/variants-query-builder/limit) function and can be retrieved using the [`pageSize`](#page-size) property. You can use the [`next()`](#next) and [`prev()`](#prev) functions returned by `readOnlyVariantsV3` to navigate the pages of a query result. 
+                - name: items[]._id  | type: string | description:  Variant GUID. 
+                - name: items[].barcode  | type: string | description:  Barcode for the variant, typically used for point-of-sale systems and inventory management.  Common barcode formats include UPC, EAN, and Code 128. The barcode helps with quick product identification and checkout processes. 
+                - name: items[].inventoryStatus  | type: V3InventoryStatus | description:  Current inventory and availability status. 
+                    - name: items[].inventoryStatus.inStock  | type: boolean | description:  Whether the variant is currently in stock and available for purchase. 
+                    - name: items[].inventoryStatus.preorderEnabled  | type: boolean | description:  Whether customers can place preorders for this variant when it's out of stock. 
+                - name: items[].media  | type: V3ProductMedia | description:  Media associated with the variant.  Typically includes images, videos, or other media files specific to this variant. 
+                    - name: items[].media.altText  | type: string | description:  Image alt text. 
+                    - name: items[].media.displayName  | type: string | description:  Media display name. Allows to override the default media name. Can be passed only when `setBy: url`. 
+                    - name: items[].media.mediaType  | type: ProductMediaMediaType | description:  Media type. 
+                        enum: 
+                             IMAGE: Image media type.
+                           UNKNOWN_MEDIA_TYPE,   VIDEO: Video media type.
+                    - name: items[].media.thumbnail  | type: V3Thumbnail | description:  Media thumbnail. 
+                        - name: items[].media.thumbnail.altText  | type: string | description:  Thumbnail alt text. 
+                        - name: items[].media.thumbnail.height  | type: number | description:  Thumbnail height. 
+                        - name: items[].media.thumbnail.url  | type: string | description:  Thumbnail URL. 
+                        - name: items[].media.thumbnail.width  | type: number | description:  Thumbnail width. 
+                    - name: items[].media.uploadId  | type: string | description:  GUID used to upload media to Wix Media Manager. 
+                    - ONE-OF: 
+                      - name: items[].media._id  | type: string | description:  GUID of existing media from Wix Media Manager. 
+                      - name: items[].media.url  | type: string | description:  Media URL. 
+                    - ONE-OF: 
+                      - name: items[].media.image  | type: string | description:  Product image. 
+                      - name: items[].media.video  | type: string | description:  Product video. 
+                - name: items[].optionChoices  | type: Array<V3OptionChoice> | description:  Product option choices that define this variant.  Each option choice represents a specific selection for a product option (like "Size: Large" or "Color: Red"). An empty list indicates this is the default variant of a product with no managed options. 
+                      - name: items[].optionChoices[].optionChoiceIds  | type: V3OptionChoiceIds | description:  Option and choice identifiers. 
+                          - name: items[].optionChoices[].optionChoiceIds.choiceId  | type: string | description:  Specific choice GUID within the option. 
+                          - name: items[].optionChoices[].optionChoiceIds.optionId  | type: string | description:  Product option GUID. 
+                      - name: items[].optionChoices[].optionChoiceNames  | type: V3OptionChoiceNames | description:  Human-readable option and choice names. 
+                          - name: items[].optionChoices[].optionChoiceNames.choiceName  | type: string | description:  Display name of the chosen option value.  For example, "Large", "Red", or "Cotton". 
+                          - name: items[].optionChoices[].optionChoiceNames.optionName  | type: string | description:  Display name of the product option.  For example, "Size", "Color", or "Material". 
+                          - name: items[].optionChoices[].optionChoiceNames.renderType  | type: string | description:  Visual representation style for the option choice.  Determines how the option is displayed in the product selector UI. Common values include "TEXT_CHOICES", "COLOR_CHOICES", or "IMAGE_CHOICES". 
+                - name: items[].price  | type: V3PriceInfo | description:  Pricing information for the variant. 
+                    - name: items[].price.actualPrice  | type: V3FixedMonetaryAmount | description:  Current selling price of the variant. 
+                        - name: items[].price.actualPrice.amount  | type: string | description:  Monetary amount. For example, `"3.99"`, or `"-4.99"` for a negative amount. 
+                        - name: items[].price.actualPrice.formattedAmount  | type: string | description:  Formatted monetary amount. For example, `"$3.99"`. 
+                    - name: items[].price.compareAtPrice  | type: V3FixedMonetaryAmount | description:  Original price before any discounts.  Used to show customers the savings when the variant is on sale. If not set, no original price is displayed. 
+                - name: items[].productData  | type: ProductFields | description:  Product information for context and convenience.  Includes essential product details like name, visibility, and categories to avoid requiring separate product API calls when working with variants. 
+                    - name: items[].productData.currency  | type: string | description:  Currency used for pricing this product.  Three-letter currency code in ISO-4217 alphabetic format. Defaults to the site's currency setting unless specified in request headers. Returned only when you pass `"CURRENCY"` to the `fields` parameter. 
+                    - name: items[].productData.handle  | type: string | description:  A unique human-friendly identifier for the product.  The handle can be set by the user to ensure consistency across multiple platforms. 
+                    - name: items[].productData.mainCategoryId  | type: string | description:  Primary category assignment for the product.  Determines the main category used for navigation and organization. 
+                    - name: items[].productData.name  | type: string | description:  Product name displayed to customers. 
+                    - name: items[].productData.productId  | type: string | description:  Product GUID. 
+                    - name: items[].productData.productType  | type: V3ProductType | description:  Type of product determining available properties and behavior. 
+                        enum: 
+                             DIGITAL: Digital product.
+                             PHYSICAL: Physical product.
+                             UNKNOWN_PRODUCT_TYPE: Not implemented.
+                    - name: items[].productData.revision  | type: string | description:  Revision number, which increments by 1 each time the product is updated. To prevent conflicting changes, the current revision must be passed when updating the product. 
+                    - name: items[].productData.slug  | type: string | description:  URL-friendly identifier for the product.  Used in product page URLs and for SEO optimization. 
+                    - name: items[].productData.visible  | type: boolean | description:  Whether the product is visible to site visitors.  Default: `true` 
+                    - name: items[].productData.visibleInPos  | type: boolean | description:  Whether the product appears in point-of-sale systems.  Default: `true` Always `false` for digital products. 
+                    - ONE-OF: 
+                      - name: items[].productData.physicalProperties  | type: V3PhysicalProperties | description:  Physical product properties such as weight and dimensions.  Required when `productType` is `PHYSICAL`. 
+                          - name: items[].productData.physicalProperties.weightMeasurementUnitInfo  | type: V3WeightMeasurementUnitInfo | description:  Weight measurement unit information for the product.  Defines the unit of measurement (kg, lb, etc.) used for product weight calculations. Returned only when you pass `"WEIGHT_MEASUREMENT_UNIT_INFO"` to the `fields` parameter. 
+                              - name: items[].productData.physicalProperties.weightMeasurementUnitInfo.weightMeasurementUnit  | type: WeightUnit | description:  Unit of measurement for weight.  Standard units include kilograms (KG), pounds (LB), ounces (OZ), and grams (G). 
+                                  enum: 
+                                       KG: Kilograms.
+                                       LB: Pounds.
+                                       UNSPECIFIED_WEIGHT_UNIT: Weight unit can't be classified due to an error.
+                - name: items[].revenueDetails  | type: V3RevenueDetails | description:  Revenue and cost details for business analytics.  Includes cost, profit, and profit margin calculations. Returned only when you pass `"MERCHANT_DATA"` to the `fields` parameter. 
+                    - name: items[].revenueDetails.cost  | type: V3FixedMonetaryAmount | description:  Cost of the variant for profit calculations.  The amount you pay to produce or acquire this variant. 
+                    - name: items[].revenueDetails.profit  | type: V3FixedMonetaryAmount | description:  Profit amount calculated by subtracting cost from the discounted price. 
+                    - name: items[].revenueDetails.profitMargin  | type: number | description:  Profit margin as a percentage of the selling price.  Calculated by dividing profit by the discounted price. The result is rounded to 4 decimal places. A value of 0.25 represents a 25% profit margin. 
+                - name: items[].sku  | type: string | description:  Stock keeping unit (SKU) for inventory tracking and identification.  The SKU is typically used for inventory management, order fulfillment, and product identification across different systems. 
+                - name: items[].subscriptionPricesInfo  | type: V3SubscriptionPricesInfo | description:  Subscription pricing information when the variant is part of subscription plans.  Shows calculated prices after applying subscription discounts to the variant's price. Returned only when you pass `"SUBSCRIPTION_PRICES_INFO"` to the `fields` parameter. 
+                    - name: items[].subscriptionPricesInfo.subscriptionPrices  | type: Array<V3SubscriptionPrice> | description:  Pricing for different subscription plans.  Shows how the variant's price changes with different subscription intervals or discounts. 
+                          - name: items[].subscriptionPricesInfo.subscriptionPrices[].price  | type: V3FixedMonetaryAmount | description:  Variant price with subscription discount applied. 
+                          - name: items[].subscriptionPricesInfo.subscriptionPrices[].pricePerUnit  | type: V3SubscriptionPricePerUnit | description:  Price per unit for subscription pricing. 
+                              - name: items[].subscriptionPricesInfo.subscriptionPrices[].pricePerUnit.description  | type: string | description:  Description of the subscription price per unit. 
+                              - name: items[].subscriptionPricesInfo.subscriptionPrices[].pricePerUnit.value  | type: string | description:  Calculated price per unit for the subscription.  Takes into account the subscription discount and the variant's price per unit settings. 
+                          - name: items[].subscriptionPricesInfo.subscriptionPrices[].subscriptionId  | type: string | description:  Subscription plan GUID. 
+                - name: items[].visible  | type: boolean | description:  Whether the variant is visible to site visitors.  Default: `true` 
+                - ONE-OF: 
+                  - name: items[].digitalProperties  | type: V3VariantDigitalProperties | description:  Digital properties such as downloadable files.  Required when the product type is `DIGITAL`. 
+                      - name: items[].digitalProperties.digitalFile  | type: V3SecuredMedia | description:  Digital file available for download after purchase.  The file that customers receive when they purchase this digital variant. 
+                          - name: items[].digitalProperties.digitalFile._id  | type: string | description:  Media GUID in media manager. 
+                          - name: items[].digitalProperties.digitalFile.fileName  | type: string | description:  Original file name. 
+                          - name: items[].digitalProperties.digitalFile.fileSize  | type: string | description:  Original file size. 
+                          - name: items[].digitalProperties.digitalFile.fileType  | type: SecuredMediaFileType | description:  File type. 
+                              enum: 
+                                   SECURE_ARCHIVE: Secure archive file.
+                                   SECURE_DOCUMENT: Secure document file.
+                                   SECURE_MUSIC: Secure music file.
+                                   SECURE_PICTURE: Secure picture file.
+                                   SECURE_VIDEO: Secure video file.
+                                   UNSPECIFIED: Unspecified file type.
+                  - name: items[].physicalProperties  | type: V3VariantPhysicalProperties | description:  Physical properties such as weight and dimensions.  Required when the product type is `PHYSICAL`. 
+                      - name: items[].physicalProperties.pricePerUnit  | type: V3PricePerUnit | description:  Price per unit measurement information.  Allows customers to compare prices based on a standard unit (like price per kilogram or per liter). Useful for bulk products or items sold by weight or volume. 
+                          - name: items[].physicalProperties.pricePerUnit.description  | type: string | description:  Human-readable description of the price per unit.  For example, "per kg" or "per liter". 
+                          - name: items[].physicalProperties.pricePerUnit.settings  | type: V3PricePerUnitSettings | description:  Price per unit measurement settings.  Defines the unit of measurement for price comparison (e.g., per kilogram, per liter). The measurement unit must correspond to the unit set on the parent product. 
+                              - name: items[].physicalProperties.pricePerUnit.settings.measurementUnit  | type: MeasurementUnit | description:  Measurement unit. For example, to define price per 100 grams, set this field to "G". 
+                                  enum: CBM, CL, CM, FLOZ, FT, G, GAL, IN, KG, L, LB, M, MG, ML, MM, OZ, PT, QT, SQFT, SQM, UNSPECIFIED, YD
+                              - name: items[].physicalProperties.pricePerUnit.settings.quantity  | type: number | description:  Quantity. For example, to define price per per 100 grams, set this field to `100`. 
+                          - name: items[].physicalProperties.pricePerUnit.value  | type: string | description:  Calculated price per unit value.  Shows the variant's price normalized to the standard unit of measurement. For example, if a 500g variant costs $2 and the standard unit is 1kg, this value would be $4. 
+                      - name: items[].physicalProperties.weight  | type: number | description:  Weight of the variant for shipping calculations.  Used for shipping cost calculations and fulfillment planning. Returned only when you pass `"WEIGHT_MEASUREMENT_UNIT_INFO"` to the `fields` parameter. 
+          - name: length  | type: number | description:  Returns the number of items in the current page of results.  `length` returns just the number of items in the current page, not the total number of items that match the query. The page size is defined by the [`limit()`](/variants-query-builder/limit) function and can be retrieved using the [`pageSize`](#page-size) property. You can use the [`next()`](#next) and [`prev()`](#prev) functions returned by `readOnlyVariantsV3` to navigate the pages of a query result. 
+          - name: pageSize  | type: number | description:  Returns the requested page size.  `pageSize` returns the page size set in [`limit()`](/variants-query-builder/limit) in `VariantsQueryBuilder`. 
+          - name: query  | type: VariantsQueryBuilder | description:  Returns the `VariantsQueryBuilder` object used to get the current results.  Use `query` to create and run a new query by chaining additional `VariantsQueryBuilder` functions to it. You can filter only on properties that haven't already been used in the previous `VariantsQueryBuilder`. 
+          Method: stores.readOnlyVariantsV3.hasNext()
+          Description: Indicates whether the query has more results.  You can use the [`next()`](#next) and [`prev()`](#prev) functions returned by `readOnlyVariantsV3` to navigate the pages of a query result.
+          Return type: PRIMITIVE<boolean>
+          Method: stores.readOnlyVariantsV3.hasPrev()
+          Description: Indicates whether the query has previous results.  You can use the [`next()`](#next) and [`prev()`](#prev) functions returned by `readOnlyVariantsV3` to navigate the pages of a query result.
+          Return type: PRIMITIVE<boolean>
+          Method: stores.readOnlyVariantsV3.queryVariants().next()
+          Description: Retrieves the next page of query results.  The `next()` function retrieves the next page of query results. The page size is defined by the [`limit()`](/variants-query-builder/limit) function and can be retrieved using the [`pageSize`](#page-size) property. You can use the [`next()`](#next) and [`prev()`](#prev) functions returned by `readOnlyVariantsV3` to navigate the pages of a query result. If items are added or removed between calls to `next()`, the values returned by `VariantsQueryBuilder` may change.
+          Return type: PROMISE<VariantsQueryResult>
+          Method: stores.readOnlyVariantsV3.queryVariants().prev()
+          Description: Retrieves the previous page of query results.  The `prev()` function retrieves the previous page of query results. The page size is defined by the [`limit()`](/variants-query-builder/limit) function and can be retrieved using the [`pageSize`](#page-size) property. You can use the [`next()`](#next) and [`prev()`](#prev) functions returned by `readOnlyVariantsV3` to navigate the pages of a query result. If items are added or removed between calls to `prev()`, the values returned may change.
+          Return type: PROMISE<VariantsQueryResult>
+    Method: stores.readOnlyVariantsV3.queryVariants().ge(propertyName, value)
+    Description: Refines a query to match items where the specified property is greater than or equal to the specified value.  The `ge()` function refines a `VariantsQueryBuilder` to match only items where the value of the specified `propertyName` is greater than or equal to the specified `value`. `ge()` matches only values of the same type. For example, `0` stored as a number doesn't match `'0'` stored as a string. If a property contains a number stored as a string (for example, `'0'`), that value is compared alphabetically and not numerically. If a property doesn't have a value, that value is ranked lowest. The following types of properties can be compared: - Number: Compares numerically. - Date: Compares JavaScript Date objects.  - String: Compares lexicographically, so `'abc'` is greater than `'ABC'`.
+    Method parameters:
+      param name:  propertyName | type: string | description:  Property whose value is compared with `value`. 
+      param name:  value | type: any | description:  Value to compare against. 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().gt(propertyName, value)
+    Description: Refines a query to match items where the specified property is greater than the specified value.  The `gt()` function refines a `VariantsQueryBuilder` to match only items where the value of the specified `propertyName` is greater than the specified `value`. `gt()` matches only values of the same type. For example, `0` stored as a number doesn't match `'0'` stored as a string. If a property contains a number stored as a string (for example, `'0'`), that value is compared alphabetically and not numerically. If a property doesn't have a value, that value is ranked lowest. The following types of properties can be compared: - Number: Compares numerically. - Date: Compares JavaScript Date objects.  - String: Compares lexicographically, so `'abc'` is greater than `'ABC'`.
+    Method parameters:
+      param name:  propertyName | type: string | description:  Property whose value is compared with `value`. 
+      param name:  value | type: any | description:  Value to compare against. 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().hasSome(propertyName, value)
+    Description: Refines a query to match items whose specified property contains any of the specified values.  The `hasSome()` function refines a `VariantsQueryBuilder` to match only items where the value of the specified `propertyName` equals any of the specified `values`. Matching strings with `hasSome()` is case-sensitive, so `'text'` isn't equal to `'Text'`. If the specified property is an array, `hasSome()` matches if any of that array's elements equal any of the specified values.
+    Method parameters:
+      param name:  propertyName | type: string | description:  Property whose value is compared with `values`. 
+      param name:  value | type: Array<any> | description:  none 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().in(propertyName, value)
+    Description: Refines a query to only match items where the specified property contains any of the values in the provided array of values.  The `in()` function refines a `VariantsQueryBuilder` to match only items where the specified `propertyName` is equal to any of the values in the provided array. Matching strings with `in()` is case-sensitive, so `'text'` isn't equal to `'Text'`.
+    Method parameters:
+      param name:  propertyName | type: string | description:  none 
+      param name:  value | type: any | description:  none 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().le(propertyName, value)
+    Description: Refines a query to match items where the specified property is less than or equal to the specified value.  The `le()` function refines a `VariantsQueryBuilder` to match only items where the value of the specified `propertyName` is less than or equal to the specified `value`. `le()` matches only values of the same type. For example, `0` stored as a number doesn't match `'0'` stored as a string. If a property contains a number stored as a string (for example, `'0'`), that value is compared alphabetically and not numerically. If a property doesn't have a value, that value is ranked lowest. The following types of properties can be compared: - Number: Compares numerically. - Date: Compares JavaScript Date objects.  - String: Compares lexicographically, so `'ABC'` is less than `'abc'`.
+    Method parameters:
+      param name:  propertyName | type: string | description:  Property whose value is compared with `value`. 
+      param name:  value | type: any | description:  Value to compare against. 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().limit(limit)
+    Description: Limits the number of items the query returns.  The `limit()` function defines the number of results a query returns in each page. Only one page of results is retrieved at a time. You can use the `next()` and `prev()` functions to navigate the pages of a query result.
+    Method parameters:
+      param name:  limit | type: number | description:  Number of items to return, which is also the `pageSize` of the results object. 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().lt(propertyName, value)
+    Description: Refines a query to match items where the specified property is less than the specified value.  The `le()` function refines a `VariantsQueryBuilder` to match only items where the value of the specified `propertyName` is less than the specified `value`. `le()` matches only values of the same type. For example, `0` stored as a number doesn't match `'0'` stored as a string. If a property contains a number stored as a string (for example, `'0'`), that value is compared alphabetically and not numerically. If a property doesn't have a value, that value is ranked lowest. The following types of properties can be compared: - Number: Compares numerically. - Date: Compares JavaScript Date objects.  - String: Compares lexicographically, so `'ABC'` is less than `'abc'`.
+    Method parameters:
+      param name:  propertyName | type: string | description:  Property whose value is compared with `value`. 
+      param name:  value | type: any | description:  Value to compare against. 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().ne(propertyName, value)
+    Description: Refines a query to match items where the specified property doesn't equal the specified value.  The `ne()` function refines a `VariantsQueryBuilder` to match only items where the value of the specified `propertyName` doesn't equal the specified `value`. `ne()` matches only values of the same type. For example, `0` stored as a number doesn't match `'0'` stored as a string. Matching strings with `ne()` is case-sensitive, so `'text'` isn't equal to `'Text'`.
+    Method parameters:
+      param name:  propertyName | type: string | description:  Property whose value is compared with `value`. 
+      param name:  value | type: any | description:  Value to compare against. 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().skipTo(cursor)
+    Description: Refines a query that skips to a specific record.  The `skipTo()` function refines a `VariantsQueryBuilder` to return items that appear before or after the item pointed to by the provided cursor. Get the relevant cursor for a specific item from the `cursors` object in previous call's response. Then you can skip to `cursors.prev` to return items before the cursor, or `cursors.next` to return items after the cursor.   When using `skipTo()`, the filters and the sorting order of the original query can't be changed. Only the `limit()` property of the query can be changed.
+    Method parameters:
+      param name:  cursor | type: string | description:  A pointer to specific record 
+    Return type: REFERENCE<VariantsQueryBuilder>
+    Method: stores.readOnlyVariantsV3.queryVariants().startsWith(propertyName, value)
+    Description: Refines a query to match items where the specified property starts with the specified value.  The `startsWith()` function refines a `VariantsQueryBuilder` to match only items where the value of the specified `propertyName` starts with the specified `string`. Matching with `startsWith()` is case-sensitive, so `'TEXT'` doesn't start with `'text'`. You can only use `startsWith()` with a property whose value is a string.
+    Method parameters:
+      param name:  propertyName | type: string | description:  Property whose value is compared with `string`. 
+      param name:  value | type: string | description:  none 
+    Return type: REFERENCE<VariantsQueryBuilder>
+
+```
+</type_definition>
+</stores_readOnlyVariantsV3_queryVariants>