@deenruv/core 1.0.0

package/dist/config/auth/default-password-validation-strategy.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultPasswordValidationStrategy = void 0;
+/**
+ * @description
+ * The DefaultPasswordValidationStrategy allows you to specify a minimum length and/or
+ * a regular expression to match passwords against.
+ *
+ * TODO:
+ * By default, the `minLength` will be set to `4`. This is rather permissive and is only
+ * this way in order to reduce the risk of backward-compatibility breaks. In the next major version
+ * this default will be made more strict.
+ *
+ * @docsCategory auth
+ * @since 1.5.0
+ */
+class DefaultPasswordValidationStrategy {
+    constructor(options) {
+        this.options = options;
+    }
+    validate(ctx, password) {
+        const { minLength, regexp } = this.options;
+        if (minLength != null) {
+            if (password.length < minLength) {
+                return false;
+            }
+        }
+        if (regexp != null) {
+            if (!regexp.test(password)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.DefaultPasswordValidationStrategy = DefaultPasswordValidationStrategy;
+//# sourceMappingURL=default-password-validation-strategy.js.map

package/dist/config/auth/default-password-validation-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-password-validation-strategy.js","sourceRoot":"","sources":["../../../src/config/auth/default-password-validation-strategy.ts"],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;GAYG;AACH,MAAa,iCAAiC;IAC5C,YAAoB,OAAgD;QAAhD,YAAO,GAAP,OAAO,CAAyC;IAAG,CAAC;IAExE,QAAQ,CAAC,GAAmB,EAAE,QAAgB;QAC5C,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAC3C,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;YACtB,IAAI,QAAQ,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;gBAChC,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;QACD,IAAI,MAAM,IAAI,IAAI,EAAE,CAAC;YACnB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC3B,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAjBD,8EAiBC"}

package/dist/config/auth/native-authentication-strategy.d.ts

@@ -0,0 +1,32 @@
+import { ID } from "@deenruv/common/lib/shared-types";
+import { DocumentNode } from "graphql";
+import { RequestContext } from "../../api/common/request-context";
+import { Injector } from "../../common/injector";
+import { User } from "../../entity/user/user.entity";
+import { AuthenticationStrategy } from "./authentication-strategy";
+export interface NativeAuthenticationData {
+    username: string;
+    password: string;
+}
+export declare const NATIVE_AUTH_STRATEGY_NAME = "native";
+/**
+ * @description
+ * This strategy implements a username/password credential-based authentication, with the credentials
+ * being stored in the Deenruv database. This is the default method of authentication, and it is advised
+ * to keep it configured unless there is a specific reason not to.
+ *
+ * @docsCategory auth
+ */
+export declare class NativeAuthenticationStrategy implements AuthenticationStrategy<NativeAuthenticationData> {
+    readonly name = "native";
+    private connection;
+    private passwordCipher;
+    private userService;
+    init(injector: Injector): Promise<void>;
+    defineInputType(): DocumentNode;
+    authenticate(ctx: RequestContext, data: NativeAuthenticationData): Promise<User | false>;
+    /**
+     * Verify the provided password against the one we have for the given user.
+     */
+    verifyUserPassword(ctx: RequestContext, userId: ID, password: string): Promise<boolean>;
+}

package/dist/config/auth/native-authentication-strategy.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeAuthenticationStrategy = exports.NATIVE_AUTH_STRATEGY_NAME = void 0;
+const graphql_tag_1 = __importDefault(require("graphql-tag"));
+const transactional_connection_1 = require("../../connection/transactional-connection");
+const native_authentication_method_entity_1 = require("../../entity/authentication-method/native-authentication-method.entity");
+const user_entity_1 = require("../../entity/user/user.entity");
+exports.NATIVE_AUTH_STRATEGY_NAME = "native";
+/**
+ * @description
+ * This strategy implements a username/password credential-based authentication, with the credentials
+ * being stored in the Deenruv database. This is the default method of authentication, and it is advised
+ * to keep it configured unless there is a specific reason not to.
+ *
+ * @docsCategory auth
+ */
+class NativeAuthenticationStrategy {
+    constructor() {
+        this.name = exports.NATIVE_AUTH_STRATEGY_NAME;
+    }
+    async init(injector) {
+        this.connection = injector.get(transactional_connection_1.TransactionalConnection);
+        // These are lazily-loaded to avoid a circular dependency
+        const { PasswordCipher } = await import("../../service/helpers/password-cipher/password-cipher.js");
+        const { UserService } = await import("../../service/services/user.service.js");
+        this.passwordCipher = injector.get(PasswordCipher);
+        this.userService = injector.get(UserService);
+    }
+    defineInputType() {
+        return (0, graphql_tag_1.default) `
+      input NativeAuthInput {
+        username: String!
+        password: String!
+      }
+    `;
+    }
+    async authenticate(ctx, data) {
+        const user = await this.userService.getUserByEmailAddress(ctx, data.username);
+        if (!user) {
+            return false;
+        }
+        const passwordMatch = await this.verifyUserPassword(ctx, user.id, data.password);
+        if (!passwordMatch) {
+            return false;
+        }
+        return user;
+    }
+    /**
+     * Verify the provided password against the one we have for the given user.
+     */
+    async verifyUserPassword(ctx, userId, password) {
+        var _a, _b;
+        const user = await this.connection.getRepository(ctx, user_entity_1.User).findOne({
+            where: { id: userId },
+            relations: ["authenticationMethods"],
+        });
+        if (!user) {
+            return false;
+        }
+        const nativeAuthMethod = user.getNativeAuthenticationMethod(false);
+        if (!nativeAuthMethod) {
+            return false;
+        }
+        const pw = (_b = (_a = (await this.connection
+            .getRepository(ctx, native_authentication_method_entity_1.NativeAuthenticationMethod)
+            .findOne({
+            where: { id: nativeAuthMethod.id },
+            select: ["passwordHash"],
+        }))) === null || _a === void 0 ? void 0 : _a.passwordHash) !== null && _b !== void 0 ? _b : "";
+        const passwordMatches = await this.passwordCipher.check(password, pw);
+        if (!passwordMatches) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.NativeAuthenticationStrategy = NativeAuthenticationStrategy;
+//# sourceMappingURL=native-authentication-strategy.js.map

package/dist/config/auth/native-authentication-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-authentication-strategy.js","sourceRoot":"","sources":["../../../src/config/auth/native-authentication-strategy.ts"],"names":[],"mappings":";;;;;;AAEA,8DAA8B;AAI9B,wFAAoF;AACpF,gIAAoH;AACpH,+DAAqD;AASxC,QAAA,yBAAyB,GAAG,QAAQ,CAAC;AAElD;;;;;;;GAOG;AACH,MAAa,4BAA4B;IAAzC;QACW,SAAI,GAAG,iCAAyB,CAAC;IAkF5C,CAAC;IA5EC,KAAK,CAAC,IAAI,CAAC,QAAkB;QAC3B,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,kDAAuB,CAAC,CAAC;QACxD,yDAAyD;QACzD,MAAM,EAAE,cAAc,EAAE,GACtB,MAAM,MAAM,CAAC,0DAA0D,CAAC,CAAC;QAC3E,MAAM,EAAE,WAAW,EAAE,GACnB,MAAM,MAAM,CAAC,wCAAwC,CAAC,CAAC;QACzD,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QACnD,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC/C,CAAC;IAED,eAAe;QACb,OAAO,IAAA,qBAAG,EAAA;;;;;KAKT,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,YAAY,CAChB,GAAmB,EACnB,IAA8B;QAE9B,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,qBAAqB,CACvD,GAAG,EACH,IAAI,CAAC,QAAQ,CACd,CAAC;QACF,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,kBAAkB,CACjD,GAAG,EACH,IAAI,CAAC,EAAE,EACP,IAAI,CAAC,QAAQ,CACd,CAAC;QACF,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,kBAAkB,CACtB,GAAmB,EACnB,MAAU,EACV,QAAgB;;QAEhB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,GAAG,EAAE,kBAAI,CAAC,CAAC,OAAO,CAAC;YAClE,KAAK,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE;YACrB,SAAS,EAAE,CAAC,uBAAuB,CAAC;SACrC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,gBAAgB,GAAG,IAAI,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC;QACnE,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,EAAE,GACN,MAAA,MAAA,CACE,MAAM,IAAI,CAAC,UAAU;aAClB,aAAa,CAAC,GAAG,EAAE,gEAA0B,CAAC;aAC9C,OAAO,CAAC;YACP,KAAK,EAAE,EAAE,EAAE,EAAE,gBAAgB,CAAC,EAAE,EAAE;YAClC,MAAM,EAAE,CAAC,cAAc,CAAC;SACzB,CAAC,CACL,0CAAE,YAAY,mCAAI,EAAE,CAAC;QACxB,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QACtE,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAnFD,oEAmFC"}

package/dist/config/auth/password-hashing-strategy.d.ts

@@ -0,0 +1,19 @@
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+/**
+ * @description
+ * Defines how user passwords get hashed when using the {@link NativeAuthenticationStrategy}.
+ *
+ * :::info
+ *
+ * This is configured via the `authOptions.passwordHashingStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @docsCategory auth
+ * @since 1.3.0
+ */
+export interface PasswordHashingStrategy extends InjectableStrategy {
+    hash(plaintext: string): Promise<string>;
+    check(plaintext: string, hash: string): Promise<boolean>;
+}

package/dist/config/auth/password-hashing-strategy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=password-hashing-strategy.js.map

package/dist/config/auth/password-hashing-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-hashing-strategy.js","sourceRoot":"","sources":["../../../src/config/auth/password-hashing-strategy.ts"],"names":[],"mappings":""}

package/dist/config/auth/password-validation-strategy.d.ts

@@ -0,0 +1,29 @@
+import { RequestContext } from "../../api/common/request-context";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+/**
+ * @description
+ * Defines validation to apply to new password (when creating an account or updating an existing account's
+ * password when using the {@link NativeAuthenticationStrategy}.
+ *
+ * :::info
+ *
+ * This is configured via the `authOptions.passwordValidationStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @docsCategory auth
+ * @since 1.5.0
+ */
+export interface PasswordValidationStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * Validates a password submitted during account registration or when a customer updates their password.
+     * The method should resolve to `true` if the password is acceptable. If not, it should return `false` or
+     * optionally a string which will be passed to the returned ErrorResult, which can e.g. advise on why
+     * exactly the proposed password is not valid.
+     *
+     * @since 1.5.0
+     */
+    validate(ctx: RequestContext, password: string): Promise<boolean | string> | boolean | string;
+}

package/dist/config/auth/password-validation-strategy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=password-validation-strategy.js.map

package/dist/config/auth/password-validation-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-validation-strategy.js","sourceRoot":"","sources":["../../../src/config/auth/password-validation-strategy.ts"],"names":[],"mappings":""}

package/dist/config/catalog/collection-filter.d.ts

@@ -0,0 +1,56 @@
+import { ConfigArg } from "@deenruv/common/lib/generated-types";
+import { SelectQueryBuilder } from "typeorm";
+import { ConfigArgs, ConfigArgValues, ConfigurableOperationDef, ConfigurableOperationDefOptions } from "../../common/configurable-operation";
+import { ProductVariant } from "../../entity/product-variant/product-variant.entity";
+export type ApplyCollectionFilterFn<T extends ConfigArgs> = (qb: SelectQueryBuilder<ProductVariant>, args: ConfigArgValues<T>) => SelectQueryBuilder<ProductVariant>;
+export interface CollectionFilterConfig<T extends ConfigArgs> extends ConfigurableOperationDefOptions<T> {
+    apply: ApplyCollectionFilterFn<T>;
+}
+/**
+ * @description
+ * A CollectionFilter defines a rule which can be used to associate ProductVariants with a Collection.
+ * The filtering is done by defining the `apply()` function, which receives a TypeORM
+ * [`QueryBuilder`](https://typeorm.io/#/select-query-builder) object to which clauses may be added.
+ *
+ * Creating a CollectionFilter is considered an advanced Deenruv topic. For more insight into how
+ * they work, study the [default collection filters](https://github.com/deenruv-ecommerce/deenruv/blob/master/packages/core/src/config/catalog/default-collection-filters.ts)
+ *
+ * Here's a simple example of a custom CollectionFilter:
+ *
+ * @example
+ * ```ts
+ * import { CollectionFilter, LanguageCode } from '\@deenruv/core';
+ *
+ * export const skuCollectionFilter = new CollectionFilter({
+ *   args: {
+ *     // The `args` object defines the user-configurable arguments
+ *     // which will get passed to the filter's `apply()` function.
+ *     sku: {
+ *       type: 'string',
+ *       label: [{ languageCode: LanguageCode.en, value: 'SKU' }],
+ *       description: [
+ *         {
+ *           languageCode: LanguageCode.en,
+ *           value: 'Matches any product variants with SKUs containing this value',
+ *         },
+ *       ],
+ *     },
+ *   },
+ *   code: 'variant-sku-filter',
+ *   description: [{ languageCode: LanguageCode.en, value: 'Filter by matching SKU' }],
+ *
+ *   // This is the function that defines the logic of the filter.
+ *   apply: (qb, args) => {
+ *     const LIKE = qb.connection.options.type === 'postgres' ? 'ILIKE' : 'LIKE';
+ *     return qb.andWhere(`productVariant.sku ${LIKE} :sku`, { sku: `%${args.sku}%` });
+ *   },
+ * });
+ * ```
+ *
+ * @docsCategory configuration
+ */
+export declare class CollectionFilter<T extends ConfigArgs = ConfigArgs> extends ConfigurableOperationDef<T> {
+    private readonly applyFn;
+    constructor(config: CollectionFilterConfig<T>);
+    apply(qb: SelectQueryBuilder<ProductVariant>, args: ConfigArg[]): SelectQueryBuilder<ProductVariant>;
+}

package/dist/config/catalog/collection-filter.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionFilter = void 0;
+const configurable_operation_1 = require("../../common/configurable-operation");
+/**
+ * @description
+ * A CollectionFilter defines a rule which can be used to associate ProductVariants with a Collection.
+ * The filtering is done by defining the `apply()` function, which receives a TypeORM
+ * [`QueryBuilder`](https://typeorm.io/#/select-query-builder) object to which clauses may be added.
+ *
+ * Creating a CollectionFilter is considered an advanced Deenruv topic. For more insight into how
+ * they work, study the [default collection filters](https://github.com/deenruv-ecommerce/deenruv/blob/master/packages/core/src/config/catalog/default-collection-filters.ts)
+ *
+ * Here's a simple example of a custom CollectionFilter:
+ *
+ * @example
+ * ```ts
+ * import { CollectionFilter, LanguageCode } from '\@deenruv/core';
+ *
+ * export const skuCollectionFilter = new CollectionFilter({
+ *   args: {
+ *     // The `args` object defines the user-configurable arguments
+ *     // which will get passed to the filter's `apply()` function.
+ *     sku: {
+ *       type: 'string',
+ *       label: [{ languageCode: LanguageCode.en, value: 'SKU' }],
+ *       description: [
+ *         {
+ *           languageCode: LanguageCode.en,
+ *           value: 'Matches any product variants with SKUs containing this value',
+ *         },
+ *       ],
+ *     },
+ *   },
+ *   code: 'variant-sku-filter',
+ *   description: [{ languageCode: LanguageCode.en, value: 'Filter by matching SKU' }],
+ *
+ *   // This is the function that defines the logic of the filter.
+ *   apply: (qb, args) => {
+ *     const LIKE = qb.connection.options.type === 'postgres' ? 'ILIKE' : 'LIKE';
+ *     return qb.andWhere(`productVariant.sku ${LIKE} :sku`, { sku: `%${args.sku}%` });
+ *   },
+ * });
+ * ```
+ *
+ * @docsCategory configuration
+ */
+class CollectionFilter extends configurable_operation_1.ConfigurableOperationDef {
+    constructor(config) {
+        super(config);
+        this.applyFn = config.apply;
+    }
+    apply(qb, args) {
+        return this.applyFn(qb, this.argsArrayToHash(args));
+    }
+}
+exports.CollectionFilter = CollectionFilter;
+//# sourceMappingURL=collection-filter.js.map

package/dist/config/catalog/collection-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection-filter.js","sourceRoot":"","sources":["../../../src/config/catalog/collection-filter.ts"],"names":[],"mappings":";;;AAGA,gFAK6C;AAc7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAa,gBAEX,SAAQ,iDAA2B;IAEnC,YAAY,MAAiC;QAC3C,KAAK,CAAC,MAAM,CAAC,CAAC;QACd,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC;IAC9B,CAAC;IAED,KAAK,CACH,EAAsC,EACtC,IAAiB;QAEjB,OAAO,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;IACtD,CAAC;CACF;AAfD,4CAeC"}

package/dist/config/catalog/default-collection-filters.d.ts

@@ -0,0 +1,155 @@
+import { LanguageCode } from "@deenruv/common/lib/generated-types";
+import { ConfigArgDef } from "../../common/configurable-operation";
+import { CollectionFilter } from "./collection-filter";
+/**
+ * @description
+ * Used to created unique key names for DB query parameters, to avoid conflicts if the
+ * same filter is applied multiple times.
+ */
+export declare function randomSuffix(prefix: string): string;
+/**
+ * @description
+ * Add this to your CollectionFilter `args` object to display the standard UI component
+ * for selecting the combination mode when working with multiple filters.
+ */
+export declare const combineWithAndArg: ConfigArgDef<"boolean">;
+/**
+ * Filters for ProductVariants having the given facetValueIds (including parent Product)
+ */
+export declare const facetValueCollectionFilter: CollectionFilter<{
+    facetValueIds: {
+        type: "ID";
+        list: true;
+        ui: {
+            component: string;
+        };
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+    };
+    containsAny: {
+        type: "boolean";
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+        description: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+    };
+    combineWithAnd: import("../../common/configurable-operation").ConfigArgCommonDef<"boolean"> & import("../../common/configurable-operation").WithArgConfig<never>;
+}>;
+export declare const variantNameCollectionFilter: CollectionFilter<{
+    operator: {
+        type: "string";
+        ui: {
+            component: string;
+            options: {
+                value: string;
+            }[];
+        };
+    };
+    term: {
+        type: "string";
+    };
+    combineWithAnd: import("../../common/configurable-operation").ConfigArgCommonDef<"boolean"> & import("../../common/configurable-operation").WithArgConfig<never>;
+}>;
+export declare const variantIdCollectionFilter: CollectionFilter<{
+    variantIds: {
+        type: "ID";
+        list: true;
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+        ui: {
+            component: string;
+            selectionMode: string;
+        };
+    };
+    combineWithAnd: import("../../common/configurable-operation").ConfigArgCommonDef<"boolean"> & import("../../common/configurable-operation").WithArgConfig<never>;
+}>;
+export declare const productIdCollectionFilter: CollectionFilter<{
+    productIds: {
+        type: "ID";
+        list: true;
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+        ui: {
+            component: string;
+            selectionMode: string;
+        };
+    };
+    combineWithAnd: import("../../common/configurable-operation").ConfigArgCommonDef<"boolean"> & import("../../common/configurable-operation").WithArgConfig<never>;
+}>;
+export declare const defaultCollectionFilters: (CollectionFilter<{
+    facetValueIds: {
+        type: "ID";
+        list: true;
+        ui: {
+            component: string;
+        };
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+    };
+    containsAny: {
+        type: "boolean";
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+        description: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+    };
+    combineWithAnd: import("../../common/configurable-operation").ConfigArgCommonDef<"boolean"> & import("../../common/configurable-operation").WithArgConfig<never>;
+}> | CollectionFilter<{
+    operator: {
+        type: "string";
+        ui: {
+            component: string;
+            options: {
+                value: string;
+            }[];
+        };
+    };
+    term: {
+        type: "string";
+    };
+    combineWithAnd: import("../../common/configurable-operation").ConfigArgCommonDef<"boolean"> & import("../../common/configurable-operation").WithArgConfig<never>;
+}> | CollectionFilter<{
+    variantIds: {
+        type: "ID";
+        list: true;
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+        ui: {
+            component: string;
+            selectionMode: string;
+        };
+    };
+    combineWithAnd: import("../../common/configurable-operation").ConfigArgCommonDef<"boolean"> & import("../../common/configurable-operation").WithArgConfig<never>;
+}> | CollectionFilter<{
+    productIds: {
+        type: "ID";
+        list: true;
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+        ui: {
+            component: string;
+            selectionMode: string;
+        };
+    };
+    combineWithAnd: import("../../common/configurable-operation").ConfigArgCommonDef<"boolean"> & import("../../common/configurable-operation").WithArgConfig<never>;
+}>)[];