@stamhoofd/structures 2.119.0 → 2.120.1

package/dist/webshops/WebshopMetaData.js

@@ -0,0 +1,733 @@
+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 { upgradePriceFrom2To4DecimalPlaces } from '../upgradePriceFrom2To4DecimalPlaces.js';
+import { Discount } from './Discount.js';
+import { TransferSettings } from './TransferSettings.js';
+import { WebshopField } from './WebshopField.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 {
+    id;
+    /**
+     * Day. The time is ignored, and timezone should be same timezone as the webshop/organization
+     */
+    date;
+    /**
+     * Saved in minutes since midnight
+     */
+    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)
+     */
+    endTime = 14 * 60;
+    maxOrders = null;
+    usedOrders = 0;
+    maxPersons = null;
+    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 {
+    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(`%VY`);
+            case CheckoutMethodType.Takeout:
+                return $t(`%xG`);
+            case CheckoutMethodType.Delivery:
+                return $t(`%tI`);
+        }
+    }
+}
+export class CheckoutMethod extends AutoEncoder {
+    id;
+    name = '';
+    description = '';
+    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: 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 {
+    type;
+    address;
+}
+__decorate([
+    field({ decoder: new EnumDecoder(CheckoutMethodType), patchDefaultValue: () => CheckoutMethodType.Takeout, defaultValue: () => 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 {
+    // Indicate this field exists for all versions, but the downgrade should get executed
+    type;
+    // TODO: transform into an address with coordinates (used by e-tickets)
+    address;
+}
+__decorate([
+    field({ decoder: new EnumDecoder(CheckoutMethodType), defaultValue: () => CheckoutMethodType.Takeout }),
+    field({
+        decoder: new EnumDecoder(CheckoutMethodType),
+        version: 105,
+        downgrade: () => {
+            // Return takeout method for old clients
+            return CheckoutMethodType.Takeout;
+        },
+        patchDefaultValue: () => CheckoutMethodType.OnSite,
+        defaultValue: () => 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 {
+    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
+     */
+    minimumPrice = null;
+    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 {
+    type;
+    price = CheckoutMethodPrice.create({});
+    cities = [];
+    provinces = [];
+    countries = [];
+}
+__decorate([
+    field({ decoder: new EnumDecoder(CheckoutMethodType), patchDefaultValue: () => CheckoutMethodType.Delivery, defaultValue: () => 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 type = data.field('type').enum(CheckoutMethodType);
+        if (type === CheckoutMethodType.Takeout) {
+            return WebshopTakeoutMethod.patchType().decode(data);
+        }
+        if (type === CheckoutMethodType.Delivery) {
+            return WebshopDeliveryMethod.patchType().decode(data);
+        }
+        if (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 type = data.field('type').enum(CheckoutMethodType);
+        if (type === CheckoutMethodType.Takeout) {
+            return WebshopTakeoutMethod.decode(data);
+        }
+        if (type === CheckoutMethodType.Delivery) {
+            return WebshopDeliveryMethod.decode(data);
+        }
+        if (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 function getWebshopTypeName(type) {
+    switch (type) {
+        case WebshopType.Performance: return $t('%1Nl');
+        case WebshopType.Event: return $t('%1PG');
+        case WebshopType.Registrations: return $t('%1EI');
+        case WebshopType.TakeawayAndDelivery: return $t('%1OT');
+        case WebshopType.Donations: return $t('%1O4');
+        case WebshopType.Webshop: return $t('%1OV');
+    }
+}
+export function getWebshopStatusName(status) {
+    switch (status) {
+        case WebshopStatus.Open: return $t('%1Nw');
+        case WebshopStatus.Closed: return $t('%1PH');
+        case WebshopStatus.Archived: return $t('%1Pg');
+    }
+}
+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 {
+    name = '';
+    title = '';
+    description = RichText.create({});
+    /**
+     * Serves as a hint in the UI for better suggestions and UX.
+     */
+    type = WebshopType.Webshop;
+    ticketType = WebshopTicketType.None;
+    coverPhoto = null;
+    allowComments = false;
+    phoneEnabled = true;
+    allowDiscountCodeEntry = false;
+    recordCategories = [];
+    /**
+     * @deprecated
+     */
+    customFields = [];
+    checkoutMethods = [];
+    seatingPlans = [];
+    reduceBranding = false;
+    defaultDiscounts = [];
+    /**
+     * @deprecated
+     * Use paymentConfiguration.paymentMethods instead
+     */
+    oldPaymentMethods = [PaymentMethod.Transfer];
+    /**
+     * @deprecated
+     * Use paymentConfiguration.transferSettings instead
+     */
+    oldTransferSettings = TransferSettings.create({});
+    paymentConfiguration = PaymentConfiguration.create({});
+    /**
+     * @deprecated
+     * Use paymentConfiguration.paymentMethods instead
+     */
+    get paymentMethods() {
+        return this.paymentConfiguration.paymentMethods;
+    }
+    /**
+     * @deprecated
+     * Use paymentConfiguration.paymentMethods instead
+     */
+    get transferSettings() {
+        return this.paymentConfiguration.transferSettings;
+    }
+    policies = [];
+    sponsors = null;
+    availableUntil = null;
+    openAt = null;
+    /**
+     * Manually close a webshop
+     */
+    status = WebshopStatus.Open;
+    layout = WebshopLayout.Default;
+    darkMode = DarkMode.Off;
+    color = null;
+    horizontalLogo = null;
+    squareLogo = null;
+    horizontalLogoDark = null;
+    squareLogoDark = null;
+    useLogo = false;
+    expandLogo = false;
+    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
+     */
+    domainActive = false;
+    authType = WebshopAuthType.Disabled;
+    customCode = null;
+    /**
+     * Returns whether the webshop is event/ticketing based - regardless whether scanners are used or not
+     */
+    get isTicketBased() {
+        return this.type === WebshopType.Event || this.type === WebshopType.Performance || this.ticketType === WebshopTicketType.Tickets;
+    }
+    get isRegistrations() {
+        return this.type === WebshopType.Registrations;
+    }
+    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(WebshopType),
+        version: 395,
+        upgrade: function () {
+            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;
+        },
+    })
+], WebshopMetaData.prototype, "type", 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 {
+    /**
+     * Automatically has full access
+     */
+    authorId = '';
+    /**
+     * @deprecated
+     * Use role resources instead
+     */
+    permissions = PermissionsByRole.create({});
+    /**
+     * @deprecated
+     * Use role resources instead
+     */
+    scanPermissions = PermissionsByRole.create({});
+    startNumber = 1;
+    /**
+     * DNS records that need to be set in order to activate mail domain and registration domain
+     */
+    dnsRecords = [];
+    defaultEmailId = null;
+    notificationEmails = [];
+    numberingType = WebshopNumberingType.Continuous;
+    static buildDNSRecords(domain) {
+        if (!STAMHOOFD.domains.webshopCname) {
+            throw new SimpleError({
+                code: 'invalid_configuration',
+                message: 'Missing configuration for webshop domain',
+                human: $t(`%tJ`),
+                statusCode: 500,
+            });
+        }
+        return [
+            DNSRecord.create({
+                type: DNSRecordType.CNAME,
+                name: domain + '.',
+                value: STAMHOOFD.domains.webshopCname + '.',
+            }),
+        ];
+    }
+    paymentConfiguration = PrivatePaymentConfiguration.create({});
+}
+__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 {
+    placeholder = '';
+}
+__decorate([
+    field({ decoder: StringDecoder })
+], WebshopServerMetaData.prototype, "placeholder", void 0);
+//# sourceMappingURL=WebshopMetaData.js.map