@stamhoofd/structures 2.118.1 → 2.120.0

package/esm/dist/src/webshops/WebshopMetaData.js

@@ -1,754 +0,0 @@
-import { __decorate } from "tslib";
-import { ArrayDecoder, AutoEncoder, BooleanDecoder, DateDecoder, EnumDecoder, field, IntegerDecoder, StringDecoder } from '@simonbackx/simple-encoding';
-import { SimpleError } from '@simonbackx/simple-errors';
-import { Colors, Formatter } from '@stamhoofd/utility';
-import { v4 as uuidv4 } from 'uuid';
-import { Address } from '../addresses/Address.js';
-import { City } from '../addresses/City.js';
-import { CountryDecoder } from '../addresses/CountryDecoder.js';
-import { Province } from '../addresses/Province.js';
-import { DNSRecord, DNSRecordType } from '../DNSRecord.js';
-import { Replacement } from '../endpoints/EmailRequest.js';
-import { Image } from '../files/Image.js';
-import { RecordCategory } from '../members/records/RecordCategory.js';
-import { PaymentConfiguration, PrivatePaymentConfiguration } from '../PaymentConfiguration.js';
-import { PaymentMethod } from '../PaymentMethod.js';
-import { PermissionsByRole } from '../PermissionsByRole.js';
-import { Policy } from '../Policy.js';
-import { RichText } from '../RichText.js';
-import { SeatingPlan } from '../SeatingPlan.js';
-import { SponsorConfig } from '../SponsorConfig.js';
-import { Discount } from './Discount.js';
-import { TransferSettings } from './TransferSettings.js';
-import { WebshopField } from './WebshopField.js';
-import { upgradePriceFrom2To4DecimalPlaces } from '../upgradePriceFrom2To4DecimalPlaces.js';
-export var WebshopLayout;
-(function (WebshopLayout) {
-    WebshopLayout["Default"] = "Default";
-    WebshopLayout["Split"] = "Split";
-})(WebshopLayout || (WebshopLayout = {}));
-export var DarkMode;
-(function (DarkMode) {
-    DarkMode["Off"] = "Off";
-    DarkMode["On"] = "On";
-    DarkMode["Auto"] = "Auto";
-})(DarkMode || (DarkMode = {}));
-export class WebshopTimeSlot extends AutoEncoder {
-    constructor() {
-        super(...arguments);
-        /**
-         * Saved in minutes since midnight
-         */
-        this.startTime = 12 * 60;
-        /**
-         * Saved in minutes since midnight (so can also keep going after midnight to indicate an event that keeps going until e.g. 03:00)
-         */
-        this.endTime = 14 * 60;
-        this.maxOrders = null;
-        this.usedOrders = 0;
-        this.maxPersons = null;
-        this.usedPersons = 0;
-    }
-    get remainingOrders() {
-        if (this.maxOrders === null) {
-            return null;
-        }
-        return Math.max(0, this.maxOrders - this.usedOrders);
-    }
-    get remainingPersons() {
-        if (this.maxPersons === null) {
-            return null;
-        }
-        return Math.max(0, this.maxPersons - this.usedPersons);
-    }
-    /**
-     * In case maxPersons and maxOrders are used at the same time, try to transform it onto 1 number of remainign 'stock' for this timeslot,
-     * which will be visible for customers
-     */
-    get listedRemainingStock() {
-        const remainingOrders = this.remainingOrders;
-        const remainingPersons = this.remainingPersons;
-        if (remainingOrders === null && remainingPersons === null) {
-            return null;
-        }
-        if (remainingPersons === null) {
-            return remainingOrders;
-        }
-        if (remainingOrders === null) {
-            return remainingPersons;
-        }
-        if (remainingPersons === 0 || remainingOrders === 0) {
-            return 0;
-        }
-        // If we still have at least one remaining order, the remaining persons always is the number we need to show
-        return remainingPersons;
-    }
-    static sort(a, b) {
-        const aa = Formatter.dateIso(a.date) + ' ' + Formatter.minutesPadded(a.startTime) + ' ' + Formatter.minutesPadded(a.endTime);
-        const bb = Formatter.dateIso(b.date) + ' ' + Formatter.minutesPadded(b.startTime) + ' ' + Formatter.minutesPadded(b.endTime);
-        if (aa < bb) {
-            return -1;
-        }
-        if (aa > bb) {
-            return 1;
-        }
-        return 0;
-    }
-    /**
-     * Index for sorting on both start and end time
-     */
-    get timeIndex() {
-        return Formatter.timeIndex(this.startTime) + Formatter.timeIndex(this.endTime);
-    }
-    toString() {
-        return this.dateString() + ', ' + this.timeRangeString();
-    }
-    dateString() {
-        return Formatter.dateWithDay(this.date);
-    }
-    dateStringShort() {
-        return Formatter.date(this.date);
-    }
-    timeRangeString() {
-        return Formatter.minutes(this.startTime) + ' - ' + Formatter.minutes(this.endTime);
-    }
-    clearStock() {
-        this.usedOrders = 0;
-        this.usedPersons = 0;
-    }
-}
-__decorate([
-    field({ decoder: StringDecoder, defaultValue: () => uuidv4() })
-], WebshopTimeSlot.prototype, "id", void 0);
-__decorate([
-    field({ decoder: DateDecoder })
-], WebshopTimeSlot.prototype, "date", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder })
-], WebshopTimeSlot.prototype, "startTime", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder })
-], WebshopTimeSlot.prototype, "endTime", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder, nullable: true, version: 143 })
-], WebshopTimeSlot.prototype, "maxOrders", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder, version: 143 })
-], WebshopTimeSlot.prototype, "usedOrders", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder, nullable: true, version: 143 })
-], WebshopTimeSlot.prototype, "maxPersons", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder, version: 143 })
-], WebshopTimeSlot.prototype, "usedPersons", void 0);
-/**
- * Configuration to keep track of available time slots. Can be a fixed number or an infinite amount of time slots
- */
-export class WebshopTimeSlots extends AutoEncoder {
-    constructor() {
-        super(...arguments);
-        this.timeSlots = [];
-    }
-}
-__decorate([
-    field({ decoder: new ArrayDecoder(WebshopTimeSlot) })
-], WebshopTimeSlots.prototype, "timeSlots", void 0);
-export var CheckoutMethodType;
-(function (CheckoutMethodType) {
-    CheckoutMethodType["OnSite"] = "OnSite";
-    CheckoutMethodType["Takeout"] = "Takeout";
-    CheckoutMethodType["Delivery"] = "Delivery";
-})(CheckoutMethodType || (CheckoutMethodType = {}));
-export class CheckoutMethodTypeHelper {
-    static getName(type) {
-        switch (type) {
-            case CheckoutMethodType.OnSite:
-                return $t(`25e67f34-649f-4743-9cdd-d2a81d252daf`);
-            case CheckoutMethodType.Takeout:
-                return $t(`edd72e8b-76de-45df-93a0-ecc72efb849a`);
-            case CheckoutMethodType.Delivery:
-                return $t(`abba46da-6bb8-40cb-88f0-186c2409a0a5`);
-        }
-    }
-}
-export class CheckoutMethod extends AutoEncoder {
-    constructor() {
-        super(...arguments);
-        this.name = '';
-        this.description = '';
-        this.timeSlots = WebshopTimeSlots.create({});
-    }
-    get typeName() {
-        return CheckoutMethodTypeHelper.getName(this.type);
-    }
-    clearStock() {
-        for (const slot of this.timeSlots.timeSlots) {
-            slot.clearStock();
-        }
-    }
-}
-__decorate([
-    field({ decoder: StringDecoder, defaultValue: () => uuidv4() })
-], CheckoutMethod.prototype, "id", void 0);
-__decorate([
-    field({ decoder: new EnumDecoder(CheckoutMethodType) })
-], CheckoutMethod.prototype, "type", void 0);
-__decorate([
-    field({ decoder: StringDecoder })
-], CheckoutMethod.prototype, "name", void 0);
-__decorate([
-    field({ decoder: StringDecoder })
-], CheckoutMethod.prototype, "description", void 0);
-__decorate([
-    field({ decoder: WebshopTimeSlots })
-], CheckoutMethod.prototype, "timeSlots", void 0);
-export class WebshopTakeoutMethod extends CheckoutMethod {
-    constructor() {
-        super(...arguments);
-        this.type = CheckoutMethodType.Takeout;
-    }
-}
-__decorate([
-    field({ decoder: new EnumDecoder(CheckoutMethodType), patchDefaultValue: () => CheckoutMethodType.Takeout }) // patchDefaultVAlue -> to include this value in all patches and make sure we can recognize the type of the patch
-], WebshopTakeoutMethod.prototype, "type", void 0);
-__decorate([
-    field({ decoder: Address })
-], WebshopTakeoutMethod.prototype, "address", void 0);
-/**
- * Choose a location and time to eat / consume the order
- */
-export class WebshopOnSiteMethod extends CheckoutMethod {
-    constructor() {
-        super(...arguments);
-        // Indicate this field exists for all versions, but the downgrade should get executed
-        this.type = CheckoutMethodType.OnSite;
-    }
-}
-__decorate([
-    field({ decoder: new EnumDecoder(CheckoutMethodType) }),
-    field({
-        decoder: new EnumDecoder(CheckoutMethodType),
-        version: 105, downgrade: () => {
-            // Return takeout method for old clients
-            return CheckoutMethodType.Takeout;
-        },
-        patchDefaultValue: () => CheckoutMethodType.OnSite,
-    }) // patchDefaultVAlue -> to include this value in all patches and make sure we can recognize the type of the patch
-], WebshopOnSiteMethod.prototype, "type", void 0);
-__decorate([
-    field({ decoder: Address })
-], WebshopOnSiteMethod.prototype, "address", void 0);
-/**
- * If you want to have some sort of cost (e.g. delivery cost that is variable depending on the cart value)
- */
-export class CheckoutMethodPrice extends AutoEncoder {
-    constructor() {
-        super(...arguments);
-        this.price = 0;
-        /**
-         * At what price of the cart the discount price should be used instead.
-         * If it is null, the discount price will never get used
-         */
-        this.minimumPrice = null;
-        this.discountPrice = 0;
-    }
-}
-__decorate([
-    field({ decoder: IntegerDecoder }),
-    field({ ...upgradePriceFrom2To4DecimalPlaces })
-], CheckoutMethodPrice.prototype, "price", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder, nullable: true }),
-    field({ ...upgradePriceFrom2To4DecimalPlaces, nullable: true })
-], CheckoutMethodPrice.prototype, "minimumPrice", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder }),
-    field({ ...upgradePriceFrom2To4DecimalPlaces })
-], CheckoutMethodPrice.prototype, "discountPrice", void 0);
-export class WebshopDeliveryMethod extends CheckoutMethod {
-    constructor() {
-        super(...arguments);
-        this.type = CheckoutMethodType.Delivery;
-        this.price = CheckoutMethodPrice.create({});
-        this.cities = [];
-        this.provinces = [];
-        this.countries = [];
-    }
-}
-__decorate([
-    field({ decoder: new EnumDecoder(CheckoutMethodType), patchDefaultValue: () => CheckoutMethodType.Delivery }) // patchDefaultVAlue -> to include this value in all patches and make sure we can recognize the type of the patch
-], WebshopDeliveryMethod.prototype, "type", void 0);
-__decorate([
-    field({ decoder: CheckoutMethodPrice, version: 45 })
-], WebshopDeliveryMethod.prototype, "price", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(City), version: 46 })
-], WebshopDeliveryMethod.prototype, "cities", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(Province), version: 46 })
-], WebshopDeliveryMethod.prototype, "provinces", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(CountryDecoder), version: 46 })
-], WebshopDeliveryMethod.prototype, "countries", void 0);
-export class AnyCheckoutMethodPatchDecoder {
-    static decode(data) {
-        const base = data.decode(CheckoutMethod.patchType());
-        if (base.type === CheckoutMethodType.Takeout) {
-            return WebshopTakeoutMethod.patchType().decode(data);
-        }
-        if (base.type === CheckoutMethodType.Delivery) {
-            return WebshopDeliveryMethod.patchType().decode(data);
-        }
-        if (base.type === CheckoutMethodType.OnSite) {
-            return WebshopOnSiteMethod.patchType().decode(data);
-        }
-        throw new SimpleError({
-            code: 'invalid_field',
-            message: 'Unsupported checkout type in patch. Make sure checkout type is always set when patching.',
-            field: data.addToCurrentField('type'),
-        });
-    }
-    static patchType() {
-        // We never allow patches on this type
-        return AnyCheckoutMethodPatchDecoder;
-    }
-}
-export class AnyCheckoutMethodDecoder {
-    static decode(data) {
-        const base = data.decode(CheckoutMethod);
-        if (base.type === CheckoutMethodType.Takeout) {
-            return WebshopTakeoutMethod.decode(data);
-        }
-        if (base.type === CheckoutMethodType.Delivery) {
-            return WebshopDeliveryMethod.decode(data);
-        }
-        if (base.type === CheckoutMethodType.OnSite) {
-            return WebshopOnSiteMethod.decode(data);
-        }
-        throw new SimpleError({
-            code: 'invalid_field',
-            message: 'Unsupported checkout type',
-            field: data.addToCurrentField('type'),
-        });
-    }
-    static patchType() {
-        // We never allow patches on this type
-        return AnyCheckoutMethodPatchDecoder;
-    }
-    static patchIdentifier() {
-        // We never allow patches on this type
-        return StringDecoder;
-    }
-}
-export var WebshopType;
-(function (WebshopType) {
-    /**
-     * Simple webshop
-     */
-    WebshopType["Webshop"] = "Webshop";
-    WebshopType["Donations"] = "Donations";
-    WebshopType["TakeawayAndDelivery"] = "TakeawayAndDelivery";
-    WebshopType["Performance"] = "Performance";
-    WebshopType["Event"] = "Event";
-    WebshopType["Registrations"] = "Registrations";
-})(WebshopType || (WebshopType = {}));
-export var WebshopTicketType;
-(function (WebshopTicketType) {
-    WebshopTicketType["None"] = "None";
-    /**
-     * Create a single ticket for every order. Used to scan the order on takeout
-     */
-    WebshopTicketType["SingleTicket"] = "SingleTicket";
-    /**
-     * Create a single ticket for every product in an order
-     * + this disables the use of checkout methods
-     * + this enables the use of locations and times on products
-     */
-    WebshopTicketType["Tickets"] = "Tickets";
-})(WebshopTicketType || (WebshopTicketType = {}));
-export var WebshopStatus;
-(function (WebshopStatus) {
-    WebshopStatus["Open"] = "Open";
-    WebshopStatus["Closed"] = "Closed";
-    WebshopStatus["Archived"] = "Archived";
-})(WebshopStatus || (WebshopStatus = {}));
-export var WebshopNumberingType;
-(function (WebshopNumberingType) {
-    WebshopNumberingType["Continuous"] = "Continuous";
-    WebshopNumberingType["Random"] = "Random";
-})(WebshopNumberingType || (WebshopNumberingType = {}));
-export var WebshopAuthType;
-(function (WebshopAuthType) {
-    WebshopAuthType["Disabled"] = "Disabled";
-    WebshopAuthType["Required"] = "Required";
-})(WebshopAuthType || (WebshopAuthType = {}));
-export class WebshopMetaData extends AutoEncoder {
-    constructor() {
-        super(...arguments);
-        this.name = '';
-        this.title = '';
-        this.description = RichText.create({});
-        /**
-         * Serves as a hint in the UI for better suggestions and UX.
-         */
-        /* @field({
-            decoder: new EnumDecoder(WebshopType),
-            optional: true,
-            version: 247,
-            upgrade: function (this: WebshopMetaData) {
-                if (this.ticketType === WebshopTicketType.Tickets && this.seatingPlans.length > 0) {
-                    return WebshopType.Performance;
-                }
-    
-                if (this.ticketType === WebshopTicketType.Tickets) {
-                    return WebshopType.Event;
-                }
-                return WebshopType.Webshop;
-            },
-        })
-        @field({
-            decoder: new EnumDecoder(WebshopType),
-            <--todo version!!-->
-            upgrade: function (this: WebshopMetaData) {
-                if (this.type) {
-                    return this.type;
-                }
-                if (this.ticketType === WebshopTicketType.Tickets && this.seatingPlans.length > 0) {
-                    return WebshopType.Performance;
-                }
-    
-                if (this.ticketType === WebshopTicketType.Tickets) {
-                    return WebshopType.Event;
-                }
-                return WebshopType.Webshop;
-            },
-        })
-        type: WebshopType; */ // do not set a default here, the upgrade will break otherwise. Set one in the create method
-        /*
-        static override create<T extends typeof AutoEncoder>(this: T, object: PartialWithoutMethods<WebshopMetaData>): WebshopMetaData {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            const o = super.create({
-                type: WebshopType.Webshop,
-                ...object,
-            } as any) as WebshopMetaData;
-    
-            return o;
-        }
-        */
-        this.ticketType = WebshopTicketType.None;
-        this.coverPhoto = null;
-        this.allowComments = false;
-        this.phoneEnabled = true;
-        this.allowDiscountCodeEntry = false;
-        this.recordCategories = [];
-        /**
-         * @deprecated
-         */
-        this.customFields = [];
-        this.checkoutMethods = [];
-        this.seatingPlans = [];
-        this.reduceBranding = false;
-        this.defaultDiscounts = [];
-        /**
-         * @deprecated
-         * Use paymentConfiguration.paymentMethods instead
-         */
-        this.oldPaymentMethods = [PaymentMethod.Transfer];
-        /**
-         * @deprecated
-         * Use paymentConfiguration.transferSettings instead
-         */
-        this.oldTransferSettings = TransferSettings.create({});
-        this.paymentConfiguration = PaymentConfiguration.create({});
-        this.policies = [];
-        this.sponsors = null;
-        this.availableUntil = null;
-        this.openAt = null;
-        /**
-         * Manually close a webshop
-         */
-        this.status = WebshopStatus.Open;
-        this.layout = WebshopLayout.Default;
-        this.darkMode = DarkMode.Off;
-        this.color = null;
-        this.horizontalLogo = null;
-        this.squareLogo = null;
-        this.horizontalLogoDark = null;
-        this.squareLogoDark = null;
-        this.useLogo = false;
-        this.expandLogo = false;
-        this.cartEnabled = true;
-        /**
-         * Whether the domain name has been validated and is active. Only used to know if this domain should get used emails and in the dashboard.
-         * This is to prevent invalid url's from being used in emails.
-         * Lookups for a given domain still work if not active
-         */
-        this.domainActive = false;
-        this.authType = WebshopAuthType.Disabled;
-        this.customCode = null;
-    }
-    /**
-     * @deprecated
-     * Use paymentConfiguration.paymentMethods instead
-     */
-    get paymentMethods() {
-        return this.paymentConfiguration.paymentMethods;
-    }
-    /**
-     * @deprecated
-     * Use paymentConfiguration.paymentMethods instead
-     */
-    get transferSettings() {
-        return this.paymentConfiguration.transferSettings;
-    }
-    get hasTickets() {
-        return this.ticketType === WebshopTicketType.SingleTicket || this.ticketType === WebshopTicketType.Tickets;
-    }
-    get hasSingleTickets() {
-        return this.ticketType === WebshopTicketType.SingleTicket;
-    }
-    getEmailReplacements() {
-        // Do not return a replacement in case we don't have a color (= default to organization color)
-        if (!this.color) {
-            return [];
-        }
-        return [
-            Replacement.create({
-                token: 'primaryColor',
-                value: this.color,
-            }),
-            Replacement.create({
-                token: 'primaryColorContrast',
-                value: this.color ? Colors.getContrastColor(this.color) : '#fff',
-            }),
-        ];
-    }
-}
-__decorate([
-    field({ decoder: StringDecoder })
-], WebshopMetaData.prototype, "name", void 0);
-__decorate([
-    field({ decoder: StringDecoder })
-], WebshopMetaData.prototype, "title", void 0);
-__decorate([
-    field({ decoder: StringDecoder }),
-    field({ decoder: RichText, version: 181, upgrade: data => RichText.create({ text: data }), downgrade: data => data.text, upgradePatch: data => RichText.patch({ text: data }), downgradePatch: data => data.text })
-], WebshopMetaData.prototype, "description", void 0);
-__decorate([
-    field({ decoder: new EnumDecoder(WebshopTicketType), version: 105 })
-], WebshopMetaData.prototype, "ticketType", void 0);
-__decorate([
-    field({ decoder: Image, nullable: true })
-], WebshopMetaData.prototype, "coverPhoto", void 0);
-__decorate([
-    field({ decoder: BooleanDecoder, version: 94 })
-], WebshopMetaData.prototype, "allowComments", void 0);
-__decorate([
-    field({ decoder: BooleanDecoder, optional: true })
-], WebshopMetaData.prototype, "phoneEnabled", void 0);
-__decorate([
-    field({ decoder: BooleanDecoder, version: 242 })
-], WebshopMetaData.prototype, "allowDiscountCodeEntry", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(RecordCategory), optional: true })
-], WebshopMetaData.prototype, "recordCategories", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(WebshopField), version: 94 })
-], WebshopMetaData.prototype, "customFields", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(AnyCheckoutMethodDecoder) })
-], WebshopMetaData.prototype, "checkoutMethods", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(SeatingPlan), version: 211 })
-], WebshopMetaData.prototype, "seatingPlans", void 0);
-__decorate([
-    field({ decoder: BooleanDecoder, version: 233, optional: true })
-], WebshopMetaData.prototype, "reduceBranding", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(Discount), version: 235 })
-], WebshopMetaData.prototype, "defaultDiscounts", void 0);
-__decorate([
-    field({
-        decoder: new ArrayDecoder(new EnumDecoder(PaymentMethod)),
-        version: 151,
-        field: 'paymentMethods',
-        optional: true, // We no longer expect this from the backend, so it can get removed in a future version
-    }),
-    field({
-        decoder: new ArrayDecoder(new EnumDecoder(PaymentMethod)),
-        version: 208,
-        field: 'oldPaymentMethods',
-        optional: true, // We no longer expect this from the backend, so it can get removed in a future version
-        downgrade: function () {
-            // This return value for old clients
-            return this.paymentMethods;
-        },
-    })
-], WebshopMetaData.prototype, "oldPaymentMethods", void 0);
-__decorate([
-    field({
-        decoder: TransferSettings,
-        version: 49,
-        field: 'transferSettings',
-        optional: true, // We no longer expect this from the backend, so it can get removed in a future version
-    }),
-    field({
-        decoder: TransferSettings,
-        version: 208,
-        field: 'oldTransferSettings',
-        optional: true, // We no longer expect this from the backend, so it can get removed in a future version
-        downgrade: function () {
-            // This return value for old clients
-            return this.transferSettings;
-        },
-    })
-], WebshopMetaData.prototype, "oldTransferSettings", void 0);
-__decorate([
-    field({
-        decoder: PaymentConfiguration,
-        version: 205,
-        upgrade: function () {
-            return PaymentConfiguration.create({
-                transferSettings: this.oldTransferSettings,
-                paymentMethods: this.oldPaymentMethods,
-            });
-        },
-    })
-], WebshopMetaData.prototype, "paymentConfiguration", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(Policy), version: 116 })
-], WebshopMetaData.prototype, "policies", void 0);
-__decorate([
-    field({ decoder: SponsorConfig, version: 226, nullable: true })
-], WebshopMetaData.prototype, "sponsors", void 0);
-__decorate([
-    field({ decoder: DateDecoder, nullable: true, version: 43 })
-], WebshopMetaData.prototype, "availableUntil", void 0);
-__decorate([
-    field({ decoder: DateDecoder, nullable: true, version: 170 })
-], WebshopMetaData.prototype, "openAt", void 0);
-__decorate([
-    field({ decoder: new EnumDecoder(WebshopStatus), version: 136 })
-], WebshopMetaData.prototype, "status", void 0);
-__decorate([
-    field({ decoder: new EnumDecoder(WebshopLayout), version: 180 })
-], WebshopMetaData.prototype, "layout", void 0);
-__decorate([
-    field({ decoder: new EnumDecoder(DarkMode), version: 182 })
-], WebshopMetaData.prototype, "darkMode", void 0);
-__decorate([
-    field({ decoder: StringDecoder, nullable: true, version: 183 })
-], WebshopMetaData.prototype, "color", void 0);
-__decorate([
-    field({ decoder: Image, nullable: true, version: 183 })
-], WebshopMetaData.prototype, "horizontalLogo", void 0);
-__decorate([
-    field({ decoder: Image, nullable: true, version: 183 })
-], WebshopMetaData.prototype, "squareLogo", void 0);
-__decorate([
-    field({ decoder: Image, nullable: true, version: 183 })
-], WebshopMetaData.prototype, "horizontalLogoDark", void 0);
-__decorate([
-    field({ decoder: Image, nullable: true, version: 183 })
-], WebshopMetaData.prototype, "squareLogoDark", void 0);
-__decorate([
-    field({ decoder: BooleanDecoder, version: 184 })
-], WebshopMetaData.prototype, "useLogo", void 0);
-__decorate([
-    field({ decoder: BooleanDecoder, optional: true, version: 183 })
-], WebshopMetaData.prototype, "expandLogo", void 0);
-__decorate([
-    field({ decoder: BooleanDecoder, version: 180 })
-], WebshopMetaData.prototype, "cartEnabled", void 0);
-__decorate([
-    field({ decoder: BooleanDecoder, version: 135 })
-], WebshopMetaData.prototype, "domainActive", void 0);
-__decorate([
-    field({ decoder: new EnumDecoder(WebshopAuthType), version: 188 })
-], WebshopMetaData.prototype, "authType", void 0);
-__decorate([
-    field({ decoder: StringDecoder, nullable: true, version: 374 })
-], WebshopMetaData.prototype, "customCode", void 0);
-export class WebshopPrivateMetaData extends AutoEncoder {
-    constructor() {
-        super(...arguments);
-        /**
-         * Automatically has full access
-         */
-        this.authorId = '';
-        /**
-         * @deprecated
-         * Use role resources instead
-         */
-        this.permissions = PermissionsByRole.create({});
-        /**
-         * @deprecated
-         * Use role resources instead
-         */
-        this.scanPermissions = PermissionsByRole.create({});
-        this.startNumber = 1;
-        /**
-         * DNS records that need to be set in order to activate mail domain and registration domain
-         */
-        this.dnsRecords = [];
-        this.defaultEmailId = null;
-        this.notificationEmails = [];
-        this.numberingType = WebshopNumberingType.Continuous;
-        this.paymentConfiguration = PrivatePaymentConfiguration.create({});
-    }
-    static buildDNSRecords(domain) {
-        if (!STAMHOOFD.domains.webshopCname) {
-            throw new SimpleError({
-                code: 'invalid_configuration',
-                message: 'Missing configuration for webshop domain',
-                human: $t(`323d9fd1-cd53-41d9-85e6-8d95c60e6240`),
-                statusCode: 500,
-            });
-        }
-        return [
-            DNSRecord.create({
-                type: DNSRecordType.CNAME,
-                name: domain + '.',
-                value: STAMHOOFD.domains.webshopCname + '.',
-            }),
-        ];
-    }
-}
-__decorate([
-    field({ decoder: StringDecoder, version: 59 })
-], WebshopPrivateMetaData.prototype, "authorId", void 0);
-__decorate([
-    field({ decoder: PermissionsByRole, version: 60, optional: true })
-], WebshopPrivateMetaData.prototype, "permissions", void 0);
-__decorate([
-    field({ decoder: PermissionsByRole, version: 202, optional: true })
-], WebshopPrivateMetaData.prototype, "scanPermissions", void 0);
-__decorate([
-    field({ decoder: IntegerDecoder, optional: true }) // Made optional because of multi-branch addition
-], WebshopPrivateMetaData.prototype, "startNumber", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(DNSRecord), version: 135 })
-], WebshopPrivateMetaData.prototype, "dnsRecords", void 0);
-__decorate([
-    field({ decoder: StringDecoder, nullable: true, version: 145 })
-], WebshopPrivateMetaData.prototype, "defaultEmailId", void 0);
-__decorate([
-    field({ decoder: new ArrayDecoder(StringDecoder), version: 163 })
-], WebshopPrivateMetaData.prototype, "notificationEmails", void 0);
-__decorate([
-    field({ decoder: new EnumDecoder(WebshopNumberingType), optional: true })
-], WebshopPrivateMetaData.prototype, "numberingType", void 0);
-__decorate([
-    field({ decoder: PrivatePaymentConfiguration, version: 175, field: 'providerConfiguration' }),
-    field({ decoder: PrivatePaymentConfiguration, version: 205 })
-], WebshopPrivateMetaData.prototype, "paymentConfiguration", void 0);
-export class WebshopServerMetaData extends AutoEncoder {
-    constructor() {
-        super(...arguments);
-        this.placeholder = '';
-    }
-}
-__decorate([
-    field({ decoder: StringDecoder })
-], WebshopServerMetaData.prototype, "placeholder", void 0);
-//# sourceMappingURL=WebshopMetaData.js.map