@stamhoofd/structures 1.12.7 → 2.1.1

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

@@ -0,0 +1,661 @@
+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';
+import { City } from '../addresses/City';
+import { CountryDecoder } from '../addresses/CountryDecoder';
+import { Province } from '../addresses/Province';
+import { DNSRecord, DNSRecordType } from '../DNSRecord';
+import { Replacement } from '../endpoints/EmailRequest';
+import { Image } from '../files/Image';
+import { RecordCategory } from '../members/records/RecordCategory';
+import { PaymentConfiguration, PrivatePaymentConfiguration } from '../PaymentConfiguration';
+import { PaymentMethod } from '../PaymentMethod';
+import { PermissionsByRole } from '../Permissions';
+import { Policy } from '../Policy';
+import { RichText } from '../RichText';
+import { SeatingPlan } from '../SeatingPlan';
+import { SponsorConfig } from '../SponsorConfig';
+import { Discount } from './Discount';
+import { TransferSettings } from './TransferSettings';
+import { WebshopField } from './WebshopField';
+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;
+    }
+    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 "Ter plaatse consumeren";
+            case CheckoutMethodType.Takeout:
+                return "Afhalen";
+            case CheckoutMethodType.Delivery:
+                return "Leveren";
+        }
+    }
+}
+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 })
+], CheckoutMethodPrice.prototype, "price", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder, nullable: true })
+], CheckoutMethodPrice.prototype, "minimumPrice", void 0);
+__decorate([
+    field({ decoder: IntegerDecoder })
+], 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 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({});
+        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;
+    }
+    /**
+     * @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);
+export class WebshopPrivateMetaData extends AutoEncoder {
+    constructor() {
+        super(...arguments);
+        /**
+         * Automatically has full access
+         */
+        this.authorId = "";
+        this.permissions = PermissionsByRole.create({});
+        this.scanPermissions = PermissionsByRole.create({});
+        /**
+         * 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) {
+        return [
+            DNSRecord.create({
+                type: DNSRecordType.CNAME,
+                name: domain + ".",
+                value: "domains.stamhoofd.shop."
+            })
+        ];
+    }
+}
+__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: 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