@passly-nl/data 1.0.1 → 1.0.3

package/src/service/EmailTemplateEditorService.ts

@@ -0,0 +1,285 @@
+import type { EmailTemplateType } from '../types/emailTemplate';
+import type {
+    EmailTemplateEditorBlock,
+    EmailTemplateEditorButtonBlock,
+    EmailTemplateEditorCondition,
+    EmailTemplateEditorContext,
+    EmailTemplateEditorH1Block,
+    EmailTemplateEditorHeaderBlock,
+    EmailTemplateEditorIfBlock,
+    EmailTemplateEditorParagraphBlock,
+    EmailTemplateEditorVariable
+} from '../types/emailTemplateEditor';
+
+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_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
+        ]
+    },
+    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/MerchantContractService.ts

@@ -0,0 +1,60 @@
+import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { MerchantAdapter } from '#data/adapter';
+import type { ContractDto } from '#data/dto';
+import type { DateTime } from 'luxon';
+
+export class MerchantContractService extends BaseService {
+    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<ContractDto>>> {
+        return await this
+            .request(`/merchants/${merchantId}/contracts`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl')
+                .append('offset', offset)
+                .append('limit', limit))
+            .runPaginatedAdapter(MerchantAdapter.parseContract);
+    }
+
+    async getSingle(merchantId: string, contractId: string): Promise<BaseResponse<ContractDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/contracts/${contractId}`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(MerchantAdapter.parseContract);
+    }
+
+    async post(merchantId: string, startsOn: DateTime, endsOn: DateTime, feeCents: number, remark: string): Promise<BaseResponse<ContractDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/contracts`)
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                starts_on: startsOn.toISO(),
+                ends_on: endsOn.toISO(),
+                fee_cents: feeCents,
+                remark: remark || undefined
+            })
+            .runAdapter(MerchantAdapter.parseContract);
+    }
+
+    async put(merchantId: string, contractId: string, startsOn: DateTime, endsOn: DateTime, feeCents: number, remark: string): Promise<BaseResponse<ContractDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/contracts/${contractId}`)
+            .method('put')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                starts_on: startsOn.toISO(),
+                ends_on: endsOn.toISO(),
+                fee_cents: feeCents,
+                remark: remark || undefined
+            })
+            .runAdapter(MerchantAdapter.parseContract);
+    }
+}

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,4 +1,5 @@
 import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import type { DateTime } from 'luxon';
 import { ProductAdapter } from '#data/adapter';
 import type { ProductDto } from '#data/dto';
 
@@ -39,7 +40,8 @@ export class MerchantEventProductService extends BaseService {
                 description: product.description,
                 price: product.price.cents,
                 max_quantity: product.maxQuantity,
-                is_swappable: product.isSwappable
+                is_swappable: product.isSwappable,
+                tickets_released_on: product.ticketsReleasedOn?.toISO() ?? null
             })
             .runAdapter(ProductAdapter.parseProduct);
     }

package/src/service/MerchantEventProductsService.ts

@@ -1,5 +1,6 @@
 import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
 import type { FluxFormSelectEntry } from '@flux-ui/types';
+import type { DateTime } from 'luxon';
 import { FluxAdapter, ProductAdapter } from '#data/adapter';
 import type { ProductDto } from '#data/dto';
 
@@ -28,7 +29,7 @@ export class MerchantEventProductsService extends BaseService {
             .runArrayAdapter(FluxAdapter.parseFluxFormSelectEntry);
     }
 
-    async post(merchantId: string, eventId: string, name: string, description: string, price: number, maxQuantity: number, stock: number | null, stockPoolId: string | null): Promise<BaseResponse<ProductDto>> {
+    async post(merchantId: string, eventId: string, name: string, description: string, price: number, maxQuantity: number, stock: number | null, stockPoolId: string | null, ticketsReleasedOn: DateTime | null = null): Promise<BaseResponse<ProductDto>> {
         return await this
             .request(`/merchants/${merchantId}/events/${eventId}/products`)
             .method('post')
@@ -41,7 +42,8 @@ export class MerchantEventProductsService extends BaseService {
                 price,
                 stock,
                 max_quantity: maxQuantity,
-                stock_pool_id: stockPoolId
+                stock_pool_id: stockPoolId,
+                tickets_released_on: ticketsReleasedOn?.toISO() ?? null
             })
             .runAdapter(ProductAdapter.parseProduct);
     }

package/src/service/MerchantUserService.ts

@@ -0,0 +1,38 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import { MerchantAdapter } from '#data/adapter';
+import type { MerchantUserDto } from '#data/dto';
+import type { Claim } from '#data/types';
+
+export class MerchantUserService extends BaseService {
+    async get(merchantId: string, userId: string): Promise<BaseResponse<MerchantUserDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/users/${userId}`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(MerchantAdapter.parseMerchantUser);
+    }
+
+    async put(merchantId: string, userId: string, isManager: boolean, claims: Claim[]): Promise<BaseResponse<MerchantUserDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/users/${userId}`)
+            .method('put')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                is_manager: isManager,
+                claims
+            })
+            .runAdapter(MerchantAdapter.parseMerchantUser);
+    }
+
+    async remove(merchantId: string, userId: string): Promise<BaseResponse<void>> {
+        return await this
+            .request(`/merchants/${merchantId}/users/${userId}`)
+            .method('delete')
+            .bearerToken()
+            .runEmpty();
+    }
+}

package/src/service/index.ts

@@ -1,7 +1,11 @@
+export * from './AdminService';
+export * from './AdminMerchantService';
+export * from './AdminMerchantsService';
 export * from './AuthService';
 export * from './InvitationService';
 export * from './MerchantService';
 export * from './MerchantsService';
+export * from './MerchantContractService';
 export * from './MerchantBuyerService';
 export * from './MerchantBuyersService';
 export * from './MerchantDashboardService';
@@ -16,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';
@@ -31,10 +39,12 @@ export * from './MerchantStatisticsOverviewService';
 export * from './MerchantStatisticsSalesService';
 export * from './MerchantTicketService';
 export * from './MerchantTicketsService';
+export * from './MerchantUserService';
 export * from './MerchantUsersService';
 export * from './MeService';
 export * from './PublicOrderService';
 export * from './PublicShopService';
 export * from './ReservationService';
 export * from './ServicesService';
+export * from './EmailTemplateEditorService';
 export * from './UiSelectOptionsService';

package/src/types/auth.ts

@@ -1,5 +1,8 @@
 export type Claim =
     | 'admin:view'
+    | 'admin:finance'
+    | 'admin:merchants'
+    | 'admin:statistics'
     | 'auth:login'
     | 'buyers:view'
     | 'events:create'

package/src/types/emailTemplate.ts

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