@stamhoofd/structures 2.39.1 → 2.40.1

package/esm/dist/src/members/checkout/RegisterItem.js

@@ -1,11 +1,11 @@
 import { __decorate } from "tslib";
-import { ArrayDecoder, AutoEncoder, field, IntegerDecoder, StringDecoder } from "@simonbackx/simple-encoding";
-import { isSimpleError, isSimpleErrors, SimpleError, SimpleErrors } from "@simonbackx/simple-errors";
-import { Formatter } from "@stamhoofd/utility";
-import { v4 as uuidv4 } from "uuid";
-import { GroupOption, GroupOptionMenu, GroupPrice, WaitingListType } from "../../GroupSettings";
-import { GroupType } from "../../GroupType";
-import { StockReservation } from "../../StockReservation";
+import { ArrayDecoder, AutoEncoder, field, IntegerDecoder, StringDecoder } from '@simonbackx/simple-encoding';
+import { isSimpleError, isSimpleErrors, SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
+import { Formatter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from 'uuid';
+import { GroupOption, GroupOptionMenu, GroupPrice, WaitingListType } from '../../GroupSettings';
+import { GroupType } from '../../GroupType';
+import { StockReservation } from '../../StockReservation';
 export class RegisterItemOption extends AutoEncoder {
     constructor() {
         super(...arguments);
@@ -66,17 +66,17 @@ export class RegisterItem {
             group: registration.group,
             organization,
             groupPrice: registration.groupPrice,
-            options: registration.options
+            options: registration.options,
         });
     }
     static defaultFor(member, group, organization) {
         if (group.organizationId !== organization.id) {
-            throw new Error("Group and organization do not match in RegisterItem.defaultFor");
+            throw new Error('Group and organization do not match in RegisterItem.defaultFor');
         }
         const item = new RegisterItem({
             member,
             group,
-            organization
+            organization,
         });
         return item;
     }
@@ -142,7 +142,7 @@ export class RegisterItem {
                     this.options.push(RegisterItemOption.create({
                         option,
                         optionMenu: optionMenu,
-                        amount: 1
+                        amount: 1,
                     }));
                     added = true;
                     break;
@@ -152,7 +152,7 @@ export class RegisterItem {
                     this.options.push(RegisterItemOption.create({
                         option: options[0],
                         optionMenu: optionMenu,
-                        amount: 1
+                        amount: 1,
                     }));
                 }
             }
@@ -184,22 +184,22 @@ export class RegisterItem {
             replacePrice += registration.price;
             all.push({
                 name: this.checkout.isAdminFromSameOrganization ? 'Reeds aangerekend voor ' + registration.group.settings.name : 'Terugbetaling ' + registration.group.settings.name,
-                price: -registration.price
+                price: -registration.price,
             });
         }
         all = all.filter(a => a.price !== 0);
         if (all.length > 0) {
             all.unshift({
                 name: 'Subtotaal',
-                price: this.calculatedPrice
+                price: this.calculatedPrice,
             });
         }
         return [
             ...all,
             {
                 name: this.checkout.isAdminFromSameOrganization ? (this.totalPrice >= 0 ? 'Openstaand bedrag stijgt met' : 'Openstaand bedrag daalt met') : 'Totaal',
-                price: this.checkout.isAdminFromSameOrganization ? Math.abs(this.totalPrice) : this.totalPrice
-            }
+                price: this.checkout.isAdminFromSameOrganization ? Math.abs(this.totalPrice) : this.totalPrice,
+            },
         ];
     }
     clone() {
@@ -213,7 +213,7 @@ export class RegisterItem {
             replaceRegistrations: this.replaceRegistrations.map(r => r.clone()),
             cartError: this.cartError,
             calculatedPrice: this.calculatedPrice,
-            calculatedRefund: this.calculatedRefund
+            calculatedRefund: this.calculatedRefund,
         });
     }
     copyFrom(item) {
@@ -243,7 +243,7 @@ export class RegisterItem {
             organizationId: this.organization.id,
             groupPrice: this.groupPrice,
             options: this.options,
-            replaceRegistrationIds: this.replaceRegistrations.map(r => r.id)
+            replaceRegistrationIds: this.replaceRegistrations.map(r => r.id),
         });
     }
     get memberId() {
@@ -270,19 +270,19 @@ export class RegisterItem {
         const errors = new SimpleErrors();
         if (this.group.settings.prices.length === 0) {
             errors.addError(new SimpleError({
-                code: "product_unavailable",
-                message: "Product unavailable",
-                human: "Er is iets fout met de tariefinstellingen van " + this.group.settings.name + ", waardoor je nu niet kan inschrijven. Neem contact op met een beheerder en vraag de tariefinstellingen na te kijken."
+                code: 'product_unavailable',
+                message: 'Product unavailable',
+                human: 'Er is iets fout met de tariefinstellingen van ' + this.group.settings.name + ', waardoor je nu niet kan inschrijven. Neem contact op met een beheerder en vraag de tariefinstellingen na te kijken.',
             }));
         }
         else {
             const groupPrice = this.group.settings.prices.find(p => p.id === this.groupPrice.id);
             if (!groupPrice) {
                 errors.addError(new SimpleError({
-                    code: "product_unavailable",
-                    message: "Product unavailable",
-                    human: "Eén of meerdere tarieven van " + this.group.settings.name + " zijn niet meer beschikbaar",
-                    meta: { recoverable: true }
+                    code: 'product_unavailable',
+                    message: 'Product unavailable',
+                    human: 'Eén of meerdere tarieven van ' + this.group.settings.name + ' zijn niet meer beschikbaar',
+                    meta: { recoverable: true },
                 }));
             }
             else {
@@ -297,25 +297,25 @@ export class RegisterItem {
                 // Check if it has a multiple choice one
                 index = this.group.settings.optionMenus.findIndex(m => m.id === o.optionMenu.id);
                 errors.addError(new SimpleError({
-                    code: "option_menu_unavailable",
-                    message: "Option menu unavailable",
-                    human: "Eén of meerdere keuzemogelijkheden van " + this.group.settings.name + " zijn niet meer beschikbaar",
-                    meta: { recoverable: true }
+                    code: 'option_menu_unavailable',
+                    message: 'Option menu unavailable',
+                    human: 'Eén of meerdere keuzemogelijkheden van ' + this.group.settings.name + ' zijn niet meer beschikbaar',
+                    meta: { recoverable: true },
                 }));
                 continue;
             }
             const menu = remainingMenus[index];
             if (!menu.multipleChoice) {
                 // Already used: not possible to add another
-                remainingMenus.splice(index, 1)[0];
+                remainingMenus.splice(index, 1);
             }
             const option = menu.options.find(m => m.id === o.option.id);
             if (!option) {
                 errors.addError(new SimpleError({
-                    code: "option_unavailable",
-                    message: "Option unavailable",
-                    human: "Eén of meerdere keuzemogelijkheden van " + this.group.settings.name + " zijn niet meer beschikbaar",
-                    meta: { recoverable: true }
+                    code: 'option_unavailable',
+                    message: 'Option unavailable',
+                    human: 'Eén of meerdere keuzemogelijkheden van ' + this.group.settings.name + ' zijn niet meer beschikbaar',
+                    meta: { recoverable: true },
                 }));
                 continue;
             }
@@ -325,10 +325,10 @@ export class RegisterItem {
         }
         if (remainingMenus.filter(m => !m.multipleChoice).length > 0) {
             errors.addError(new SimpleError({
-                code: "missing_menu",
-                message: "Missing menu's " + remainingMenus.filter(m => !m.multipleChoice).map(m => m.name).join(", "),
-                human: "Er zijn nieuwe keuzemogelijkheden voor " + this.group.settings.name + " waaruit je moet kiezen",
-                meta: { recoverable: true }
+                code: 'missing_menu',
+                message: "Missing menu's " + remainingMenus.filter(m => !m.multipleChoice).map(m => m.name).join(', '),
+                human: 'Er zijn nieuwe keuzemogelijkheden voor ' + this.group.settings.name + ' waaruit je moet kiezen',
+                meta: { recoverable: true },
             }));
         }
         errors.throwIfNotEmpty();
@@ -346,13 +346,13 @@ export class RegisterItem {
         const parents = this.group.getParentCategories(this.organization.period.settings.categories, false);
         for (const parent of parents) {
             if (parent.settings.maximumRegistrations !== null) {
-                const count = this.member.patchedMember.registrations.filter(r => {
+                const count = this.member.patchedMember.registrations.filter((r) => {
                     if (!this.willReplace(r.id) && r.registeredAt !== null && r.deactivatedAt === null && parent.groupIds.includes(r.groupId)) {
                         return true;
                     }
                     return false;
                 }).length;
-                const waiting = this.checkout.cart.items.filter(item => {
+                const waiting = this.checkout.cart.items.filter((item) => {
                     return item.member.member.id === this.member.member.id && parent.groupIds.includes(item.group.id) && item.group.id !== this.group.id;
                 }).length;
                 if (count + waiting >= parent.settings.maximumRegistrations) {
@@ -367,7 +367,7 @@ export class RegisterItem {
     }
     doesMeetRequireGroupIds() {
         if (this.group.settings.requireGroupIds.length > 0) {
-            const hasGroup = this.member.member.registrations.find(r => {
+            const hasGroup = this.member.member.registrations.find((r) => {
                 return !this.willReplace(r.id) && r.registeredAt !== null && r.deactivatedAt === null && this.group.settings.requireGroupIds.includes(r.groupId);
             });
             if (!hasGroup && !this.checkout.cart.items.find(item => item.member.id === this.member.id && this.group.settings.requireGroupIds.includes(item.group.id))) {
@@ -375,7 +375,7 @@ export class RegisterItem {
             }
         }
         if (this.group.settings.requireDefaultAgeGroupIds.length > 0) {
-            const hasGroup = this.member.member.registrations.find(r => {
+            const hasGroup = this.member.member.registrations.find((r) => {
                 return r.group.periodId === this.group.periodId && !this.willReplace(r.id) && r.registeredAt !== null && r.deactivatedAt === null && r.group.defaultAgeGroupId && this.group.settings.requireDefaultAgeGroupIds.includes(r.group.defaultAgeGroupId);
             });
             if (!hasGroup && !this.checkout.cart.items.find(item => item.member.id === this.member.id && item.group.defaultAgeGroupId && this.group.settings.requireDefaultAgeGroupIds.includes(item.group.defaultAgeGroupId))) {
@@ -386,7 +386,7 @@ export class RegisterItem {
     }
     doesMeetRequireOrganizationIds() {
         if (this.group.settings.requireOrganizationIds.length > 0) {
-            const hasGroup = this.member.member.registrations.find(r => {
+            const hasGroup = this.member.member.registrations.find((r) => {
                 return r.group.periodId === this.group.periodId && !this.willReplace(r.id) && r.group.type === GroupType.Membership && this.group.settings.requireOrganizationIds.includes(r.organizationId) && r.registeredAt !== null && r.deactivatedAt === null;
             });
             if (!hasGroup && !this.checkout.cart.items.find(item => item.member.id === this.member.id && this.group.settings.requireOrganizationIds.includes(item.organization.id))) {
@@ -397,7 +397,7 @@ export class RegisterItem {
     }
     doesMeetRequireOrganizationTags() {
         if (this.group.settings.requireOrganizationTags.length > 0) {
-            const hasOrganization = this.member.filterOrganizations({ currentPeriod: true, types: [GroupType.Membership] }).find(organization => {
+            const hasOrganization = this.member.filterOrganizations({ currentPeriod: true, types: [GroupType.Membership] }).find((organization) => {
                 return organization.meta.matchTags(this.group.settings.requireOrganizationTags);
             });
             if (!hasOrganization && !this.checkout.cart.items.find(item => item.member.id === this.member.id && item.organization.meta.matchTags(this.group.settings.requireOrganizationTags))) {
@@ -420,16 +420,16 @@ export class RegisterItem {
         const descriptions = [];
         if (this.replaceRegistrations.length > 0) {
             for (const registration of this.replaceRegistrations) {
-                descriptions.push("Verplaatsen vanaf " + registration.group.settings.name);
+                descriptions.push('Verplaatsen vanaf ' + registration.group.settings.name);
             }
         }
         if (this.getFilteredPrices().length > 1) {
             descriptions.push(this.groupPrice.name);
         }
         for (const option of this.options) {
-            descriptions.push(option.optionMenu.name + ': ' + option.option.name + (option.option.allowAmount ? ` x ${option.amount}` : ""));
+            descriptions.push(option.optionMenu.name + ': ' + option.option.name + (option.option.allowAmount ? ` x ${option.amount}` : ''));
         }
-        return descriptions.filter(d => !!d).join("\n");
+        return descriptions.filter(d => !!d).join('\n');
     }
     hasReachedGroupMaximum() {
         const available = this.group.settings.getRemainingStock(this);
@@ -528,8 +528,8 @@ export class RegisterItem {
         if (periodId !== this.organization.period.period.id) {
             if (!admin) {
                 throw new SimpleError({
-                    code: "different_period",
-                    message: "Different period",
+                    code: 'different_period',
+                    message: 'Different period',
                     human: type === 'register' ? `Je kan niet meer inschrijven voor ${group.settings.name} omdat dit werkjaar niet actief is.` : `Je kan geen inschrijvingen wijzigen van ${group.settings.name} omdat dat werkjaar niet actief is.`,
                 });
             }
@@ -537,15 +537,15 @@ export class RegisterItem {
         const period = periodId === platform.period.id ? platform.period : (periodId === this.organization.period.period.id ? this.organization.period.period : group.settings.period);
         if (!period) {
             throw new SimpleError({
-                code: "locked_period",
-                message: "Locked period",
+                code: 'locked_period',
+                message: 'Locked period',
                 human: type === 'register' ? `Je kan niet meer inschrijven voor ${group.settings.name} omdat dit werkjaar is afgesloten.` : `Je kan geen inschrijvingen wijzigen van ${group.settings.name} omdat dit werkjaar is afgesloten.`,
             });
         }
         if (!period || period.locked) {
             throw new SimpleError({
-                code: "locked_period",
-                message: "Locked period",
+                code: 'locked_period',
+                message: 'Locked period',
                 human: type === 'register' ? `Je kan niet meer inschrijven voor ${group.settings.name} omdat werkjaar ${period.nameShort} is afgesloten.` : `Je kan geen inschrijvingen wijzigen van ${group.settings.name} omdat werkjaar ${period.nameShort} is afgesloten.`,
             });
         }
@@ -556,55 +556,55 @@ export class RegisterItem {
         const checkout = this.member.family.checkout;
         const admin = checkout.isAdminFromSameOrganization && !(options === null || options === void 0 ? void 0 : options.warnings);
         if (this.group.organizationId !== this.organization.id) {
-            throw new Error("Group and organization do not match in RegisterItem.validate");
+            throw new Error('Group and organization do not match in RegisterItem.validate');
         }
         if (this.checkout.singleOrganization && this.checkout.singleOrganization.id !== this.organization.id) {
             throw new SimpleError({
-                code: "multiple_organizations",
-                message: "Cannot add items of multiple organizations to the checkout",
+                code: 'multiple_organizations',
+                message: 'Cannot add items of multiple organizations to the checkout',
                 human: `Reken eerst jouw huidige winkelmandje af. Inschrijvingen voor ${this.group.settings.name} moeten aan een andere organisatie betaald worden en kan je daardoor niet samen afrekenen.`,
-                meta: { recoverable: true }
+                meta: { recoverable: true },
             });
         }
         this.validatePeriod(this.group, 'register', admin);
         if ((options === null || options === void 0 ? void 0 : options.forWaitingList) && !this.group.waitingList) {
             throw new SimpleError({
-                code: "missing_waiting_list",
-                message: "No waiting list",
-                human: `Je kan niet inschrijven voor de wachtlijst`
+                code: 'missing_waiting_list',
+                message: 'No waiting list',
+                human: `Je kan niet inschrijven voor de wachtlijst`,
             });
         }
         if (checkout.asOrganizationId && !checkout.isAdminFromSameOrganization && !this.group.settings.allowRegistrationsByOrganization) {
             throw new SimpleError({
-                code: "as_organization_disabled",
-                message: "allowRegistrationsByOrganization disabled",
-                human: "Inschrijvingen door organisaties zijn niet toegestaan voor " + this.group.settings.name,
+                code: 'as_organization_disabled',
+                message: 'allowRegistrationsByOrganization disabled',
+                human: 'Inschrijvingen door organisaties zijn niet toegestaan voor ' + this.group.settings.name,
             });
         }
         for (const registration of this.replaceRegistrations) {
             // todo: check if you are allowed to move
             if (registration.memberId !== this.member.id) {
                 throw new SimpleError({
-                    code: "invalid_move",
-                    message: "Invalid member in replaceRegistration",
-                    human: "Je wilt een inschrijving verplaatsen van een ander lid in ruil voor een ander lid. Dit is niet toegestaan.",
-                    field: "replaceRegistrations"
+                    code: 'invalid_move',
+                    message: 'Invalid member in replaceRegistration',
+                    human: 'Je wilt een inschrijving verplaatsen van een ander lid in ruil voor een ander lid. Dit is niet toegestaan.',
+                    field: 'replaceRegistrations',
                 });
             }
             if (registration.group.organizationId !== this.organization.id) {
                 throw new SimpleError({
-                    code: "invalid_move",
-                    message: "Invalid organization in replaceRegistration",
-                    human: "Je wilt een inschrijving verplaatsen van een andere organisatie. Dit is niet toegestaan.",
-                    field: "replaceRegistrations"
+                    code: 'invalid_move',
+                    message: 'Invalid organization in replaceRegistration',
+                    human: 'Je wilt een inschrijving verplaatsen van een andere organisatie. Dit is niet toegestaan.',
+                    field: 'replaceRegistrations',
                 });
             }
             if (!admin) {
                 throw new SimpleError({
-                    code: "invalid_move",
-                    message: "Not allowed to move registrations",
-                    human: "Enkel beheerders kunnen inschrijvingen verplaatsen.",
-                    field: "replaceRegistrations"
+                    code: 'invalid_move',
+                    message: 'Not allowed to move registrations',
+                    human: 'Enkel beheerders kunnen inschrijvingen verplaatsen.',
+                    field: 'replaceRegistrations',
                 });
             }
             this.validatePeriod(registration.group, 'move', admin);
@@ -612,17 +612,17 @@ export class RegisterItem {
         // Already registered
         if (this.isAlreadyRegistered()) {
             throw new SimpleError({
-                code: "already_registered",
-                message: "Already registered",
-                human: `${this.member.member.firstName} is al ingeschreven voor ${this.group.settings.name}`
+                code: 'already_registered',
+                message: 'Already registered',
+                human: `${this.member.member.firstName} is al ingeschreven voor ${this.group.settings.name}`,
             });
         }
         if (this.hasReachedCategoryMaximum()) {
             // Only happens if maximum is reached in teh cart (because maximum without cart is already checked in shouldShow)
             throw new SimpleError({
-                code: "maximum_reached",
-                message: "Maximum reached",
-                human: `Je kan niet meer inschrijven voor ${this.group.settings.name} omdat ${this.member.patchedMember.name} al ingeschreven is voor een groep die je niet kan combineren.`
+                code: 'maximum_reached',
+                message: 'Maximum reached',
+                human: `Je kan niet meer inschrijven voor ${this.group.settings.name} omdat ${this.member.patchedMember.name} al ingeschreven is voor een groep die je niet kan combineren.`,
             });
         }
         // Check if we have an invite (doesn't matter if registrations are closed)
@@ -633,16 +633,16 @@ export class RegisterItem {
             if (!(options === null || options === void 0 ? void 0 : options.forWaitingList)) {
                 if (this.group.notYetOpen) {
                     throw new SimpleError({
-                        code: "not_yet_open",
-                        message: "Not yet open",
-                        human: `De inschrijvingen voor ${this.group.settings.name} zijn nog niet geopend.`
+                        code: 'not_yet_open',
+                        message: 'Not yet open',
+                        human: `De inschrijvingen voor ${this.group.settings.name} zijn nog niet geopend.`,
                     });
                 }
                 if (this.group.closed) {
                     throw new SimpleError({
-                        code: "closed",
-                        message: "Closed",
-                        human: `De inschrijvingen voor ${this.group.settings.name} zijn gesloten.`
+                        code: 'closed',
+                        message: 'Closed',
+                        human: `De inschrijvingen voor ${this.group.settings.name} zijn gesloten.`,
                     });
                 }
             }
@@ -651,39 +651,39 @@ export class RegisterItem {
                 if (!this.member.member.details.doesMatchGroup(this.group)) {
                     const error = this.member.member.details.getMatchingError(this.group);
                     throw new SimpleError({
-                        code: "not_matching",
-                        message: "Not matching: memberDetails",
-                        human: (_a = error === null || error === void 0 ? void 0 : error.description) !== null && _a !== void 0 ? _a : `${this.member.patchedMember.name} voldoet niet aan de voorwaarden om in te schrijven voor deze groep.`
+                        code: 'not_matching',
+                        message: 'Not matching: memberDetails',
+                        human: (_a = error === null || error === void 0 ? void 0 : error.description) !== null && _a !== void 0 ? _a : `${this.member.patchedMember.name} voldoet niet aan de voorwaarden om in te schrijven voor deze groep.`,
                     });
                 }
             }
             // Check if registrations are limited
             if (!this.doesMeetRequireGroupIds()) {
                 throw new SimpleError({
-                    code: "not_matching",
-                    message: "Not matching: requireGroupIds",
-                    human: `${this.member.patchedMember.name} voldoet niet aan de voorwaarden om in te schrijven voor deze groep (verplichte inschrijving bij leeftijdsgroep).`
+                    code: 'not_matching',
+                    message: 'Not matching: requireGroupIds',
+                    human: `${this.member.patchedMember.name} voldoet niet aan de voorwaarden om in te schrijven voor deze groep (verplichte inschrijving bij leeftijdsgroep).`,
                 });
             }
             if (!this.doesMeetRequireOrganizationIds()) {
                 throw new SimpleError({
-                    code: "not_matching",
-                    message: "Not matching: requireOrganizationIds",
-                    human: `${this.member.patchedMember.name} kan pas inschrijven met een geldige actieve inschrijving  (verplichte inschrijving bij lokale groep).`
+                    code: 'not_matching',
+                    message: 'Not matching: requireOrganizationIds',
+                    human: `${this.member.patchedMember.name} kan pas inschrijven met een geldige actieve inschrijving  (verplichte inschrijving bij lokale groep).`,
                 });
             }
             if (!this.doesMeetRequireOrganizationTags()) {
                 throw new SimpleError({
-                    code: "not_matching",
-                    message: "Not matching: requireOrganizationIds",
-                    human: `${this.member.patchedMember.name} kan pas inschrijven met een geldige actieve inschrijving  (verplichte inschrijving in regio).`
+                    code: 'not_matching',
+                    message: 'Not matching: requireOrganizationIds',
+                    human: `${this.member.patchedMember.name} kan pas inschrijven met een geldige actieve inschrijving  (verplichte inschrijving in regio).`,
                 });
             }
             if (!this.doesMeetRequirePlatformMembershipOn()) {
                 throw new SimpleError({
-                    code: "not_matching",
-                    message: "Not matching: requirePlatformMembershipOn",
-                    human: `${this.member.patchedMember.name} kan pas inschrijven met een geldige aansluiting (en dus verzekering) bij de koepel`
+                    code: 'not_matching',
+                    message: 'Not matching: requirePlatformMembershipOn',
+                    human: `${this.member.patchedMember.name} kan pas inschrijven met een geldige aansluiting (en dus verzekering) bij de koepel`,
                 });
             }
             const existingMember = this.isExistingMemberOrFamily();
@@ -691,9 +691,9 @@ export class RegisterItem {
             if (this.group.activePreRegistrationDate) {
                 if (!existingMember) {
                     throw new SimpleError({
-                        code: "pre_registrations",
-                        message: "Pre registrations",
-                        human: "Momenteel zijn de voorinschrijvingen nog bezig voor " + this.group.settings.name + ". Dit is enkel voor bestaande leden" + (this.group.settings.priorityForFamily ? " en hun broers/zussen" : "") + "."
+                        code: 'pre_registrations',
+                        message: 'Pre registrations',
+                        human: 'Momenteel zijn de voorinschrijvingen nog bezig voor ' + this.group.settings.name + '. Dit is enkel voor bestaande leden' + (this.group.settings.priorityForFamily ? ' en hun broers/zussen' : '') + '.',
                     });
                 }
             }
@@ -702,27 +702,27 @@ export class RegisterItem {
                 // More detailed error messages
                 if (this.group.settings.waitingListType === WaitingListType.All) {
                     throw new SimpleError({
-                        code: "waiting_list_required",
-                        message: "Waiting list required",
+                        code: 'waiting_list_required',
+                        message: 'Waiting list required',
                         human: `Iedereen moet zich eerst op de wachtlijst inschrijven`,
-                        meta: { recoverable: true }
+                        meta: { recoverable: true },
                     });
                 }
                 if (this.group.settings.waitingListType === WaitingListType.ExistingMembersFirst && !existingMember) {
                     throw new SimpleError({
-                        code: "waiting_list_required",
-                        message: "Waiting list required",
+                        code: 'waiting_list_required',
+                        message: 'Waiting list required',
                         human: `Nieuwe leden moeten zich eerst op de wachtlijst inschrijven`,
-                        meta: { recoverable: true }
+                        meta: { recoverable: true },
                     });
                 }
                 if (this.group.waitingList) {
                     if (reachedMaximum) {
                         throw new SimpleError({
-                            code: "waiting_list_required",
-                            message: "Waiting list required",
+                            code: 'waiting_list_required',
+                            message: 'Waiting list required',
                             human: `De inschrijvingen voor ${this.group.settings.name} zijn volzet. Je kan wel nog inschrijven voor de wachtlijst`,
-                            meta: { recoverable: true }
+                            meta: { recoverable: true },
                         });
                     }
                 }
@@ -730,10 +730,10 @@ export class RegisterItem {
             if (reachedMaximum && !this.group.waitingList) {
                 // Reached maximum without waiting lists
                 throw new SimpleError({
-                    code: "maximum_reached",
-                    message: "Maximum reached",
+                    code: 'maximum_reached',
+                    message: 'Maximum reached',
                     human: `De inschrijvingen voor ${this.group.settings.name} zijn volzet`,
-                    meta: { recoverable: true }
+                    meta: { recoverable: true },
                 });
             }
             // Only check individual stock if we haven't reached the maximum - otherwise it won't suggest to use the waiting list
@@ -741,20 +741,20 @@ export class RegisterItem {
                 // Check individual stock
                 if (this.groupPrice.getRemainingStock(this) === 0) {
                     throw new SimpleError({
-                        code: "stock_empty",
-                        message: "Stock empty",
+                        code: 'stock_empty',
+                        message: 'Stock empty',
                         human: `Het tarief ${this.groupPrice.name} is uitverkocht`,
-                        meta: { recoverable: true }
+                        meta: { recoverable: true },
                     });
                 }
                 for (const option of this.options) {
                     const remaining = option.option.getRemainingStock(this);
                     if (remaining !== null && remaining < option.amount) {
                         throw new SimpleError({
-                            code: "stock_empty",
-                            message: "Stock empty",
+                            code: 'stock_empty',
+                            message: 'Stock empty',
                             human: remaining === 0 ? `De keuzemogelijkheid ${option.option.name} is uitverkocht` : `Er zijn nog maar ${Formatter.pluralText(remaining, 'stuk', 'stuks')} beschikbaar van ${option.option.name}`,
-                            meta: { recoverable: true }
+                            meta: { recoverable: true },
                         });
                     }
                 }
@@ -769,21 +769,21 @@ export class RegisterItem {
     static fromId(idRegisterItem, context) {
         const member = context.members.find(m => m.member.id === idRegisterItem.memberId);
         if (!member) {
-            throw new Error("Member not found: " + idRegisterItem.memberId);
+            throw new Error('Member not found: ' + idRegisterItem.memberId);
         }
         const organization = context.organizations.find(o => o.id === idRegisterItem.organizationId);
         if (!organization) {
-            throw new Error("Organization not found: " + idRegisterItem.organizationId);
+            throw new Error('Organization not found: ' + idRegisterItem.organizationId);
         }
         const group = context.groups.find(g => g.id === idRegisterItem.groupId);
         if (!group) {
-            throw new Error("Group not found: " + idRegisterItem.groupId);
+            throw new Error('Group not found: ' + idRegisterItem.groupId);
         }
         const replaceRegistrations = [];
         for (const registrationId of idRegisterItem.replaceRegistrationIds) {
             const registration = member.patchedMember.registrations.find(r => r.id === registrationId);
             if (!registration) {
-                throw new Error("Registration not found: " + registrationId);
+                throw new Error('Registration not found: ' + registrationId);
             }
             replaceRegistrations.push(registration);
         }
@@ -794,7 +794,7 @@ export class RegisterItem {
             organization,
             groupPrice: idRegisterItem.groupPrice,
             options: idRegisterItem.options,
-            replaceRegistrations
+            replaceRegistrations,
         });
     }
     /**
@@ -804,13 +804,12 @@ export class RegisterItem {
     getCartPendingStockReservations() {
         const deleteRegistrations = [
             ...this.checkout.cart.deleteRegistrations.filter(r => r.groupId === this.group.id),
-            ...this.replaceRegistrations.filter(r => r.groupId === this.group.id)
+            ...this.replaceRegistrations.filter(r => r.groupId === this.group.id),
         ];
         const cartIndex = this.checkout.cart.items.findIndex(i => i.id === this.id);
         const itemsBefore = this.checkout.cart.items.slice(0, cartIndex === -1 ? undefined : cartIndex);
         return StockReservation.removed(itemsBefore.flatMap(i => i.getPendingStockReservations()), // these will be removed
-        deleteRegistrations.flatMap(r => r.stockReservations) // these will be freed up
-        );
+        deleteRegistrations.flatMap(r => r.stockReservations));
     }
     /**
      * Stock that will be taken or removed by this item
@@ -827,17 +826,17 @@ export class RegisterItem {
                     StockReservation.create({
                         objectId: this.groupPrice.id,
                         objectType: 'GroupPrice',
-                        amount: 1
+                        amount: 1,
                     }),
-                    ...this.options.map(o => {
+                    ...this.options.map((o) => {
                         return StockReservation.create({
                             objectId: o.option.id,
                             objectType: 'GroupOption',
-                            amount: o.amount
+                            amount: o.amount,
                         });
-                    })
-                ]
-            })
+                    }),
+                ],
+            }),
         ];
         const freed = this.replaceRegistrations.flatMap(r => r.stockReservations);
         return StockReservation.removed(base, freed);