@passly-nl/data 1.0.2 → 1.0.4

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@passly-nl/data",
     "description": "API implementation for Passly.",
-    "version": "1.0.2",
+    "version": "1.0.4",
     "type": "module",
     "license": "MIT",
     "funding": "https://github.com/sponsors/basmilius",
@@ -50,16 +50,16 @@
         "./*": "./*"
     },
     "dependencies": {
-        "@basmilius/http-client": "^3.11.1",
-        "@flux-ui/types": "^3.0.0-next.32",
+        "@basmilius/http-client": "^3.14.0",
+        "@flux-ui/types": "^3.0.0-next.35",
         "@fortawesome/fontawesome-common-types": "^7.2.0",
-        "apexcharts": "^5.10.3",
+        "apexcharts": "^5.10.4",
         "luxon": "^3.7.2"
     },
     "devDependencies": {
         "@types/luxon": "^3.7.1",
-        "@typescript/native-preview": "^7.0.0-dev.20260309.1",
-        "tsdown": "^0.21.1"
+        "@typescript/native-preview": "^7.0.0-dev.20260320.1",
+        "tsdown": "^0.21.4"
     },
     "overrides": {
         "@disabled-basmilius/http-client": "link:@basmilius/http-client",

package/src/adapter/EmailTemplateAdapter.ts

@@ -0,0 +1,25 @@
+import { adapter, ForeignData } from '@basmilius/http-client';
+import { DateTimeAdapter } from '#data/adapter';
+import { EmailTemplateDto, RenderedMailDto } from '#data/dto';
+
+@adapter
+export class EmailTemplateAdapter {
+    static parseEmailTemplate(data: ForeignData): EmailTemplateDto {
+        return new EmailTemplateDto(
+            data.id,
+            data.type,
+            data.language ?? null,
+            data.subject,
+            data.content,
+            DateTimeAdapter.parseDateTime(data.created_on),
+            DateTimeAdapter.parseDateTime(data.updated_on)
+        );
+    }
+
+    static parseRenderedMail(data: ForeignData): RenderedMailDto {
+        return new RenderedMailDto(
+            data.subject,
+            data.content
+        );
+    }
+}

package/src/adapter/index.ts

@@ -1,5 +1,6 @@
 export * from './AddressAdapter';
 export * from './AuthAdapter';
+export * from './EmailTemplateAdapter';
 export * from './BuyerAdapter';
 export * from './CommonAdapter';
 export * from './DateTimeAdapter';

package/src/dto/emailTemplate/EmailTemplateDto.ts

@@ -0,0 +1,80 @@
+import { dto } from '@basmilius/http-client';
+import type { DateTime } from 'luxon';
+import type { EmailTemplateLanguage, EmailTemplateType } from '#data/types';
+
+@dto
+export class EmailTemplateDto {
+    get id(): string {
+        return this.#id;
+    }
+
+    set id(value: string) {
+        this.#id = value;
+    }
+
+    get type(): EmailTemplateType {
+        return this.#type;
+    }
+
+    set type(value: EmailTemplateType) {
+        this.#type = value;
+    }
+
+    get language(): EmailTemplateLanguage | null {
+        return this.#language;
+    }
+
+    set language(value: EmailTemplateLanguage | null) {
+        this.#language = value;
+    }
+
+    get subject(): string {
+        return this.#subject;
+    }
+
+    set subject(value: string) {
+        this.#subject = value;
+    }
+
+    get content(): string {
+        return this.#content;
+    }
+
+    set content(value: string) {
+        this.#content = value;
+    }
+
+    get createdOn(): DateTime {
+        return this.#createdOn;
+    }
+
+    set createdOn(value: DateTime) {
+        this.#createdOn = value;
+    }
+
+    get updatedOn(): DateTime {
+        return this.#updatedOn;
+    }
+
+    set updatedOn(value: DateTime) {
+        this.#updatedOn = value;
+    }
+
+    #id: string;
+    #type: EmailTemplateType;
+    #language: EmailTemplateLanguage | null;
+    #subject: string;
+    #content: string;
+    #createdOn: DateTime;
+    #updatedOn: DateTime;
+
+    constructor(id: string, type: EmailTemplateType, language: EmailTemplateLanguage | null, subject: string, content: string, createdOn: DateTime, updatedOn: DateTime) {
+        this.#id = id;
+        this.#type = type;
+        this.#language = language;
+        this.#subject = subject;
+        this.#content = content;
+        this.#createdOn = createdOn;
+        this.#updatedOn = updatedOn;
+    }
+}

package/src/dto/emailTemplate/RenderedMailDto.ts

@@ -0,0 +1,28 @@
+import { dto } from '@basmilius/http-client';
+
+@dto
+export class RenderedMailDto {
+    get subject(): string {
+        return this.#subject;
+    }
+
+    set subject(value: string) {
+        this.#subject = value;
+    }
+
+    get content(): string {
+        return this.#content;
+    }
+
+    set content(value: string) {
+        this.#content = value;
+    }
+
+    #subject: string;
+    #content: string;
+
+    constructor(subject: string, content: string) {
+        this.#subject = subject;
+        this.#content = content;
+    }
+}

package/src/dto/emailTemplate/index.ts

@@ -0,0 +1,2 @@
+export * from './EmailTemplateDto';
+export * from './RenderedMailDto';

package/src/dto/index.ts

@@ -1,6 +1,7 @@
 export * from './address';
 export * from './auth';
 export * from './common';
+export * from './emailTemplate';
 export * from './event';
 export * from './fileSystem';
 export * from './finance';

package/src/service/EmailTemplateEditorService.ts

@@ -0,0 +1,286 @@
+import type { EmailTemplateEditorBlock, EmailTemplateEditorButtonBlock, EmailTemplateEditorCondition, EmailTemplateEditorContext, EmailTemplateEditorH1Block, EmailTemplateEditorHeaderBlock, EmailTemplateEditorIfBlock, EmailTemplateEditorParagraphBlock, EmailTemplateEditorVariable, EmailTemplateType } from '#data/types';
+
+const SHARED_VARIABLES: EmailTemplateEditorVariable[] = [
+    {label: 'variable.merchantName', path: 'merchant.name'},
+    {label: 'variable.weekDay', path: 'weekDay'}
+];
+
+const BUYER_VARIABLES: EmailTemplateEditorVariable[] = [
+    {label: 'variable.buyerFirstName', path: 'buyer.firstName'},
+    {label: 'variable.buyerLastName', path: 'buyer.lastName'},
+    {label: 'variable.buyerFullName', path: 'buyer.fullName'},
+    {label: 'variable.buyerInitials', path: 'buyer.initials'},
+    {label: 'variable.buyerEmail', path: 'buyer.email'},
+    {label: 'variable.buyerPhoneNumber', path: 'buyer.phoneNumber'},
+    {label: 'variable.buyerDateOfBirth', path: 'buyer.dateOfBirth'},
+    {label: 'variable.buyerGender', path: 'buyer.gender'},
+    {label: 'variable.buyerLanguage', path: 'buyer.language'},
+    {label: 'variable.buyerAddressStreet', path: 'buyer.address.street'},
+    {label: 'variable.buyerAddressNumber', path: 'buyer.address.number'},
+    {label: 'variable.buyerAddressPostalCode', path: 'buyer.address.postalCode'},
+    {label: 'variable.buyerAddressCity', path: 'buyer.address.city'},
+    {label: 'variable.buyerAddressCountry', path: 'buyer.address.country'}
+];
+
+const EVENT_VARIABLES: EmailTemplateEditorVariable[] = [
+    {label: 'variable.eventName', path: 'event.name'},
+    {label: 'variable.eventStartDate', path: 'event.startDate'},
+    {label: 'variable.eventStartTime', path: 'event.startTime'}
+];
+
+const ORDER_VARIABLES: EmailTemplateEditorVariable[] = [
+    {label: 'variable.orderCode', path: 'order.code'}
+];
+
+const HEADER_CONDITION: EmailTemplateEditorCondition = {label: 'condition.eventHasHeaderImage', condition: 'event.headerFile'};
+
+export const EMAIL_TEMPLATE_EDITOR_CONTEXTS: Record<EmailTemplateType, EmailTemplateEditorContext> = {
+    merchant_invite: {
+        variables: [
+            ...SHARED_VARIABLES,
+            {label: 'variable.userFirstName', path: 'user.firstName'},
+            {label: 'variable.userLastName', path: 'user.lastName'},
+            {label: 'variable.acceptUrl', path: 'acceptUrl'}
+        ],
+        conditions: []
+    },
+    order_canceled: {
+        variables: [...SHARED_VARIABLES, ...BUYER_VARIABLES, ...EVENT_VARIABLES, ...ORDER_VARIABLES],
+        conditions: [HEADER_CONDITION]
+    },
+    order_confirmation: {
+        variables: [...SHARED_VARIABLES, ...BUYER_VARIABLES, ...EVENT_VARIABLES, ...ORDER_VARIABLES],
+        conditions: [
+            {label: 'condition.hasNormalTicketsOnly', condition: 'hasNormalTicketsOnly'},
+            {label: 'condition.hasPersonalizableTickets', condition: 'hasPersonalizableTickets'},
+            {label: 'condition.hasSealedTickets', condition: 'hasSealedTickets'},
+            HEADER_CONDITION
+        ]
+    },
+    order_expired: {
+        variables: [...SHARED_VARIABLES, ...BUYER_VARIABLES, ...EVENT_VARIABLES, ...ORDER_VARIABLES],
+        conditions: [HEADER_CONDITION]
+    },
+    order_failed: {
+        variables: [...SHARED_VARIABLES, ...BUYER_VARIABLES, ...EVENT_VARIABLES, ...ORDER_VARIABLES],
+        conditions: [HEADER_CONDITION]
+    },
+    personalization_invite: {
+        variables: [...SHARED_VARIABLES, ...BUYER_VARIABLES, ...EVENT_VARIABLES, {label: 'variable.personalizeUrl', path: 'personalizeUrl'}],
+        conditions: [HEADER_CONDITION]
+    },
+    personalization_request: {
+        variables: [...SHARED_VARIABLES, ...BUYER_VARIABLES, ...EVENT_VARIABLES, ...ORDER_VARIABLES, {label: 'variable.personalizeUrl', path: 'personalizeUrl'}],
+        conditions: [HEADER_CONDITION]
+    },
+    tickets: {
+        variables: [...SHARED_VARIABLES, ...BUYER_VARIABLES, ...EVENT_VARIABLES, ...ORDER_VARIABLES],
+        conditions: [HEADER_CONDITION]
+    }
+};
+
+interface ScanResult {
+    blocks: EmailTemplateEditorBlock[];
+    consumed: number;
+}
+
+/**
+ * Parses quoted or unquoted arguments from a Handlebars helper argument string.
+ * Returns an array of string values.
+ */
+function parseArgs(args: string): string[] {
+    const result: string[] = [];
+    let remaining = args.trim();
+
+    while (remaining.length > 0) {
+        if (remaining[0] === '"') {
+            const end = remaining.indexOf('"', 1);
+            if (end === -1) break;
+            result.push(remaining.slice(1, end));
+            remaining = remaining.slice(end + 1).trim();
+        } else {
+            const spaceIdx = remaining.search(/\s/);
+            if (spaceIdx === -1) {
+                result.push(remaining);
+                break;
+            }
+            result.push(remaining.slice(0, spaceIdx));
+            remaining = remaining.slice(spaceIdx + 1).trim();
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Builds a single EmailTemplateEditorBlock from a parsed Handlebars block.
+ */
+function buildBlock(
+    type: string,
+    args: string,
+    children: EmailTemplateEditorBlock[],
+    rawContent: string
+): EmailTemplateEditorBlock | null {
+    const content = rawContent.trim().split('\n').map(line => line.replace(/^ {4}/, '')).join('\n');
+
+    switch (type) {
+        case 'h1':
+            return {type: 'h1', content} satisfies EmailTemplateEditorH1Block;
+
+        case 'paragraph':
+            return {type: 'paragraph', content} satisfies EmailTemplateEditorParagraphBlock;
+
+        case 'divider':
+            return {type: 'divider'};
+
+        case 'spacer':
+            return {type: 'spacer'};
+
+        case 'logo':
+            return {type: 'logo'};
+
+        case 'button': {
+            const [label = '', url = ''] = parseArgs(args);
+            return {type: 'button', label, url} satisfies EmailTemplateEditorButtonBlock;
+        }
+
+        case 'header': {
+            const [src = ''] = parseArgs(args);
+            return {type: 'header', src} satisfies EmailTemplateEditorHeaderBlock;
+        }
+
+        case 'if':
+            return {type: 'if', condition: args, children} satisfies EmailTemplateEditorIfBlock;
+
+        default:
+            return null;
+    }
+}
+
+/**
+ * Recursively scans the template string starting from startPos, building blocks
+ * until a closing tag is found or the end of the string is reached.
+ */
+function scan(template: string, startPos: number = 0): ScanResult {
+    const blocks: EmailTemplateEditorBlock[] = [];
+    let pos = startPos;
+
+    while (pos < template.length) {
+        const tokenStart = template.indexOf('{{', pos);
+        if (tokenStart === -1) break;
+
+        const ch = template[tokenStart + 2];
+
+        // Partial {{> ...}} — skip
+        if (ch === '>') {
+            const end = template.indexOf('}}', tokenStart);
+            if (end === -1) break;
+            pos = end + 2;
+            continue;
+        }
+
+        // Comment {{!-- ... --}} or {{! ...}} — skip
+        if (ch === '!') {
+            const end = template.indexOf('}}', tokenStart);
+            if (end === -1) break;
+            pos = end + 2;
+            continue;
+        }
+
+        // Closing tag {{/type}} — return to parent scanner
+        if (ch === '/') {
+            return {blocks, consumed: tokenStart};
+        }
+
+        // Opening block tag {{#type args}}
+        if (ch === '#') {
+            const closeTag = template.indexOf('}}', tokenStart);
+            if (closeTag === -1) break;
+
+            const tagContent = template.slice(tokenStart + 3, closeTag).trim();
+            const spaceIdx = tagContent.search(/\s/);
+            const type = spaceIdx === -1 ? tagContent : tagContent.slice(0, spaceIdx);
+            const args = spaceIdx === -1 ? '' : tagContent.slice(spaceIdx + 1).trim();
+
+            const innerStart = closeTag + 2;
+            const {blocks: children, consumed: innerEnd} = scan(template, innerStart);
+            const rawContent = template.slice(innerStart, innerEnd);
+
+            // Advance past the closing {{/type}} tag
+            const expectedClose = `{{/${type}}}`;
+            pos = innerEnd + expectedClose.length;
+
+            const block = buildBlock(type, args, children, rawContent);
+            if (block !== null) {
+                blocks.push(block);
+            }
+            continue;
+        }
+
+        // Variable or other expression — skip
+        const end = template.indexOf('}}', tokenStart);
+        if (end === -1) break;
+        pos = end + 2;
+    }
+
+    return {blocks, consumed: pos};
+}
+
+/**
+ * Serializes a single block back to its Handlebars string representation.
+ */
+function serializeBlock(block: EmailTemplateEditorBlock): string {
+    switch (block.type) {
+        case 'h1': {
+            const indented = block.content.split('\n').map(line => `    ${line}`).join('\n');
+            return `{{#h1}}\n${indented}\n{{/h1}}`;
+        }
+
+        case 'paragraph': {
+            const indented = block.content.split('\n').map(line => `    ${line}`).join('\n');
+            return `{{#paragraph}}\n${indented}\n{{/paragraph}}`;
+        }
+
+        case 'divider':
+            return `{{#divider}}{{/divider}}`;
+
+        case 'spacer':
+            return `{{#spacer}}{{/spacer}}`;
+
+        case 'logo':
+            return `{{#logo}}{{/logo}}`;
+
+        case 'button':
+            return `{{#button "${block.label}" "${block.url}"}}{{/button}}`;
+
+        case 'header': {
+            const srcArg = block.src.includes('://') ? `"${block.src}"` : block.src;
+            return `{{#header ${srcArg}}}{{/header}}`;
+        }
+
+        case 'if': {
+            const indented = serializeBlocks(block.children)
+                .split('\n')
+                .map(line => `    ${line}`)
+                .join('\n');
+            return `{{#if ${block.condition}}}\n${indented}\n{{/if}}`;
+        }
+    }
+}
+
+/**
+ * Parses a Handlebars template string into an array of editor blocks.
+ * Strips structure partials; only content blocks are returned.
+ */
+export function parseEmailTemplate(template: string): EmailTemplateEditorBlock[] {
+    const {blocks} = scan(template);
+    return blocks;
+}
+
+/**
+ * Serializes an array of editor blocks back into a Handlebars content string.
+ * Does not include structure partials — those are added by the backend automatically.
+ */
+export function serializeBlocks(blocks: EmailTemplateEditorBlock[]): string {
+    return blocks.map(serializeBlock).join('\n\n');
+}

package/src/service/MerchantEmailTemplateService.ts

@@ -0,0 +1,43 @@
+import { BaseResponse, BaseService } from '@basmilius/http-client';
+import { CommonAdapter, EmailTemplateAdapter } from '#data/adapter';
+import type { EmailTemplateDto, RenderedMailDto, StatusResponseDto } from '#data/dto';
+import type { EmailTemplateLanguage } from '#data/types';
+
+export class MerchantEmailTemplateService extends BaseService {
+    async getPreview(merchantId: string, emailTemplateId: string): Promise<BaseResponse<RenderedMailDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/email-templates/${emailTemplateId}/preview`)
+            .method('get')
+            .bearerToken()
+            .runAdapter(EmailTemplateAdapter.parseRenderedMail);
+    }
+
+    async get(merchantId: string, emailTemplateId: string): Promise<BaseResponse<EmailTemplateDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/email-templates/${emailTemplateId}`)
+            .method('get')
+            .bearerToken()
+            .runAdapter(EmailTemplateAdapter.parseEmailTemplate);
+    }
+
+    async patch(merchantId: string, emailTemplateId: string, subject: string, content: string, language: EmailTemplateLanguage | null = null): Promise<BaseResponse<EmailTemplateDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/email-templates/${emailTemplateId}`)
+            .method('patch')
+            .bearerToken()
+            .body({
+                subject,
+                content,
+                language
+            })
+            .runAdapter(EmailTemplateAdapter.parseEmailTemplate);
+    }
+
+    async delete(merchantId: string, emailTemplateId: string): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/email-templates/${emailTemplateId}`)
+            .method('delete')
+            .bearerToken()
+            .runAdapter(CommonAdapter.parseStatusResponse);
+    }
+}

package/src/service/MerchantEmailTemplatesService.ts

@@ -0,0 +1,31 @@
+import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { EmailTemplateAdapter } from '#data/adapter';
+import type { EmailTemplateDto } from '#data/dto';
+import type { EmailTemplateLanguage, EmailTemplateType } from '#data/types';
+
+export class MerchantEmailTemplatesService extends BaseService {
+    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<EmailTemplateDto>>> {
+        return await this
+            .request(`/merchants/${merchantId}/email-templates`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('offset', offset)
+                .append('limit', limit))
+            .runPaginatedAdapter(EmailTemplateAdapter.parseEmailTemplate);
+    }
+
+    async post(merchantId: string, type: EmailTemplateType, subject: string, content: string, language: EmailTemplateLanguage | null = null): Promise<BaseResponse<EmailTemplateDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/email-templates`)
+            .method('post')
+            .bearerToken()
+            .body({
+                type,
+                subject,
+                content,
+                language
+            })
+            .runAdapter(EmailTemplateAdapter.parseEmailTemplate);
+    }
+}

package/src/service/MerchantEventEmailTemplateService.ts

@@ -0,0 +1,43 @@
+import { BaseResponse, BaseService } from '@basmilius/http-client';
+import { CommonAdapter, EmailTemplateAdapter } from '#data/adapter';
+import type { EmailTemplateDto, RenderedMailDto, StatusResponseDto } from '#data/dto';
+import type { EmailTemplateLanguage } from '#data/types';
+
+export class MerchantEventEmailTemplateService extends BaseService {
+    async getPreview(merchantId: string, eventId: string, emailTemplateId: string): Promise<BaseResponse<RenderedMailDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/email-templates/${emailTemplateId}/preview`)
+            .method('get')
+            .bearerToken()
+            .runAdapter(EmailTemplateAdapter.parseRenderedMail);
+    }
+
+    async get(merchantId: string, eventId: string, emailTemplateId: string): Promise<BaseResponse<EmailTemplateDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/email-templates/${emailTemplateId}`)
+            .method('get')
+            .bearerToken()
+            .runAdapter(EmailTemplateAdapter.parseEmailTemplate);
+    }
+
+    async patch(merchantId: string, eventId: string, emailTemplateId: string, subject: string, content: string, language: EmailTemplateLanguage | null = null): Promise<BaseResponse<EmailTemplateDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/email-templates/${emailTemplateId}`)
+            .method('patch')
+            .bearerToken()
+            .body({
+                subject,
+                content,
+                language
+            })
+            .runAdapter(EmailTemplateAdapter.parseEmailTemplate);
+    }
+
+    async delete(merchantId: string, eventId: string, emailTemplateId: string): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/email-templates/${emailTemplateId}`)
+            .method('delete')
+            .bearerToken()
+            .runAdapter(CommonAdapter.parseStatusResponse);
+    }
+}

package/src/service/MerchantEventEmailTemplatesService.ts

@@ -0,0 +1,31 @@
+import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { EmailTemplateAdapter } from '#data/adapter';
+import type { EmailTemplateDto } from '#data/dto';
+import type { EmailTemplateLanguage, EmailTemplateType } from '#data/types';
+
+export class MerchantEventEmailTemplatesService extends BaseService {
+    async get(merchantId: string, eventId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<EmailTemplateDto>>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/email-templates`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('offset', offset)
+                .append('limit', limit))
+            .runPaginatedAdapter(EmailTemplateAdapter.parseEmailTemplate);
+    }
+
+    async post(merchantId: string, eventId: string, type: EmailTemplateType, subject: string, content: string, language: EmailTemplateLanguage | null = null): Promise<BaseResponse<EmailTemplateDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/email-templates`)
+            .method('post')
+            .bearerToken()
+            .body({
+                type,
+                subject,
+                content,
+                language
+            })
+            .runAdapter(EmailTemplateAdapter.parseEmailTemplate);
+    }
+}

package/src/service/MerchantEventProductService.ts

@@ -1,5 +1,4 @@
 import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
-import type { DateTime } from 'luxon';
 import { ProductAdapter } from '#data/adapter';
 import type { ProductDto } from '#data/dto';
 

package/src/service/PublicShopService.ts

@@ -31,7 +31,7 @@ export class PublicShopService extends BaseService {
                 number: addressNumber,
                 postal_code: addressPostalCode,
                 street: addressStreet
-            }
+            };
         }
 
         return await this

package/src/service/index.ts

@@ -20,6 +20,10 @@ export * from './MerchantEventShopsService';
 export * from './MerchantEventStockPoolsService';
 export * from './MerchantEventTicketTemplateService';
 export * from './MerchantEventTicketTemplatesService';
+export * from './MerchantEmailTemplateService';
+export * from './MerchantEmailTemplatesService';
+export * from './MerchantEventEmailTemplateService';
+export * from './MerchantEventEmailTemplatesService';
 export * from './MerchantEventsService';
 export * from './MerchantFinanceInvoiceService';
 export * from './MerchantFinanceInvoicesService';
@@ -42,4 +46,5 @@ export * from './PublicOrderService';
 export * from './PublicShopService';
 export * from './ReservationService';
 export * from './ServicesService';
+export * from './EmailTemplateEditorService';
 export * from './UiSelectOptionsService';

package/src/types/emailTemplate.ts

@@ -0,0 +1,13 @@
+export type EmailTemplateType =
+    | 'merchant_invite'
+    | 'order_canceled'
+    | 'order_confirmation'
+    | 'order_expired'
+    | 'order_failed'
+    | 'personalization_invite'
+    | 'personalization_request'
+    | 'tickets';
+
+export type EmailTemplateLanguage =
+    | 'en'
+    | 'nl';