@infrab4a/connect 4.1.0-beta.0 → 4.1.0-beta.1

package/{fesm2022 → fesm2020}/infrab4a-connect.mjs

@@ -257,6 +257,12 @@ var UserType;
     UserType["Influencer"] = "Influencer";
 })(UserType || (UserType = {}));
 
+class Edition extends BaseModel {
+    static get identifiersFields() {
+        return ['id', 'subscriptionId'];
+    }
+}
+
 var BillingStatus;
 (function (BillingStatus) {
     BillingStatus["PAYED"] = "PAGO";
@@ -281,12 +287,6 @@ var Status;
     Status["CANCELLED"] = "Cancelado";
 })(Status || (Status = {}));
 
-class Edition extends BaseModel {
-    static get identifiersFields() {
-        return ['id', 'subscriptionId'];
-    }
-}
-
 class Payment extends BaseModel {
     static get identifiersFields() {
         return ['id'];
@@ -602,7 +602,6 @@ class ReflectHelper {
                 return true;
         });
     }
-    static { this._items = {}; }
     static put({ key, target, property, value, propertyDescriptor }) {
         const index = target.constructor.name;
         ReflectHelper.items[key] = ReflectHelper.items[key] || {};
@@ -633,9 +632,9 @@ class ReflectHelper {
             return false;
     }
 }
+ReflectHelper._items = {};
 
 class DebugDecoratorHelper {
-    static { this.DebugNamingMetadataKey = 'model:naming:decorator'; }
     static set(target, options) {
         ReflectHelper.add({
             key: DebugDecoratorHelper.DebugNamingMetadataKey,
@@ -650,6 +649,7 @@ class DebugDecoratorHelper {
         });
     }
 }
+DebugDecoratorHelper.DebugNamingMetadataKey = 'model:naming:decorator';
 
 class ClassNameHelper {
     static get(clazz) {
@@ -669,10 +669,10 @@ const isDebuggable = (object) => {
     return 'debug' in object;
 };
 class DebugHelper {
-    static { this.logs$ = new Subject(); }
-    static { this.traces$ = new Subject(); }
-    static { this.errors$ = new Subject(); }
-    static { this.isDebuggable = isDebuggable; }
+    constructor(...namespace) {
+        this.namespaces = new Set();
+        this.push(...namespace);
+    }
     static namespacesFor(target) {
         if (isNil(target))
             return [];
@@ -726,10 +726,6 @@ class DebugHelper {
         DebugHelper.replace(target, { with: debug });
         return { original, debug };
     }
-    constructor(...namespace) {
-        this.namespaces = new Set();
-        this.push(...namespace);
-    }
     get entries() {
         return Array.from(get$1(this, 'namespaces', []));
     }
@@ -809,6 +805,10 @@ class DebugHelper {
         return [`[${this.namespace}]`, ...args].join(' ');
     }
 }
+DebugHelper.logs$ = new Subject();
+DebugHelper.traces$ = new Subject();
+DebugHelper.errors$ = new Subject();
+DebugHelper.isDebuggable = isDebuggable;
 
 function Debug(opts) {
     return function (target) {
@@ -1072,130 +1072,6 @@ __decorate([
     __metadata("design:type", Array)
 ], Subscription.prototype, "payment", void 0);
 
-class UserPaymentMethod extends BaseModel {
-    static get identifiersFields() {
-        return ['id', 'userId'];
-    }
-}
-
-class Lead extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class UnauthorizedError extends CustomError {
-    constructor(message) {
-        super(message);
-    }
-}
-
-var SignInMethods;
-(function (SignInMethods) {
-    SignInMethods["EMAIL_PASSWORD"] = "email_password";
-    SignInMethods["GOOGLE"] = "google";
-})(SignInMethods || (SignInMethods = {}));
-class Authentication {
-    constructor(authService, userRepository) {
-        this.authService = authService;
-        this.userRepository = userRepository;
-    }
-    async signIn({ email, password }, signInMethod) {
-        const method = this.getServiceByMethod(signInMethod);
-        const userAuth = await this.authService[method]({ email, password });
-        const user = this.userRepository.get({ id: userAuth.id });
-        if (!isNil(user))
-            return user;
-        if (/^.+@b4a.com.br$/.test(userAuth.email))
-            return this.createsUserByCredential(userAuth);
-        throw new UnauthorizedError('Invalid credentials');
-    }
-    getServiceByMethod(signInMethod) {
-        return signInMethod === SignInMethods.EMAIL_PASSWORD ? 'signInWithEmailAndPassword' : 'signInWithGoogle';
-    }
-    async createsUserByCredential(user) {
-        const [firstName, lastName] = user.displayName?.split(/\s/);
-        const person = User.toInstance({
-            ...user,
-            cpf: '',
-            birthday: new Date(),
-            firstName,
-            lastName,
-            acceptsNewsletter: false,
-            area: Area.Transactional,
-            officePosition: OfficePosition.Intern,
-            type: UserType.Collaborator,
-        });
-        return this.userRepository.create(person);
-    }
-}
-
-class UserAlreadyRegisteredError extends CustomError {
-    constructor(message) {
-        super(message);
-    }
-}
-
-class WeakPasswordError extends CustomError {
-    constructor(message = 'Weak password') {
-        super(message);
-    }
-}
-
-class Register {
-    constructor(registerService, userRepository) {
-        this.registerService = registerService;
-        this.userRepository = userRepository;
-    }
-    async register(params) {
-        const email = params.email.toLocaleLowerCase();
-        const displayName = `${params.firstName} ${params.lastName}`;
-        if (await this.userRepository.checkIfExistsByField('cpf', params.cpf))
-            throw new UserAlreadyRegisteredError(`Usuário com CPF ${params.cpf} já registrado.`);
-        if (await this.userRepository.checkIfExistsByField('email', params.email))
-            throw new UserAlreadyRegisteredError(`Usuário com e-mail ${params.email} já registrado.`);
-        const auth = await this.registerService.register({
-            birthday: params.birthday,
-            email,
-            firstName: params.firstName,
-            lastName: params.lastName,
-            cpf: params.cpf,
-            displayName,
-            phone: params.phone,
-            password: params.password,
-        });
-        delete params.password;
-        const user = await this.userRepository.create({
-            ...params,
-            id: auth.id,
-            email,
-            displayName,
-            type: UserType.B2C,
-            dateCreated: new Date(),
-            dateModified: new Date(),
-        });
-        return user;
-    }
-}
-
-class SignOut {
-    constructor(authService) {
-        this.authService = authService;
-    }
-    async signOut() {
-        await this.authService.signOut();
-    }
-}
-
-class RecoveryPassword {
-    constructor(authService) {
-        this.authService = authService;
-    }
-    async sendEmail(email) {
-        await this.authService.sendPasswordResetEmail(email);
-    }
-}
-
 class Filter extends BaseModel {
     static get identifiersFields() {
         return ['id'];
@@ -1463,6 +1339,164 @@ __decorate([
     __metadata("design:type", Coupon)
 ], CheckoutSubscription.prototype, "coupon", void 0);
 
+class SubscriptionMaterialization extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+__decorate([
+    Type(() => User),
+    __metadata("design:type", User)
+], SubscriptionMaterialization.prototype, "user", void 0);
+__decorate([
+    Type(() => SubscriptionPlan),
+    __metadata("design:type", SubscriptionPlan)
+], SubscriptionMaterialization.prototype, "subscriptionPlan", void 0);
+__decorate([
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
+], SubscriptionMaterialization.prototype, "shippingAddress", void 0);
+__decorate([
+    Type(() => UserAddress),
+    __metadata("design:type", UserAddress)
+], SubscriptionMaterialization.prototype, "billingAddress", void 0);
+__decorate([
+    Type(() => Coupon),
+    __metadata("design:type", Coupon)
+], SubscriptionMaterialization.prototype, "coupon", void 0);
+__decorate([
+    Type(() => Edition),
+    __metadata("design:type", Array)
+], SubscriptionMaterialization.prototype, "editions", void 0);
+__decorate([
+    Type(() => SubscriptionPayment),
+    __metadata("design:type", SubscriptionPayment)
+], SubscriptionMaterialization.prototype, "payment", void 0);
+
+class UserPaymentMethod extends BaseModel {
+    static get identifiersFields() {
+        return ['id', 'userId'];
+    }
+}
+
+class Lead extends BaseModel {
+    static get identifiersFields() {
+        return ['id'];
+    }
+}
+
+class UnauthorizedError extends CustomError {
+    constructor(message) {
+        super(message);
+    }
+}
+
+var SignInMethods;
+(function (SignInMethods) {
+    SignInMethods["EMAIL_PASSWORD"] = "email_password";
+    SignInMethods["GOOGLE"] = "google";
+})(SignInMethods || (SignInMethods = {}));
+class Authentication {
+    constructor(authService, userRepository) {
+        this.authService = authService;
+        this.userRepository = userRepository;
+    }
+    async signIn({ email, password }, signInMethod) {
+        const method = this.getServiceByMethod(signInMethod);
+        const userAuth = await this.authService[method]({ email, password });
+        const user = this.userRepository.get({ id: userAuth.id });
+        if (!isNil(user))
+            return user;
+        if (/^.+@b4a.com.br$/.test(userAuth.email))
+            return this.createsUserByCredential(userAuth);
+        throw new UnauthorizedError('Invalid credentials');
+    }
+    getServiceByMethod(signInMethod) {
+        return signInMethod === SignInMethods.EMAIL_PASSWORD ? 'signInWithEmailAndPassword' : 'signInWithGoogle';
+    }
+    async createsUserByCredential(user) {
+        const [firstName, lastName] = user.displayName?.split(/\s/);
+        const person = User.toInstance({
+            ...user,
+            cpf: '',
+            birthday: new Date(),
+            firstName,
+            lastName,
+            acceptsNewsletter: false,
+            area: Area.Transactional,
+            officePosition: OfficePosition.Intern,
+            type: UserType.Collaborator,
+        });
+        return this.userRepository.create(person);
+    }
+}
+
+class UserAlreadyRegisteredError extends CustomError {
+    constructor(message) {
+        super(message);
+    }
+}
+
+class WeakPasswordError extends CustomError {
+    constructor(message = 'Weak password') {
+        super(message);
+    }
+}
+
+class Register {
+    constructor(registerService, userRepository) {
+        this.registerService = registerService;
+        this.userRepository = userRepository;
+    }
+    async register(params) {
+        const email = params.email.toLocaleLowerCase();
+        const displayName = `${params.firstName} ${params.lastName}`;
+        if (await this.userRepository.checkIfExistsByField('cpf', params.cpf))
+            throw new UserAlreadyRegisteredError(`Usuário com CPF ${params.cpf} já registrado.`);
+        if (await this.userRepository.checkIfExistsByField('email', params.email))
+            throw new UserAlreadyRegisteredError(`Usuário com e-mail ${params.email} já registrado.`);
+        const auth = await this.registerService.register({
+            birthday: params.birthday,
+            email,
+            firstName: params.firstName,
+            lastName: params.lastName,
+            cpf: params.cpf,
+            displayName,
+            phone: params.phone,
+            password: params.password,
+        });
+        delete params.password;
+        const user = await this.userRepository.create({
+            ...params,
+            id: auth.id,
+            email,
+            displayName,
+            type: UserType.B2C,
+            dateCreated: new Date(),
+            dateModified: new Date(),
+        });
+        return user;
+    }
+}
+
+class SignOut {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    async signOut() {
+        await this.authService.signOut();
+    }
+}
+
+class RecoveryPassword {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    async sendEmail(email) {
+        await this.authService.sendPasswordResetEmail(email);
+    }
+}
+
 class RoundProductPricesHelper {
     static roundProductPrices(product) {
         product.price.price = Number(product.price.price.toFixed(2));
@@ -1519,27 +1553,6 @@ var QuestionsFilters;
     QuestionsFilters["PRODUCT_SPENT"] = "Qual \u00E9 o seu nivel de gasto mensal em produtos de beleza e cuidados pessoais?";
 })(QuestionsFilters || (QuestionsFilters = {}));
 
-var ShopPageName;
-(function (ShopPageName) {
-    ShopPageName["LP_CLUB"] = "LP_CLUBE";
-    ShopPageName["SUBSCRIBER_PANEL"] = "SUBSCRIBER_PANEL";
-    ShopPageName["INVITE_FRIENDS"] = "INVITE_FRIENDS";
-    ShopPageName["INVITE_AND_WIN"] = "INVITE_AND_WIN";
-    ShopPageName["WIN_GLAMPOINTS"] = "WIN_GLAMPOINTS";
-    ShopPageName["POSTS"] = "POSTS";
-    ShopPageName["GLAMPOINTS_SHOWCASE"] = "GLAMPOINTS_SHOWCASE";
-    ShopPageName["LP_EDITIONS"] = "LP_EDITIONS";
-    ShopPageName["LP_GLAMBOX_EDITION"] = "LP_GLAMBOX_EDITION";
-    ShopPageName["LP_GLAMBOX_PROMOTION"] = "LP_GLAMBOX_PROMOTION";
-    ShopPageName["LP_GLAMBAG_PROMOTION"] = "LP_GLAMBAG_PROMOTION";
-    ShopPageName["LP_GLAMPASS_PROMOTION"] = "LP_GLAMPASS_PROMOTION";
-    ShopPageName["LP_SUBSCRIPTION_PROMOTION"] = "LP_SUBSCRIPTION_PROMOTION";
-    ShopPageName["LP_GLAMPARTNER_PROMOTION"] = "LP_GLAMPARTNER_PROMOTION";
-    ShopPageName["LP_GLAMQUEENS"] = "LP_GLAMQUEENS";
-    ShopPageName["LP_INVITE"] = "LP_INVITE";
-    ShopPageName["LP_LIVELO"] = "LP_LIVELO";
-})(ShopPageName || (ShopPageName = {}));
-
 class BeautyQuestionsHelper {
     static getAnswers(filter) {
         switch (filter) {
@@ -1585,18 +1598,6 @@ class BeautyQuestionsHelper {
     }
 }
 
-class Campaign extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
-class CampaignBanner extends BaseModel {
-    static get identifiersFields() {
-        return ['id'];
-    }
-}
-
 class Home extends BaseModel {
     static get identifiersFields() {
         return ['id'];
@@ -2186,6 +2187,17 @@ class SubscriptionFirestoreRepository extends withCrudFirestore(withHelpers(with
     }
 }
 
+class SubscriptionMaterializationFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
+    constructor({ firestore, interceptors }) {
+        super({
+            firestore,
+            collectionName: 'subscriptionMaterialization',
+            model: SubscriptionMaterialization,
+            interceptors,
+        });
+    }
+}
+
 class SubscriptionPaymentFirestoreRepository extends withSubCollection(withCrudFirestore(withHelpers(withFirestore(Base))), Subscription) {
     constructor({ firestore, interceptors }, parentRepository) {
         super({
@@ -2572,28 +2584,6 @@ class SubscriptionPlanFirestoreRepository extends withCrudFirestore(withHelpers(
     }
 }
 
-class CampaignBannerFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor({ firestore, interceptors, }) {
-        super({
-            firestore,
-            collectionName: 'banners',
-            model: CampaignBanner,
-            interceptors,
-        });
-    }
-}
-
-class CampaignFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
-    constructor({ firestore, interceptors }) {
-        super({
-            firestore,
-            collectionName: 'campaigns',
-            model: Campaign,
-            interceptors,
-        });
-    }
-}
-
 class HomeFirestoreRepository extends withCrudFirestore(withHelpers(withFirestore(Base))) {
     constructor({ firestore, interceptors }) {
         super({
@@ -2742,38 +2732,38 @@ class RegisterFirebaseAuthService {
 }
 
 class AttributeOptionHelper {
-    static { this.FindByAttribute = (attributeName, fields) => {
-        if (fields.includes(attributeName))
-            return { columnName: attributeName.toString(), attributeName, to: (value) => value, from: (value) => value };
-        const field = fields.find((columnOption) => isObject(columnOption) && Object.keys(columnOption).includes(attributeName.toString()));
-        const fieldOption = is(field)?.[attributeName];
-        if (isNil(fieldOption))
-            return { columnName: attributeName.toString(), attributeName };
-        if (Array.isArray(fieldOption))
-            return { columnName: attributeName.toString(), attributeName, fields: fieldOption };
-        return { attributeName, columnName: attributeName.toString(), ...fieldOption };
-    }; }
-    static { this.CheckIsColumnOption = (fieldValue) => !!fieldValue?.columnName; }
-    static { this.FindColumnOptionFromList = (columnName, fields) => {
-        if (fields.includes(columnName))
-            return { columnName, attributeName: columnName };
-        const field = is(fields.find((field) => {
-            if (!isObject(field))
-                return false;
-            const columnOption = Object.values(field).find((option) => AttributeOptionHelper.CheckIsColumnOption(option) && option.columnName === columnName ? option : {});
-            return AttributeOptionHelper.CheckIsColumnOption(columnOption) && columnOption?.columnName === columnName;
-        }) || {});
-        const attributeName = Object.keys(field).find((fieldOptionFromList) => AttributeOptionHelper.CheckIsColumnOption(field[fieldOptionFromList]) || Array.isArray(field[fieldOptionFromList]));
-        const fieldOption = field?.[attributeName];
-        if (Array.isArray(fieldOption))
-            return { attributeName: attributeName, fields: fieldOption };
-        return {
-            attributeName: attributeName || columnName,
-            columnName,
-            ...fieldOption,
-        };
-    }; }
 }
+AttributeOptionHelper.FindByAttribute = (attributeName, fields) => {
+    if (fields.includes(attributeName))
+        return { columnName: attributeName.toString(), attributeName, to: (value) => value, from: (value) => value };
+    const field = fields.find((columnOption) => isObject(columnOption) && Object.keys(columnOption).includes(attributeName.toString()));
+    const fieldOption = is(field)?.[attributeName];
+    if (isNil(fieldOption))
+        return { columnName: attributeName.toString(), attributeName };
+    if (Array.isArray(fieldOption))
+        return { columnName: attributeName.toString(), attributeName, fields: fieldOption };
+    return { attributeName, columnName: attributeName.toString(), ...fieldOption };
+};
+AttributeOptionHelper.CheckIsColumnOption = (fieldValue) => !!fieldValue?.columnName;
+AttributeOptionHelper.FindColumnOptionFromList = (columnName, fields) => {
+    if (fields.includes(columnName))
+        return { columnName, attributeName: columnName };
+    const field = is(fields.find((field) => {
+        if (!isObject(field))
+            return false;
+        const columnOption = Object.values(field).find((option) => AttributeOptionHelper.CheckIsColumnOption(option) && option.columnName === columnName ? option : {});
+        return AttributeOptionHelper.CheckIsColumnOption(columnOption) && columnOption?.columnName === columnName;
+    }) || {});
+    const attributeName = Object.keys(field).find((fieldOptionFromList) => AttributeOptionHelper.CheckIsColumnOption(field[fieldOptionFromList]) || Array.isArray(field[fieldOptionFromList]));
+    const fieldOption = field?.[attributeName];
+    if (Array.isArray(fieldOption))
+        return { attributeName: attributeName, fields: fieldOption };
+    return {
+        attributeName: attributeName || columnName,
+        columnName,
+        ...fieldOption,
+    };
+};
 
 var HasuraGraphQLWhere;
 (function (HasuraGraphQLWhere) {
@@ -2806,211 +2796,211 @@ var HasuraGraphQLColumnType;
 })(HasuraGraphQLColumnType || (HasuraGraphQLColumnType = {}));
 
 class FilterOptionHelper {
-    static { this.CheckIfIsFilterOption = (filter) => !isNil(filter?.operator); }
-    static { this.GetValueFromFilter = (filter, fieldOption) => {
-        if (!FilterOptionHelper.CheckIfIsFilterOption(filter))
-            return filter;
-        if (filter.operator === Where.ISNULL)
-            return true;
-        if (filter.operator === Where.ISNOTNULL)
-            return false;
-        const converter = fieldOption.to
-            ? fieldOption.to
-            : (value) => filter.operator === Where.LIKE && !Array.isArray(filter.value) && value.indexOf('%') < 0
-                ? `%${value}%`
-                : value;
-        return Array.isArray(filter.value) && !fieldOption.fields && [Where.IN, Where.NOTIN].includes(filter.operator)
-            ? filter.value.map((fieldValue) => converter(fieldValue))
-            : converter(filter.value);
-    }; }
 }
+FilterOptionHelper.CheckIfIsFilterOption = (filter) => !isNil(filter?.operator);
+FilterOptionHelper.GetValueFromFilter = (filter, fieldOption) => {
+    if (!FilterOptionHelper.CheckIfIsFilterOption(filter))
+        return filter;
+    if (filter.operator === Where.ISNULL)
+        return true;
+    if (filter.operator === Where.ISNOTNULL)
+        return false;
+    const converter = fieldOption.to
+        ? fieldOption.to
+        : (value) => filter.operator === Where.LIKE && !Array.isArray(filter.value) && value.indexOf('%') < 0
+            ? `%${value}%`
+            : value;
+    return Array.isArray(filter.value) && !fieldOption.fields && [Where.IN, Where.NOTIN].includes(filter.operator)
+        ? filter.value.map((fieldValue) => converter(fieldValue))
+        : converter(filter.value);
+};
 
 class BindFilterQueryHelper {
-    static { this.MakeGraphQLWhere = (filter, fields) => Object.keys(filter).reduce((variables, fieldName) => {
-        const columnOption = AttributeOptionHelper.FindByAttribute(fieldName, fields);
-        if (!columnOption.bindFindFilter)
+}
+BindFilterQueryHelper.MakeGraphQLWhere = (filter, fields) => Object.keys(filter).reduce((variables, fieldName) => {
+    const columnOption = AttributeOptionHelper.FindByAttribute(fieldName, fields);
+    if (!columnOption.bindFindFilter)
+        return {
+            ...variables,
+            ...{
+                [columnOption.columnName]: BindFilterQueryHelper.BuildWhereSentence(fieldName, filter[fieldName], fields),
+            },
+        };
+    const builtFilter = columnOption.bindFindFilter(filter[fieldName]);
+    return {
+        ...variables,
+        ...Object.keys(builtFilter).reduce((variablesList, columnName) => ({
+            ...variablesList,
+            [columnName]: BindFilterQueryHelper.BuildWhereSentence(fieldName, builtFilter[columnName], fields),
+        }), {}),
+    };
+}, {});
+BindFilterQueryHelper.BuildWhereSentence = (field, options, fields) => {
+    const fieldSentenceOptions = AttributeOptionHelper.FindByAttribute(field, fields);
+    const isNestedField = !Array.isArray(options) &&
+        isObject(options) &&
+        isNil(options?.operator) &&
+        isNil(options?.value) &&
+        isNil(fieldSentenceOptions?.to);
+    if (isNestedField)
+        return Object.keys(options).reduce((variables, key) => {
+            const fieldOptions = AttributeOptionHelper.FindByAttribute(key, fieldSentenceOptions?.fields || fields);
+            const columnName = fieldOptions.columnName;
+            const columnFields = fieldOptions.fields;
             return {
                 ...variables,
-                ...{
-                    [columnOption.columnName]: BindFilterQueryHelper.BuildWhereSentence(fieldName, filter[fieldName], fields),
-                },
+                [columnName]: BindFilterQueryHelper.BuildWhereSentence(key, is(is(options)[key]), fieldSentenceOptions?.fields || columnFields || fields),
             };
-        const builtFilter = columnOption.bindFindFilter(filter[fieldName]);
+        }, {});
+    if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))
         return {
-            ...variables,
-            ...Object.keys(builtFilter).reduce((variablesList, columnName) => ({
-                ...variablesList,
-                [columnName]: BindFilterQueryHelper.BuildWhereSentence(fieldName, builtFilter[columnName], fields),
-            }), {}),
+            [fieldSentenceOptions.fields[0]]: BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions),
         };
-    }, {}); }
-    static { this.BuildWhereSentence = (field, options, fields) => {
-        const fieldSentenceOptions = AttributeOptionHelper.FindByAttribute(field, fields);
-        const isNestedField = !Array.isArray(options) &&
-            isObject(options) &&
-            isNil(options?.operator) &&
-            isNil(options?.value) &&
-            isNil(fieldSentenceOptions?.to);
+    if (!Array.isArray(options) && isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
+        options = Object.values(options)[0];
+    return Array.isArray(options)
+        ? options.reduce((whereSentence, option) => ({
+            ...whereSentence,
+            ...BindFilterQueryHelper.BuildOperatorSentence(option, fieldSentenceOptions),
+        }), {})
+        : BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions);
+};
+BindFilterQueryHelper.BuildOperatorSentence = (options, fieldOption) => ({
+    [BindFilterQueryHelper.GetHasuraOperator(options, fieldOption)]: FilterOptionHelper.GetValueFromFilter(options, fieldOption),
+});
+BindFilterQueryHelper.GetHasuraOperator = (options, fieldOption) => FilterOptionHelper.CheckIfIsFilterOption(options)
+    ? fieldOption.type === HasuraGraphQLColumnType.Jsonb
+        ? BindFilterQueryHelper.GetHasuraJsonbOperator(options)
+        : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find((graphQLOperator) => graphQLOperator ===
+            Object.keys(Where).find((operator) => Where[operator] === options?.operator))]
+    : HasuraGraphQLWhere.EQUALS;
+BindFilterQueryHelper.GetHasuraJsonbOperator = (options) => options.operator === Where.IN
+    ? HasuraGraphQLWhere.JSON_CONTAINS
+    : options.operator === Where.LIKE
+        ? HasuraGraphQLWhere.JSON_HAS_KEYS_ANY
+        : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find((graphQLOperator) => graphQLOperator ===
+            Object.keys(Where).find((operator) => Where[operator] === options?.operator))];
+
+class GraphQLFieldHelper {
+}
+GraphQLFieldHelper.CheckIsGraphQLParams = (params) => !isString(params) && Array.isArray(params) && params.length >= 0 && !!params[0].operation;
+GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields = (fields) => {
+    return fields
+        ?.map((field) => {
+        if (isString(field))
+            return field.toString();
+        if (field === 'affected_rows')
+            return field;
+        const fieldName = Object.keys(field).shift();
+        const fieldValue = is(field[fieldName]);
+        if (Array.isArray(fieldValue))
+            return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) };
+        if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue))
+            return;
+        const isNestedField = !!fieldValue.fields;
         if (isNestedField)
-            return Object.keys(options).reduce((variables, key) => {
-                const fieldOptions = AttributeOptionHelper.FindByAttribute(key, fieldSentenceOptions?.fields || fields);
-                const columnName = fieldOptions.columnName;
-                const columnFields = fieldOptions.fields;
-                return {
-                    ...variables,
-                    [columnName]: BindFilterQueryHelper.BuildWhereSentence(key, is(is(options)[key]), fieldSentenceOptions?.fields || columnFields || fields),
-                };
-            }, {});
-        if (!Array.isArray(options) && !isNil(fieldSentenceOptions.fields))
+            return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue);
+        return fieldValue.columnName;
+    })
+        .filter((field) => !!field);
+};
+GraphQLFieldHelper.ConvertFieldValueFrom = (data, fields) => Object.keys(data).reduce((result, columnName) => {
+    const { attributeName, fields: attributeFields, from, } = AttributeOptionHelper.FindColumnOptionFromList(columnName, fields);
+    if (!!attributeFields && Array.isArray(attributeFields)) {
+        if (Array.isArray(data[columnName]))
             return {
-                [fieldSentenceOptions.fields[0]]: BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions),
+                ...result,
+                [attributeName]: from
+                    ? from(data[columnName], data)
+                    : is(data[columnName]).map((value) => GraphQLFieldHelper.ConvertFieldValueFrom(is(value), attributeFields)),
             };
-        if (!Array.isArray(options) && isObject(options) && !FilterOptionHelper.CheckIfIsFilterOption(options))
-            options = Object.values(options)[0];
-        return Array.isArray(options)
-            ? options.reduce((whereSentence, option) => ({
-                ...whereSentence,
-                ...BindFilterQueryHelper.BuildOperatorSentence(option, fieldSentenceOptions),
-            }), {})
-            : BindFilterQueryHelper.BuildOperatorSentence(options, fieldSentenceOptions);
-    }; }
-    static { this.BuildOperatorSentence = (options, fieldOption) => ({
-        [BindFilterQueryHelper.GetHasuraOperator(options, fieldOption)]: FilterOptionHelper.GetValueFromFilter(options, fieldOption),
-    }); }
-    static { this.GetHasuraOperator = (options, fieldOption) => FilterOptionHelper.CheckIfIsFilterOption(options)
-        ? fieldOption.type === HasuraGraphQLColumnType.Jsonb
-            ? BindFilterQueryHelper.GetHasuraJsonbOperator(options)
-            : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find((graphQLOperator) => graphQLOperator ===
-                Object.keys(Where).find((operator) => Where[operator] === options?.operator))]
-        : HasuraGraphQLWhere.EQUALS; }
-    static { this.GetHasuraJsonbOperator = (options) => options.operator === Where.IN
-        ? HasuraGraphQLWhere.JSON_CONTAINS
-        : options.operator === Where.LIKE
-            ? HasuraGraphQLWhere.JSON_HAS_KEYS_ANY
-            : HasuraGraphQLWhere[Object.keys(HasuraGraphQLWhere).find((graphQLOperator) => graphQLOperator ===
-                Object.keys(Where).find((operator) => Where[operator] === options?.operator))]; }
-}
-
-class GraphQLFieldHelper {
-    static { this.CheckIsGraphQLParams = (params) => !isString(params) && Array.isArray(params) && params.length >= 0 && !!params[0].operation; }
-    static { this.ConvertModelFieldsToGraphQLFields = (fields) => {
-        return fields
-            ?.map((field) => {
-            if (isString(field))
-                return field.toString();
-            if (field === 'affected_rows')
-                return field;
-            const fieldName = Object.keys(field).shift();
-            const fieldValue = is(field[fieldName]);
-            if (Array.isArray(fieldValue))
-                return { [fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue) };
-            if (!AttributeOptionHelper.CheckIsColumnOption(fieldValue))
-                return;
-            const isNestedField = !!fieldValue.fields;
-            if (isNestedField)
-                return GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields(fieldName, fieldValue);
-            return fieldValue.columnName;
-        })
-            .filter((field) => !!field);
-    }; }
-    static { this.ConvertFieldValueFrom = (data, fields) => Object.keys(data).reduce((result, columnName) => {
-        const { attributeName, fields: attributeFields, from, } = AttributeOptionHelper.FindColumnOptionFromList(columnName, fields);
-        if (!!attributeFields && Array.isArray(attributeFields)) {
-            if (Array.isArray(data[columnName]))
-                return {
-                    ...result,
-                    [attributeName]: from
-                        ? from(data[columnName], data)
-                        : is(data[columnName]).map((value) => GraphQLFieldHelper.ConvertFieldValueFrom(is(value), attributeFields)),
-                };
-            if (isObject(data[columnName]))
+        if (isObject(data[columnName]))
+            return {
+                ...result,
+                [attributeName]: !!from
+                    ? from(data[columnName])
+                    : GraphQLFieldHelper.ConvertFieldValueFrom(is(data[columnName]), attributeFields),
+            };
+    }
+    if (!!from)
+        return { ...result, [attributeName]: from(data[columnName], data) };
+    return {
+        ...result,
+        [attributeName]: isString(data[columnName]) ? parseDateTime(data[columnName].toString()) : data[columnName],
+    };
+}, {});
+GraphQLFieldHelper.ConvertFieldValueTo = (instance, fields, update = false) => {
+    const data = instance.toPlain?.() || instance;
+    return Object.keys(data).reduce((result, attributeName) => {
+        const { columnName, fields: attributeFields, foreignKeyColumn, to, bindPersistData, } = AttributeOptionHelper.FindByAttribute(attributeName, fields);
+        if (bindPersistData)
+            return {
+                ...result,
+                ...bindPersistData(data[attributeName], instance),
+            };
+        if (isNil(columnName))
+            return result;
+        if (!!foreignKeyColumn &&
+            !isEmpty(foreignKeyColumn) &&
+            !Object.keys(foreignKeyColumn).filter((key) => !is(data[attributeName])?.[key]).length)
+            return Object.keys(foreignKeyColumn).reduce((object, current) => {
+                const { columnName: foreignColumnName } = AttributeOptionHelper.FindByAttribute(foreignKeyColumn[current], fields);
                 return {
-                    ...result,
-                    [attributeName]: !!from
-                        ? from(data[columnName])
-                        : GraphQLFieldHelper.ConvertFieldValueFrom(is(data[columnName]), attributeFields),
+                    ...object,
+                    [foreignColumnName]: data[attributeName]?.[current],
                 };
+            }, { ...result });
+        if (update &&
+            isObject(data[attributeName]) &&
+            !isNil(attributeFields) &&
+            !isDate(data[attributeName]))
+            return result;
+        if (!!columnName &&
+            Array.isArray(attributeFields) &&
+            isObject(data[attributeName])) {
+            const converted = !isNil(columnName) && to
+                ? to(instance[attributeName], instance)
+                : data[attributeName];
+            return {
+                ...result,
+                ...(converted !== undefined
+                    ? {
+                        [columnName]: {
+                            data: instance[attributeName] instanceof BaseModel
+                                ? GraphQLFieldHelper.ConvertFieldValueTo(data[attributeName], attributeFields)
+                                : converted,
+                        },
+                    }
+                    : {}),
+            };
         }
-        if (!!from)
-            return { ...result, [attributeName]: from(data[columnName], data) };
-        return {
-            ...result,
-            [attributeName]: isString(data[columnName]) ? parseDateTime(data[columnName].toString()) : data[columnName],
-        };
-    }, {}); }
-    static { this.ConvertFieldValueTo = (instance, fields, update = false) => {
-        const data = instance.toPlain?.() || instance;
-        return Object.keys(data).reduce((result, attributeName) => {
-            const { columnName, fields: attributeFields, foreignKeyColumn, to, bindPersistData, } = AttributeOptionHelper.FindByAttribute(attributeName, fields);
-            if (bindPersistData)
-                return {
-                    ...result,
-                    ...bindPersistData(data[attributeName], instance),
-                };
-            if (isNil(columnName))
-                return result;
-            if (!!foreignKeyColumn &&
-                !isEmpty(foreignKeyColumn) &&
-                !Object.keys(foreignKeyColumn).filter((key) => !is(data[attributeName])?.[key]).length)
-                return Object.keys(foreignKeyColumn).reduce((object, current) => {
-                    const { columnName: foreignColumnName } = AttributeOptionHelper.FindByAttribute(foreignKeyColumn[current], fields);
-                    return {
-                        ...object,
-                        [foreignColumnName]: data[attributeName]?.[current],
-                    };
-                }, { ...result });
-            if (update &&
-                isObject(data[attributeName]) &&
-                !isNil(attributeFields) &&
-                !isDate(data[attributeName]))
-                return result;
-            if (!!columnName &&
-                Array.isArray(attributeFields) &&
-                isObject(data[attributeName])) {
-                const converted = !isNil(columnName) && to
-                    ? to(instance[attributeName], instance)
-                    : data[attributeName];
-                return {
-                    ...result,
-                    ...(converted !== undefined
-                        ? {
-                            [columnName]: {
-                                data: instance[attributeName] instanceof BaseModel
-                                    ? GraphQLFieldHelper.ConvertFieldValueTo(data[attributeName], attributeFields)
-                                    : converted,
-                            },
-                        }
-                        : {}),
-                };
-            }
-            if (!!to)
-                return {
-                    ...result,
-                    [columnName]: to(instance[attributeName], instance),
-                };
-            return { ...result, [columnName]: data[attributeName] };
-        }, {});
-    }; }
-    static { this.ConvertNestedFieldsToGraphQLFields = (fieldName, fieldValue) => {
-        const hasCustomFilters = !!fieldValue.filters;
-        if (hasCustomFilters)
+        if (!!to)
             return {
-                operation: fieldValue.columnName || fieldName,
-                fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
-                variables: {
-                    [`${fieldValue.columnName}_where`]: {
-                        name: 'where',
-                        type: fieldValue.filters.filterType,
-                        value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),
-                        required: true,
-                    },
-                },
+                ...result,
+                [columnName]: to(instance[attributeName], instance),
             };
+        return { ...result, [columnName]: data[attributeName] };
+    }, {});
+};
+GraphQLFieldHelper.ConvertNestedFieldsToGraphQLFields = (fieldName, fieldValue) => {
+    const hasCustomFilters = !!fieldValue.filters;
+    if (hasCustomFilters)
         return {
-            [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+            operation: fieldValue.columnName || fieldName,
+            fields: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+            variables: {
+                [`${fieldValue.columnName}_where`]: {
+                    name: 'where',
+                    type: fieldValue.filters.filterType,
+                    value: BindFilterQueryHelper.MakeGraphQLWhere(fieldValue.filters.filters, fieldValue.fields),
+                    required: true,
+                },
+            },
         };
-    }; }
-}
+    return {
+        [fieldValue.columnName || fieldName]: GraphQLFieldHelper.ConvertModelFieldsToGraphQLFields(fieldValue.fields),
+    };
+};
 
 const withCreateHasuraGraphQL = (MixinBase) => {
     return class CreateHasuraGraphQLMixin extends MixinBase {
@@ -3080,6 +3070,16 @@ const withDeleteHasuraGraphQL = (MixinBase) => {
 
 const withHasuraGraphQL = (MixinBase) => {
     return class HasuraGraphQLMixin extends MixinBase {
+        constructor(...params) {
+            const options = params[0];
+            super(...params);
+            this.tableName = options.tableName;
+            this.endpoint = options.endpoint;
+            this.authOptions = options.authOptions;
+            this.model = options.model;
+            this.fields = options.fields || this.model.identifiersFields;
+            this.logger = DebugHelper.from(this);
+        }
         get headers() {
             return {
                 'Content-Type': 'application/json',
@@ -3093,16 +3093,6 @@ const withHasuraGraphQL = (MixinBase) => {
                     }),
             };
         }
-        constructor(...params) {
-            const options = params[0];
-            super(...params);
-            this.tableName = options.tableName;
-            this.endpoint = options.endpoint;
-            this.authOptions = options.authOptions;
-            this.model = options.model;
-            this.fields = options.fields || this.model.identifiersFields;
-            this.logger = DebugHelper.from(this);
-        }
         async mutation(operation, fields, variables) {
             const resultQuery = mutation({
                 operation,
@@ -3719,7 +3709,6 @@ class CategoryHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
                 slug,
                 shops: { operator: Where.IN, value: [shop] },
                 published: { operator: Where.EQUALS, value: true },
-                isWishlist: { operator: Where.EQUALS, value: false },
             },
             options: {
                 enableCount: false,
@@ -4055,24 +4044,6 @@ class FilterOptionHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasu
 }
 
 class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGraphQL(Base)) {
-    get reviewsFields() {
-        return [
-            'id',
-            'shop',
-            'rate',
-            'author',
-            'email',
-            'location',
-            'review',
-            'status',
-            'title',
-            { personId: { columnName: 'person_id' } },
-            'points',
-            { orderId: { columnName: 'order_id' } },
-            { createdAt: { columnName: 'created_at' } },
-            { updatedAt: { columnName: 'updated_at' } },
-        ];
-    }
     constructor({ endpoint, authOptions, interceptors, }) {
         super({
             tableName: 'product',
@@ -4273,6 +4244,24 @@ class ProductHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGra
             },
         ];
     }
+    get reviewsFields() {
+        return [
+            'id',
+            'shop',
+            'rate',
+            'author',
+            'email',
+            'location',
+            'review',
+            'status',
+            'title',
+            { personId: { columnName: 'person_id' } },
+            'points',
+            { orderId: { columnName: 'order_id' } },
+            { createdAt: { columnName: 'created_at' } },
+            { updatedAt: { columnName: 'updated_at' } },
+        ];
+    }
     async create(params) {
         const { metadata, ...data } = params;
         const product = await super.create(omit({ ...data, metadata: metadata || { description: null, title: null } }, ['reviews']));
@@ -4758,6 +4747,8 @@ class WishlistHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
                     },
                 },
                 { personId: { columnName: 'person_id' } },
+                { personName: { columnName: 'person_name' } },
+                { personPhoto: { columnName: 'person_photo' } },
             ],
         });
         this.categoryFilterRepository = categoryFilterRepository;
@@ -4907,5 +4898,5 @@ class WishlistHasuraGraphQLRepository extends withCrudHasuraGraphQL(withHasuraGr
  * Generated bundle index. Do not edit.
  */
 
-export { AccessoryImportances, Address, Area, Authentication, AuthenticationFirebaseAuthService, AxiosAdapter, Base, BaseModel, BeardProblems, BeardSizes, BeautyProductImportances, BeautyProfile, BeautyQuestionsHelper, BillingStatus, BodyProblems, BodyShapes, BodyTattoos, Buy2Win, Buy2WinFirestoreRepository, Campaign, CampaignBanner, CampaignBannerFirestoreRepository, CampaignDashboard, CampaignDashboardFirestoreRepository, CampaignFirestoreRepository, CampaignHashtag, CampaignHashtagFirestoreRepository, Category, CategoryCollectionChildren, CategoryCollectionChildrenHasuraGraphQLRepository, CategoryFilter, CategoryFilterHasuraGraphQLRepository, CategoryFirestoreRepository, CategoryHasuraGraphQL, CategoryHasuraGraphQLRepository, Checkout, CheckoutFirestoreRepository, CheckoutSubscription, CheckoutSubscriptionFirestoreRepository, CheckoutTypes, ClassNameHelper, Coupon, CouponFirestoreRepository, CouponSubtypes, CouponTypes, Debug, DebugDecoratorHelper, DebugHelper, DebugNamespaces, DuplicatedResultsError, Edition, EditionStatus, Exclusivities, FaceSkinOilinesses, FaceSkinProblems, FaceSkinTones, FamilyIncomes, Filter, FilterHasuraGraphQLRepository, FilterOption, FilterOptionHasuraGraphQLRepository, FilterType, FragranceImportances, GenderDestination, HairColors, HairProblems, HairStrands, HairTypes, Home, HomeFirestoreRepository, InvalidArgumentError, KitProduct, KitProductHasuraGraphQL, Lead, LeadFirestoreRepository, LegacyOrderFirestoreRepository, LineItem, Log, Logger, NotFoundError, OfficePosition, Order, OrderFirestoreRepository, OrderStatus, Payment, PaymentFirestoreRepository, PaymentType, Product, ProductFirestoreRepository, ProductHasuraGraphQL, ProductHasuraGraphQLRepository, ProductSpents, ProductVariantFirestoreRepository, ProductsIndex, QuestionsFilters, RecoveryPassword, ReflectHelper, Register, RegisterFirebaseAuthService, RequiredArgumentError, RoundProductPricesHelper, ShippingMethod, ShopMenu, ShopMenuFirestoreRepository, ShopPageName, ShopSettings, ShopSettingsFirestoreRepository, Shops, SignInMethods, SignOut, Status, Subscription, SubscriptionEditionFirestoreRepository, SubscriptionFirestoreRepository, SubscriptionPayment, SubscriptionPaymentFirestoreRepository, SubscriptionPlan, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, Trace, UnauthorizedError, UpdateOptionActions, User, UserAddress, UserAddressFirestoreRepository, UserAlreadyRegisteredError, UserBeautyProfileFirestoreRepository, UserFirestoreRepository, UserPaymentMethod, UserPaymentMethodFirestoreRepository, UserType, Variant, VariantHasuraGraphQL, VariantHasuraGraphQLRepository, WeakPasswordError, Where, Wishlist, WishlistHasuraGraphQLRepository, is, isDebuggable, isUUID, parseDateTime, withCreateFirestore, withCreateHasuraGraphQL, withCrudFirestore, withCrudHasuraGraphQL, withDeleteFirestore, withDeleteHasuraGraphQL, withFindFirestore, withFindHasuraGraphQL, withFirestore, withGetFirestore, withGetHasuraGraphQL, withHasuraGraphQL, withHelpers, withSubCollection, withUpdateFirestore, withUpdateHasuraGraphQL };
+export { AccessoryImportances, Address, Area, Authentication, AuthenticationFirebaseAuthService, AxiosAdapter, Base, BaseModel, BeardProblems, BeardSizes, BeautyProductImportances, BeautyProfile, BeautyQuestionsHelper, BillingStatus, BodyProblems, BodyShapes, BodyTattoos, Buy2Win, Buy2WinFirestoreRepository, CampaignDashboard, CampaignDashboardFirestoreRepository, CampaignHashtag, CampaignHashtagFirestoreRepository, Category, CategoryCollectionChildren, CategoryCollectionChildrenHasuraGraphQLRepository, CategoryFilter, CategoryFilterHasuraGraphQLRepository, CategoryFirestoreRepository, CategoryHasuraGraphQL, CategoryHasuraGraphQLRepository, Checkout, CheckoutFirestoreRepository, CheckoutSubscription, CheckoutSubscriptionFirestoreRepository, CheckoutTypes, ClassNameHelper, Coupon, CouponFirestoreRepository, CouponSubtypes, CouponTypes, Debug, DebugDecoratorHelper, DebugHelper, DebugNamespaces, DuplicatedResultsError, Edition, EditionStatus, Exclusivities, FaceSkinOilinesses, FaceSkinProblems, FaceSkinTones, FamilyIncomes, Filter, FilterHasuraGraphQLRepository, FilterOption, FilterOptionHasuraGraphQLRepository, FilterType, FragranceImportances, GenderDestination, HairColors, HairProblems, HairStrands, HairTypes, Home, HomeFirestoreRepository, InvalidArgumentError, KitProduct, KitProductHasuraGraphQL, Lead, LeadFirestoreRepository, LegacyOrderFirestoreRepository, LineItem, Log, Logger, NotFoundError, OfficePosition, Order, OrderFirestoreRepository, OrderStatus, Payment, PaymentFirestoreRepository, PaymentType, Product, ProductFirestoreRepository, ProductHasuraGraphQL, ProductHasuraGraphQLRepository, ProductSpents, ProductVariantFirestoreRepository, ProductsIndex, QuestionsFilters, RecoveryPassword, ReflectHelper, Register, RegisterFirebaseAuthService, RequiredArgumentError, RoundProductPricesHelper, ShippingMethod, ShopMenu, ShopMenuFirestoreRepository, ShopSettings, ShopSettingsFirestoreRepository, Shops, SignInMethods, SignOut, Status, Subscription, SubscriptionEditionFirestoreRepository, SubscriptionFirestoreRepository, SubscriptionMaterialization, SubscriptionMaterializationFirestoreRepository, SubscriptionPayment, SubscriptionPaymentFirestoreRepository, SubscriptionPlan, SubscriptionPlanFirestoreRepository, SubscriptionProductFirestoreRepository, Trace, UnauthorizedError, UpdateOptionActions, User, UserAddress, UserAddressFirestoreRepository, UserAlreadyRegisteredError, UserBeautyProfileFirestoreRepository, UserFirestoreRepository, UserPaymentMethod, UserPaymentMethodFirestoreRepository, UserType, Variant, VariantHasuraGraphQL, VariantHasuraGraphQLRepository, WeakPasswordError, Where, Wishlist, WishlistHasuraGraphQLRepository, is, isDebuggable, isUUID, parseDateTime, withCreateFirestore, withCreateHasuraGraphQL, withCrudFirestore, withCrudHasuraGraphQL, withDeleteFirestore, withDeleteHasuraGraphQL, withFindFirestore, withFindHasuraGraphQL, withFirestore, withGetFirestore, withGetHasuraGraphQL, withHasuraGraphQL, withHelpers, withSubCollection, withUpdateFirestore, withUpdateHasuraGraphQL };
 //# sourceMappingURL=infrab4a-connect.mjs.map