@stamhoofd/structures 2.118.1 → 2.120.0

package/dist/GroupSettings.js

@@ -0,0 +1,884 @@
+import { __decorate } from "tslib";
+import { ArrayDecoder, AutoEncoder, BooleanDecoder, DateDecoder, EnumDecoder, field, IntegerDecoder, MapDecoder, StringDecoder } from '@simonbackx/simple-encoding';
+import { Formatter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from 'uuid';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { BundleDiscountGroupPriceSettings } from './BundleDiscountGroupPriceSettings.js';
+import { Group } from './Group.js';
+import { GroupGenderType } from './GroupGenderType.js';
+import { OldGroupPrices } from './OldGroupPrices.js';
+import { ReduceablePrice } from './ReduceablePrice.js';
+import { RegistrationPeriodBase } from './RegistrationPeriodBase.js';
+import { StockReservation } from './StockReservation.js';
+import { TranslatedString } from './TranslatedString.js';
+import { Image } from './files/Image.js';
+import { OrganizationRecordsConfiguration } from './members/OrganizationRecordsConfiguration.js';
+import { RecordCategory } from './members/records/RecordCategory.js';
+export class GroupPrice extends AutoEncoder {
+    id;
+    name;
+    price;
+    hidden = false;
+    /**
+     * Total stock, excluding already sold items into account
+     */
+    stock;
+    /**
+     * @deprecated removed
+     */
+    _usedStock;
+    /**
+     * @deprecated removed
+     */
+    _reserved;
+    /**
+     * Bundle discounts that are enabled for this group price, and possible custom settings
+     */
+    bundleDiscounts;
+    startDate;
+    endDate;
+    getUsedStock(group) {
+        const groupStockReservations = group.stockReservations;
+        return StockReservation.getAmount('GroupPrice', this.id, groupStockReservations);
+    }
+    /**
+     * Can be negative is we are editing items, positive if other items in the cart cause stock changes
+     */
+    getPendingStock(item) {
+        const stock = item.getCartPendingStockReservations(); // this is positive if it will be used
+        return StockReservation.getAmount('GroupPrice', this.id, StockReservation.filter('Group', item.group.id, stock));
+    }
+    isSoldOut(item) {
+        if (this.stock === null) {
+            return false;
+        }
+        if (item instanceof Group) {
+            return this.getUsedStock(item) >= this.stock;
+        }
+        return this.getUsedStock(item.group) + this.getPendingStock(item) >= this.stock;
+    }
+    getRemainingStock(item) {
+        if (this.stock === null) {
+            return null;
+        }
+        if (item instanceof Group) {
+            return Math.max(0, this.stock - this.getUsedStock(item));
+        }
+        return Math.max(0, this.stock - this.getPendingStock(item) - this.getUsedStock(item.group));
+    }
+    isInPeriod(date) {
+        if (this.startDate !== null && this.startDate > date) {
+            return false;
+        }
+        if (this.endDate !== null && this.endDate < date) {
+            return false;
+        }
+        return true;
+    }
+}
+__decorate([
+    field({ decoder: StringDecoder, defaultValue: () => uuidv4() })
+], GroupPrice.prototype, "id", void 0);
+__decorate([
+    field({ decoder: StringDecoder, defaultValue: () => '' }),
+    field(TranslatedString.field({ version: 370, defaultValue: () => new TranslatedString($t(`%132`)) }))
+], GroupPrice.prototype, "name", void 0);
+__decorate([
+    field({ decoder: ReduceablePrice, defaultValue: () => ReduceablePrice.create({}) })
+], GroupPrice.prototype, "price", void 0);
+__decorate([
+    field({ decoder: BooleanDecoder, version: 290 })
+], GroupPrice.prototype, "hidden", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, nullable: true, version: 290 })
+], GroupPrice.prototype, "stock", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, optional: true, field: 'usedStock' })
+], GroupPrice.prototype, "_usedStock", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, optional: true, field: 'reserved' })
+], GroupPrice.prototype, "_reserved", void 0);
+__decorate([
+    field({ decoder: new MapDecoder(StringDecoder, BundleDiscountGroupPriceSettings), version: 374 })
+], GroupPrice.prototype, "bundleDiscounts", void 0);
+__decorate([
+    field({ decoder: DateDecoder, nullable: true, version: 378 })
+], GroupPrice.prototype, "startDate", void 0);
+__decorate([
+    field({ decoder: DateDecoder, nullable: true, version: 378 })
+], GroupPrice.prototype, "endDate", void 0);
+export class GroupOption extends AutoEncoder {
+    id;
+    name = '';
+    hidden = false;
+    /**
+     * Price added (can be negative) is always in cents, to avoid floating point errors
+     */
+    price = ReduceablePrice.create({});
+    /**
+     * Maximum per registration (if > 1, you can choose an amount for this option)
+     * If null = infinite
+     */
+    allowAmount = false;
+    /**
+     * Maximum per registration (in case allowAmount is true)
+     * If null = infinite
+     */
+    maximum = null;
+    /**
+     * Total stock, excluding already sold items into account
+     */
+    stock = null;
+    /**
+     * @deprecated removed
+     */
+    _usedStock = 0;
+    /**
+     * @deprecated removed
+     */
+    _reserved = 0;
+    getUsedStock(group) {
+        const groupStockReservations = group.stockReservations;
+        return StockReservation.getAmount('GroupOption', this.id, groupStockReservations);
+    }
+    /**
+     * Can be negative is we are editing items, positive if other items in the cart cause stock changes
+     */
+    getPendingStock(item) {
+        const stock = item.getCartPendingStockReservations(); // this is positive if it will be used
+        return StockReservation.getAmount('GroupOption', this.id, StockReservation.filter('Group', item.group.id, stock));
+    }
+    isSoldOut(item) {
+        if (this.stock === null) {
+            return false;
+        }
+        if (item instanceof Group) {
+            return this.getUsedStock(item) >= this.stock;
+        }
+        return this.getUsedStock(item.group) + this.getPendingStock(item) >= this.stock;
+    }
+    getRemainingStock(item) {
+        if (this.stock === null) {
+            return null;
+        }
+        if (item instanceof Group) {
+            return Math.max(0, this.stock - this.getUsedStock(item));
+        }
+        return Math.max(0, this.stock - this.getPendingStock(item) - this.getUsedStock(item.group));
+    }
+    getMaximumSelection(item) {
+        if (this.maximum === null) {
+            return this.getRemainingStock(item);
+        }
+        const remaining = this.getRemainingStock(item);
+        if (remaining === null) {
+            return this.maximum;
+        }
+        return Math.min(this.maximum, remaining);
+    }
+}
+__decorate([
+    field({ decoder: StringDecoder, defaultValue: () => uuidv4() })
+], GroupOption.prototype, "id", void 0);
+__decorate([
+    field({ decoder: StringDecoder })
+], GroupOption.prototype, "name", void 0);
+__decorate([
+    field({ decoder: BooleanDecoder, version: 290 })
+], GroupOption.prototype, "hidden", void 0);
+__decorate([
+    field({ decoder: ReduceablePrice })
+], GroupOption.prototype, "price", void 0);
+__decorate([
+    field({ decoder: BooleanDecoder })
+], GroupOption.prototype, "allowAmount", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, nullable: true })
+], GroupOption.prototype, "maximum", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, nullable: true, version: 290 })
+], GroupOption.prototype, "stock", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, optional: true, field: 'usedStock' })
+], GroupOption.prototype, "_usedStock", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, optional: true, field: 'reserved' })
+], GroupOption.prototype, "_reserved", void 0);
+export class GroupOptionMenu extends AutoEncoder {
+    id;
+    name = '';
+    description = '';
+    multipleChoice = false;
+    options = [
+        GroupOption.create({}),
+    ];
+    get hidden() {
+        return this.options.length > 0 && this.options.every(o => o.hidden);
+    }
+    getFilteredOptions(options) {
+        return this.options.filter((p) => {
+            if (p.hidden && !options?.admin) {
+                return false;
+            }
+            return true;
+        });
+    }
+    getDefaultOption(options) {
+        if (options?.admin || this.hidden) {
+            return this.options[0];
+        }
+        return this.options.filter(o => !o.hidden)[0];
+    }
+}
+__decorate([
+    field({ decoder: StringDecoder, defaultValue: () => uuidv4() })
+], GroupOptionMenu.prototype, "id", void 0);
+__decorate([
+    field({ decoder: StringDecoder })
+], GroupOptionMenu.prototype, "name", void 0);
+__decorate([
+    field({ decoder: StringDecoder })
+], GroupOptionMenu.prototype, "description", void 0);
+__decorate([
+    field({ decoder: BooleanDecoder })
+], GroupOptionMenu.prototype, "multipleChoice", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(GroupOption) })
+], GroupOptionMenu.prototype, "options", void 0);
+export var WaitingListType;
+(function (WaitingListType) {
+    WaitingListType["None"] = "None";
+    WaitingListType["PreRegistrations"] = "PreRegistrations";
+    WaitingListType["ExistingMembersFirst"] = "ExistingMembersFirst";
+    WaitingListType["All"] = "All";
+})(WaitingListType || (WaitingListType = {}));
+export class CycleInformation extends AutoEncoder {
+    startDate = null;
+    endDate = null;
+    registeredMembers = 0;
+    /**
+     * Amount of members that is reserved (e.g in payment process, or a member on the waiting list that is invited)
+     */
+    reservedMembers = 0;
+    /**
+     * Amount of members on the waiting list
+     */
+    waitingListSize = 0;
+}
+__decorate([
+    field({ decoder: DateDecoder, nullable: true })
+], CycleInformation.prototype, "startDate", void 0);
+__decorate([
+    field({ decoder: DateDecoder, nullable: true })
+], CycleInformation.prototype, "endDate", void 0);
+__decorate([
+    field({
+        decoder: IntegerDecoder,
+        nullable: true,
+    })
+], CycleInformation.prototype, "registeredMembers", void 0);
+__decorate([
+    field({
+        decoder: IntegerDecoder,
+        nullable: true,
+        version: 139,
+    })
+], CycleInformation.prototype, "reservedMembers", void 0);
+__decorate([
+    field({
+        decoder: IntegerDecoder,
+        nullable: true,
+        version: 139,
+    })
+], CycleInformation.prototype, "waitingListSize", void 0);
+export class GroupDefaultEventTime extends AutoEncoder {
+    dayOfWeek = 1; // 1 = monday, 7 = sunday
+    startTime = 0; // minutes since midnight
+    endTime = 0; // minutes since midnight
+}
+__decorate([
+    field({ decoder: IntegerDecoder })
+], GroupDefaultEventTime.prototype, "dayOfWeek", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder })
+], GroupDefaultEventTime.prototype, "startTime", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder })
+], GroupDefaultEventTime.prototype, "endTime", void 0);
+export class GroupSettings extends AutoEncoder {
+    name = new TranslatedString();
+    description = new TranslatedString();
+    eventId = null;
+    /**
+     * Cached value so we know what period this group is in, to calculate the age requirements,
+     * and to display the time period in the UI
+     */
+    period = null;
+    prices = [GroupPrice.create({})];
+    optionMenus = [];
+    recordsConfiguration;
+    /**
+     * Note: these are saved in the registration, not the member.
+     * Do not confuse with the member's record categories in recordsConfiguration
+     */
+    recordCategories = [];
+    /**
+     * Date when the online registrations open automatically (note: the group should be open for this to work)
+     */
+    registrationStartDate = null;
+    /**
+     * Date when the online registrations close automatically
+     */
+    registrationEndDate = null;
+    /**
+     * Experimental feature to suggest when to create new activities in the calendar.
+     */
+    defaultEventTime = null;
+    genderType = GroupGenderType.Mixed;
+    /**
+     * Number of days on trial for new members
+     */
+    trialDays = 0;
+    minAge = null;
+    maxAge = null;
+    waitingListType = WaitingListType.None;
+    /**
+     * Only used for waitingListType = PreRegistrations
+     */
+    preRegistrationsDate = null;
+    maxMembers = null;
+    /**
+     * @deprecated
+     * Use waitinglist instead to determine if a waiting list is enabled
+     */
+    waitingListIfFull = true;
+    /**
+     * @deprecated
+     * If maxMembers is not null, this will get filled in by the backend
+     */
+    registeredMembers = 0;
+    /**
+     * @deprecated
+     * Amount of members that is reserved (e.g in payment process, or a member on the waiting list that is invited)
+     */
+    reservedMembers = 0;
+    /**
+     * @deprecated
+     * Amount of members on the waiting list
+     */
+    waitingListSize = null;
+    getUsedStock(group) {
+        const groupStockReservations = group.stockReservations;
+        return StockReservation.getAmount('GroupPrice', null, groupStockReservations);
+    }
+    /**
+     * Can be negative is we are editing items, positive if other items in the cart cause stock changes
+     */
+    getPendingStock(item) {
+        const stock = item.getCartPendingStockReservations(); // this is positive if it will be used
+        return StockReservation.getAmount('Group', item.group.id, stock);
+    }
+    isSoldOut(item) {
+        if (this.maxMembers === null) {
+            return false;
+        }
+        if (item instanceof Group) {
+            return this.getUsedStock(item) >= this.maxMembers;
+        }
+        return this.getUsedStock(item.group) + this.getPendingStock(item) >= this.maxMembers;
+    }
+    getRemainingStock(item) {
+        if (this.maxMembers === null) {
+            return null;
+        }
+        if (item instanceof Group) {
+            return Math.max(0, this.maxMembers - this.getUsedStock(item));
+        }
+        return Math.max(0, this.maxMembers - this.getPendingStock(item) - this.getUsedStock(item.group));
+    }
+    get isFull() {
+        return this.maxMembers !== null && this.registeredMembers !== null && (this.registeredMembers + (this.reservedMembers ?? 0)) >= this.maxMembers;
+    }
+    get availableMembers() {
+        if (this.maxMembers === null) {
+            return null;
+        }
+        if (this.registeredMembers === null) {
+            return null;
+        }
+        return this.maxMembers - this.registeredMembers - (this.reservedMembers ?? 0);
+    }
+    /**
+     * Of er voorrang moet gegeven worden aan broers en/of zussen als er wachtlijsten of voorinschrijvingen zijn
+     */
+    priorityForFamily = true;
+    coverPhoto = null;
+    squarePhoto = null;
+    /**
+     * @deprecated
+     */
+    oldPrices = [];
+    /**
+     * @deprecated
+     */
+    images = [];
+    /**
+     * @deprecated
+     */
+    location = '';
+    /**
+     * Require that the member is already registered for one of these groups before allowing to register for this group.
+     * If it is empty, then it is not enforced
+     */
+    requireGroupIds = [];
+    /**
+     * Prevent members from these groups from registering for this group.
+     */
+    preventGroupIds = [];
+    /**
+     * Require that the member is already registered for one of these groups before allowing to register for this group.
+     * If it is empty, then it is not enforced
+     */
+    requireDefaultAgeGroupIds = [];
+    /**
+     * The member should have a platform membership for the provided date before being able to register
+     * OR on the date of the registration
+     */
+    requirePlatformMembershipOn = null;
+    /**
+     * The member should have a platform membership on the date of the registration before being able to register
+     */
+    requirePlatformMembershipOnRegistrationDate = false;
+    /**
+     * The member should have a valid registration (type = GroupType.Membership) for one of these organization ids
+     *
+     * If empty and requireOrganizationTags empty: new members without registrations can also register
+     */
+    requireOrganizationIds = [];
+    /**
+     * The member should have a valid registration (type = GroupType.Membership) for one of these organization tags
+     *
+     * If empty AND requireOrganizationIds empty: new members without registrations can also register
+     */
+    requireOrganizationTags = [];
+    /**
+     * Allow other admins to see registrations of this group - but only for the members they have access to.
+     * Note: when allowRegistrationsByOrganization is enabled, this is implied
+     */
+    allowViewRegistrations = false;
+    /**
+     * Allow other organizations to register members in this group
+     * This would create a payment between the organizations instead, so that often requires invoicing
+     */
+    allowRegistrationsByOrganization = false;
+    get implicitlyAllowViewRegistrations() {
+        return this.allowRegistrationsByOrganization || this.allowViewRegistrations;
+    }
+    /**
+     * @deprecated
+     * Require that the member is already registered for one of these groups before allowing to register for this group.
+     * If it is empty, then it is not enforced
+     */
+    requirePreviousGroupIds = [];
+    /**
+     * @deprecated
+     */
+    preventPreviousGroupIds = [];
+    /**
+     * @deprecated
+     * Information about previous cycles
+     */
+    cycleSettings = new Map();
+    hasCustomDates = false;
+    startDate = new Date();
+    endDate = new Date();
+    /**
+     * @deprecated
+     * Dispay start and end date times
+     */
+    displayStartEndTime = false;
+    /**
+     * @deprecated
+     */
+    getGroupPrices(date) {
+        let foundPrice = undefined;
+        // Determine price
+        for (const price of this.oldPrices) {
+            if (!price.startDate || price.startDate <= date) {
+                foundPrice = price;
+            }
+        }
+        return foundPrice;
+    }
+    get maxYear() {
+        if (this.minAge === null) {
+            return null;
+        }
+        return (this.startDate.getFullYear() - this.minAge);
+    }
+    get minYear() {
+        if (this.maxAge === null) {
+            return null;
+        }
+        return (this.startDate.getFullYear() - this.maxAge);
+    }
+    get forAdults() {
+        return ((this.minAge && this.minAge >= 18) || (this.maxAge && this.maxAge > 18));
+    }
+    getAgeGenderDescription({ includeAge = false, includeGender = false } = {}) {
+        let who = '';
+        if (includeAge && this.minYear && this.maxYear) {
+            if (includeGender && this.genderType === GroupGenderType.OnlyMale) {
+                if (this.forAdults) {
+                    who += $t(`%133`);
+                }
+                else {
+                    who += $t(`%134`);
+                }
+            }
+            else if (includeGender && this.genderType === GroupGenderType.OnlyFemale) {
+                if (this.forAdults) {
+                    who += $t(`%135`);
+                }
+                else {
+                    who += $t(`%136`);
+                }
+            }
+            else {
+                who += $t(`%137`);
+            }
+            if (this.minYear === this.maxYear) {
+                who += ' ' + (this.minYear);
+            }
+            else {
+                who += ' ' + (this.minYear) + ' - ' + (this.maxYear);
+            }
+        }
+        else if (includeAge && this.maxYear) {
+            if (includeGender && this.genderType === GroupGenderType.OnlyMale) {
+                if (this.forAdults) {
+                    who += $t(`%138`);
+                }
+                else {
+                    who += $t(`%139`);
+                }
+            }
+            else if (includeGender && this.genderType === GroupGenderType.OnlyFemale) {
+                if (this.forAdults) {
+                    who += $t(`%13A`);
+                }
+                else {
+                    who += $t(`%13B`);
+                }
+            }
+            else {
+                who += $t(`%13C`);
+            }
+            who += ' ' + (this.maxYear);
+        }
+        else if (includeAge && this.minYear) {
+            if (includeGender && this.genderType === GroupGenderType.OnlyMale) {
+                if (this.forAdults) {
+                    who += $t(`%13D`);
+                }
+                else {
+                    who += $t(`%13E`);
+                }
+            }
+            else if (includeGender && this.genderType === GroupGenderType.OnlyFemale) {
+                if (this.forAdults) {
+                    who += $t(`%13F`);
+                }
+                else {
+                    who += $t(`%13G`);
+                }
+            }
+            else {
+                who += $t(`%13H`);
+            }
+            who += ' ' + (this.minYear);
+        }
+        else if (includeGender) {
+            if (this.genderType === GroupGenderType.OnlyMale) {
+                if (this.forAdults) {
+                    who += $t(`%13I`);
+                }
+                else {
+                    who += $t(`%13J`);
+                }
+            }
+            else if (this.genderType === GroupGenderType.OnlyFemale) {
+                if (this.forAdults) {
+                    who += $t(`%13K`);
+                }
+                else {
+                    who += $t(`%13L`);
+                }
+            }
+        }
+        if (!who) {
+            return null;
+        }
+        return who;
+    }
+    getMemberCount({ waitingList }) {
+        if (waitingList) {
+            return this.waitingListSize;
+        }
+        return this.registeredMembers;
+    }
+    getShortCode(maxLength) {
+        return Formatter.firstLetters(this.name, maxLength);
+    }
+    getFilteredPrices(options) {
+        if (options?.admin) {
+            return [...this.prices];
+        }
+        return this.prices.filter((p) => {
+            if (p.hidden) {
+                return false;
+            }
+            if (options?.date && !p.isInPeriod(options.date)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    getFilteredOptionMenus(options) {
+        return this.optionMenus.filter((p) => {
+            return p.getFilteredOptions(options).length > 0;
+        });
+    }
+    get isFree() {
+        return !this.prices.find(p => p.price.price > 0) && !this.optionMenus.find(o => o.options.find(p => p.price.price > 0));
+    }
+    throwIfInvalidPrices() {
+        const isForever = coversForever(this.prices);
+        if (!isForever) {
+            throw new SimpleError({
+                code: 'prices_period_gap',
+                message: 'Not every date has a price.',
+                human: $t('%1Cn'),
+            });
+        }
+    }
+}
+__decorate([
+    field({ decoder: StringDecoder }),
+    field(TranslatedString.field({ version: 370 }))
+], GroupSettings.prototype, "name", void 0);
+__decorate([
+    field({ decoder: StringDecoder }),
+    field(TranslatedString.field({ version: 370 }))
+], GroupSettings.prototype, "description", void 0);
+__decorate([
+    field({ decoder: StringDecoder, version: 350, nullable: true })
+], GroupSettings.prototype, "eventId", void 0);
+__decorate([
+    field({ decoder: RegistrationPeriodBase, nullable: true, version: 329 })
+], GroupSettings.prototype, "period", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(GroupPrice), version: 285, upgrade: () => { return []; } }) // Upgrade uses empty array to prevent generating random ids every time
+], GroupSettings.prototype, "prices", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(GroupOptionMenu), version: 285 })
+], GroupSettings.prototype, "optionMenus", void 0);
+__decorate([
+    field({
+        decoder: OrganizationRecordsConfiguration,
+        version: 291,
+        defaultValue: () => OrganizationRecordsConfiguration.create({}),
+    })
+], GroupSettings.prototype, "recordsConfiguration", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(RecordCategory), version: 338 })
+], GroupSettings.prototype, "recordCategories", void 0);
+__decorate([
+    field({ decoder: DateDecoder, nullable: false, version: 73, upgrade: function () { return this.startDate; } }),
+    field({ decoder: DateDecoder, nullable: true, version: 192, downgrade: function () { return this.registrationStartDate ?? this.startDate; } })
+], GroupSettings.prototype, "registrationStartDate", void 0);
+__decorate([
+    field({ decoder: DateDecoder, nullable: false, version: 73, upgrade: function () { return this.endDate; } }),
+    field({ decoder: DateDecoder, nullable: true, version: 192, downgrade: function () { return this.registrationEndDate ?? this.endDate; } })
+], GroupSettings.prototype, "registrationEndDate", void 0);
+__decorate([
+    field({ decoder: GroupDefaultEventTime, nullable: true, version: 283 })
+], GroupSettings.prototype, "defaultEventTime", void 0);
+__decorate([
+    field({ decoder: new EnumDecoder(GroupGenderType) })
+], GroupSettings.prototype, "genderType", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, version: 353 })
+], GroupSettings.prototype, "trialDays", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, nullable: true, field: 'maxBirthYear' }),
+    field({ decoder: IntegerDecoder, nullable: true, version: 12, upgrade: (year) => {
+            if (year === null) {
+                return null;
+            }
+            return 2020 - year;
+        } })
+], GroupSettings.prototype, "minAge", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, nullable: true, field: 'minBirthYear' }),
+    field({
+        decoder: IntegerDecoder, nullable: true, version: 12, upgrade: (year) => {
+            if (year === null) {
+                return null;
+            }
+            return 2020 - year;
+        },
+    })
+], GroupSettings.prototype, "maxAge", void 0);
+__decorate([
+    field({ decoder: new EnumDecoder(WaitingListType), version: 16 })
+], GroupSettings.prototype, "waitingListType", void 0);
+__decorate([
+    field({ decoder: DateDecoder, nullable: true, version: 16 })
+], GroupSettings.prototype, "preRegistrationsDate", void 0);
+__decorate([
+    field({
+        decoder: IntegerDecoder, nullable: true, version: 16,
+    }),
+    field({
+        decoder: IntegerDecoder,
+        nullable: true,
+        version: 74,
+        upgrade: function (old) {
+            // Clear value if waiting list type is none
+            if (this.waitingListType !== WaitingListType.None) {
+                return old;
+            }
+            return null;
+        },
+    })
+], GroupSettings.prototype, "maxMembers", void 0);
+__decorate([
+    field({
+        decoder: BooleanDecoder, version: 79,
+    })
+], GroupSettings.prototype, "waitingListIfFull", void 0);
+__decorate([
+    field({
+        decoder: IntegerDecoder,
+        nullable: true,
+        version: 77,
+    })
+], GroupSettings.prototype, "registeredMembers", void 0);
+__decorate([
+    field({
+        decoder: IntegerDecoder,
+        nullable: true,
+        version: 139,
+    })
+], GroupSettings.prototype, "reservedMembers", void 0);
+__decorate([
+    field({
+        decoder: IntegerDecoder,
+        nullable: true,
+        version: 139,
+        optional: true,
+    })
+], GroupSettings.prototype, "waitingListSize", void 0);
+__decorate([
+    field({ decoder: BooleanDecoder, version: 16 })
+], GroupSettings.prototype, "priorityForFamily", void 0);
+__decorate([
+    field({ decoder: Image, nullable: true, version: 65 })
+], GroupSettings.prototype, "coverPhoto", void 0);
+__decorate([
+    field({ decoder: Image, nullable: true, version: 66 })
+], GroupSettings.prototype, "squarePhoto", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(OldGroupPrices), field: 'prices' }),
+    field({ decoder: new ArrayDecoder(OldGroupPrices), field: 'oldPrices', optional: true, version: 284 })
+], GroupSettings.prototype, "oldPrices", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(Image), version: 58, optional: true })
+], GroupSettings.prototype, "images", void 0);
+__decorate([
+    field({ decoder: StringDecoder, version: 76, optional: true })
+], GroupSettings.prototype, "location", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(StringDecoder), version: 83 })
+], GroupSettings.prototype, "requireGroupIds", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(StringDecoder), version: 386 })
+], GroupSettings.prototype, "preventGroupIds", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(StringDecoder), version: 297 })
+], GroupSettings.prototype, "requireDefaultAgeGroupIds", void 0);
+__decorate([
+    field({ decoder: DateDecoder, nullable: true, version: 297 })
+], GroupSettings.prototype, "requirePlatformMembershipOn", void 0);
+__decorate([
+    field({ decoder: BooleanDecoder, version: 358 })
+], GroupSettings.prototype, "requirePlatformMembershipOnRegistrationDate", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(StringDecoder), version: 297 })
+], GroupSettings.prototype, "requireOrganizationIds", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(StringDecoder), version: 297 })
+], GroupSettings.prototype, "requireOrganizationTags", void 0);
+__decorate([
+    field({ decoder: BooleanDecoder, version: 387 })
+], GroupSettings.prototype, "allowViewRegistrations", void 0);
+__decorate([
+    field({ decoder: BooleanDecoder, version: 303 })
+], GroupSettings.prototype, "allowRegistrationsByOrganization", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(StringDecoder), version: 100, optional: true })
+], GroupSettings.prototype, "requirePreviousGroupIds", void 0);
+__decorate([
+    field({ decoder: new ArrayDecoder(StringDecoder), version: 102, optional: true })
+], GroupSettings.prototype, "preventPreviousGroupIds", void 0);
+__decorate([
+    field({ decoder: new MapDecoder(IntegerDecoder, CycleInformation), version: 193, optional: true })
+], GroupSettings.prototype, "cycleSettings", void 0);
+__decorate([
+    field({ decoder: BooleanDecoder, version: 383 })
+], GroupSettings.prototype, "hasCustomDates", void 0);
+__decorate([
+    field({ decoder: DateDecoder }),
+    field({ decoder: DateDecoder, version: 33, upgrade: (d) => {
+            const d2 = new Date(d);
+            d2.setUTCHours(-2, 0, 0, 0); // brussels time
+            return d2;
+        }, optional: true })
+], GroupSettings.prototype, "startDate", void 0);
+__decorate([
+    field({ decoder: DateDecoder }),
+    field({ decoder: DateDecoder, version: 33, upgrade: (d) => {
+            const d2 = new Date(d);
+            d2.setUTCHours(23 - 2, 59, 0, 0); // brussels time
+            return d2;
+        }, optional: true })
+], GroupSettings.prototype, "endDate", void 0);
+__decorate([
+    field({ decoder: BooleanDecoder, version: 78, optional: true })
+], GroupSettings.prototype, "displayStartEndTime", void 0);
+function coversForever(periods) {
+    const allowedGap = 1; // Allow 1ms gaps (23:59:59.999 to 00:00:00.000)
+    const normalized = periods
+        .map(({ startDate, endDate }) => ({
+        startDate: startDate ? startDate.getTime() : -Infinity,
+        endDate: endDate ? endDate.getTime() : Infinity,
+    }))
+        .filter(p => p.startDate < p.endDate) // Skip empty periods
+        .sort((a, b) => a.startDate - b.startDate);
+    if (normalized.length === 0)
+        return false;
+    const currentStart = normalized[0].startDate;
+    let currentEnd = normalized[0].endDate;
+    for (let i = 1; i < normalized.length; i++) {
+        const { startDate, endDate } = normalized[i];
+        if (startDate > currentEnd + allowedGap) {
+            // Gap found
+            return false;
+        }
+        currentEnd = Math.max(currentEnd, endDate);
+    }
+    return currentStart === -Infinity && currentEnd === Infinity;
+}
+export const GroupSettingsPatch = GroupSettings.patchType();
+//# sourceMappingURL=GroupSettings.js.map