@passly-nl/data 1.3.4 → 1.3.6

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@passly-nl/data",
     "description": "API implementation for Passly.",
-    "version": "1.3.4",
+    "version": "1.3.6",
     "type": "module",
     "license": "MIT",
     "funding": "https://github.com/sponsors/basmilius",
@@ -50,22 +50,16 @@
         "./*": "./*"
     },
     "devDependencies": {
-        "@basmilius/http-client": "^3.35.0",
-        "@flux-ui/types": "^3.0.0-next.70",
-        "@fortawesome/fontawesome-common-types": "^7.2.0",
+        "@basmilius/http-client": "^3.38.0",
+        "@flux-ui/types": "^3.0.0-next.72",
         "@types/luxon": "^3.7.1",
-        "@typescript/native-preview": "^7.0.0-dev.20260524.1",
+        "@typescript/native-preview": "^7.0.0-dev.20260527.1",
         "luxon": "^3.7.2",
         "tsdown": "^0.22.0"
     },
     "peerDependencies": {
-        "@basmilius/http-client": "^3.35.0",
-        "@flux-ui/types": "^3.0.0-next.70",
-        "@fortawesome/fontawesome-common-types": "^7.2.0",
+        "@basmilius/http-client": "^3.38.0",
+        "@flux-ui/types": "^3.0.0-next.72",
         "luxon": "^3.7.2"
-    },
-    "overrides": {
-        "@disabled-basmilius/http-client": "link:@basmilius/http-client",
-        "@disabled-flux-ui/types": "link:@flux-ui/types"
     }
 }

package/src/dto/aiUsage/AiUsagePeriodDto.ts

@@ -52,11 +52,11 @@ export class AiUsagePeriodDto {
         this.#lastEventOn = value;
     }
 
-    get features(): AiUsageFeatureStatusDto[] {
+    get features(): AiUsageFeatureStatusDto[] | null {
         return this.#features;
     }
 
-    set features(value: AiUsageFeatureStatusDto[]) {
+    set features(value: AiUsageFeatureStatusDto[] | null) {
         this.#features = value;
     }
 
@@ -66,9 +66,9 @@ export class AiUsagePeriodDto {
     #limitTokens: number | null;
     #percentage: number;
     #lastEventOn: DateTime | null;
-    #features: AiUsageFeatureStatusDto[];
+    #features: AiUsageFeatureStatusDto[] | null;
 
-    constructor(periodStart: DateTime | null, periodEnd: DateTime | null, tokensUsed: number, limitTokens: number | null, percentage: number, lastEventOn: DateTime | null, features: AiUsageFeatureStatusDto[]) {
+    constructor(periodStart: DateTime | null, periodEnd: DateTime | null, tokensUsed: number, limitTokens: number | null, percentage: number, lastEventOn: DateTime | null, features: AiUsageFeatureStatusDto[] | null) {
         this.#periodStart = periodStart;
         this.#periodEnd = periodEnd;
         this.#tokensUsed = tokensUsed;

package/src/dto/statistics/InsightsResponseDto.ts

@@ -20,11 +20,11 @@ export class InsightsResponseDto {
         this.#language = value;
     }
 
-    get cards(): InsightDto[] {
+    get cards(): InsightDto[] | null {
         return this.#cards;
     }
 
-    set cards(value: InsightDto[]) {
+    set cards(value: InsightDto[] | null) {
         this.#cards = value;
     }
 
@@ -38,10 +38,10 @@ export class InsightsResponseDto {
 
     #insightsEnabled: boolean;
     #language: InsightLanguage;
-    #cards: InsightDto[];
+    #cards: InsightDto[] | null;
     #lastGeneratedOn: string | null;
 
-    constructor(insightsEnabled: boolean, language: InsightLanguage, cards: InsightDto[], lastGeneratedOn: string | null) {
+    constructor(insightsEnabled: boolean, language: InsightLanguage, cards: InsightDto[] | null, lastGeneratedOn: string | null) {
         this.#insightsEnabled = insightsEnabled;
         this.#language = language;
         this.#cards = cards;

package/src/service/AdminMerchantsService.ts

@@ -1,16 +1,15 @@
-import { type BaseResponse, BaseService, type Paginated, QueryString } from '@basmilius/http-client';
+import { type BaseResponse, BaseService, type Paginated } from '@basmilius/http-client';
 import { MerchantAdapter } from '#data/adapter';
 import { MerchantDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class AdminMerchantsService extends BaseService {
-    async get(offset: number, limit: number): Promise<BaseResponse<Paginated<MerchantDto>>> {
+    async get(params: ListParams): Promise<BaseResponse<Paginated<MerchantDto>>> {
         return await this
             .request('/admin/merchants')
             .method('get')
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .bearerToken()
             .runPaginatedAdapter(MerchantAdapter.parseMerchant);
     }

package/src/service/MerchantBuyerService.ts

@@ -1,6 +1,8 @@
 import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
 import { BuyerAdapter, OrderAdapter } from '#data/adapter';
 import type { BuyerDto, OrderDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantBuyerService extends BaseService {
     async get(merchantId: string, buyerId: string): Promise<BaseResponse<BuyerDto>> {
@@ -23,15 +25,12 @@ export class MerchantBuyerService extends BaseService {
             .runAdapter(OrderAdapter.parseOrder);
     }
 
-    async getOrders(merchantId: string, buyerId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<OrderDto>>> {
+    async getOrders(merchantId: string, buyerId: string, params: ListParams): Promise<BaseResponse<Paginated<OrderDto>>> {
         return await this
             .request(`/merchants/${merchantId}/buyers/${buyerId}/orders`)
             .method('get')
             .bearerToken()
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .runPaginatedAdapter(OrderAdapter.parseOrder);
     }
 }

package/src/service/MerchantBuyersService.ts

@@ -1,16 +1,15 @@
-import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { BaseResponse, BaseService, Paginated } from '@basmilius/http-client';
 import { BuyerAdapter } from '#data/adapter';
 import type { BuyerDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantBuyersService extends BaseService {
-    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<BuyerDto>>> {
+    async get(merchantId: string, params: ListParams): Promise<BaseResponse<Paginated<BuyerDto>>> {
         return await this
             .request(`/merchants/${merchantId}/buyers`)
             .method('get')
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .bearerToken()
             .runPaginatedAdapter(BuyerAdapter.parseBuyer);
     }

package/src/service/MerchantContractService.ts

@@ -1,18 +1,17 @@
 import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
 import { MerchantAdapter } from '#data/adapter';
 import type { ContractDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 import type { DateTime } from 'luxon';
 
 export class MerchantContractService extends BaseService {
-    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<ContractDto>>> {
+    async get(merchantId: string, params: ListParams): 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))
+            .queryString(buildListQuery(params))
             .runPaginatedAdapter(MerchantAdapter.parseContract);
     }
 

package/src/service/MerchantDiscountCodesService.ts

@@ -2,24 +2,16 @@ import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/ht
 import type { DateTime } from 'luxon';
 import { DiscountCodeAdapter } from '#data/adapter';
 import type { DiscountCodeDto } from '#data/dto';
-import type { DiscountCodeType } from '#data/types';
+import type { DiscountCodeType, ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantDiscountCodesService extends BaseService {
-    async get(merchantId: string, offset: number, limit: number, eventId: string | null = null): Promise<BaseResponse<Paginated<DiscountCodeDto>>> {
-        const qs = QueryString.builder()
-            .append('language', 'nl')
-            .append('offset', offset)
-            .append('limit', limit);
-
-        if (eventId !== null) {
-            qs.append('event_id', eventId);
-        }
-
+    async get(merchantId: string, params: ListParams): Promise<BaseResponse<Paginated<DiscountCodeDto>>> {
         return await this
             .request(`/merchants/${merchantId}/discount-codes`)
             .method('get')
             .bearerToken()
-            .queryString(qs)
+            .queryString(buildListQuery(params))
             .runPaginatedAdapter(DiscountCodeAdapter.parseDiscountCode);
     }
 

package/src/service/MerchantEmailTemplatesService.ts

@@ -1,17 +1,16 @@
-import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { BaseResponse, BaseService, Paginated } from '@basmilius/http-client';
 import { EmailTemplateAdapter } from '#data/adapter';
 import type { EmailTemplateDto } from '#data/dto';
-import type { EmailTemplateLanguage, EmailTemplateType } from '#data/types';
+import type { EmailTemplateLanguage, EmailTemplateType, ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantEmailTemplatesService extends BaseService {
-    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<EmailTemplateDto>>> {
+    async get(merchantId: string, params: ListParams): Promise<BaseResponse<Paginated<EmailTemplateDto>>> {
         return await this
             .request(`/merchants/${merchantId}/email-templates`)
             .method('get')
             .bearerToken()
-            .queryString(QueryString.builder()
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .runPaginatedAdapter(EmailTemplateAdapter.parseEmailTemplate);
     }
 

package/src/service/MerchantEventAppTeamsService.ts

@@ -1,17 +1,16 @@
 import { type BaseResponse, BaseService, type Paginated, QueryString } from '@basmilius/http-client';
 import { EventAdapter } from '#data/adapter';
 import type { AppTeamDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantEventAppTeamsService extends BaseService {
-    async get(merchantId: string, eventId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<AppTeamDto>>> {
+    async get(merchantId: string, eventId: string, params: ListParams): Promise<BaseResponse<Paginated<AppTeamDto>>> {
         return await this
             .request(`/merchants/${merchantId}/events/${eventId}/app-teams`)
             .method('get')
             .bearerToken()
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .runPaginatedAdapter(EventAdapter.parseAppTeam);
     }
 

package/src/service/MerchantEventEmailTemplatesService.ts

@@ -1,17 +1,16 @@
-import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { BaseResponse, BaseService, Paginated } from '@basmilius/http-client';
 import { EmailTemplateAdapter } from '#data/adapter';
 import type { EmailTemplateDto } from '#data/dto';
-import type { EmailTemplateLanguage, EmailTemplateType } from '#data/types';
+import type { EmailTemplateLanguage, EmailTemplateType, ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantEventEmailTemplatesService extends BaseService {
-    async get(merchantId: string, eventId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<EmailTemplateDto>>> {
+    async get(merchantId: string, eventId: string, params: ListParams): 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))
+            .queryString(buildListQuery(params))
             .runPaginatedAdapter(EmailTemplateAdapter.parseEmailTemplate);
     }
 

package/src/service/MerchantEventProductsService.ts

@@ -3,17 +3,16 @@ import type { FluxFormSelectEntry } from '@flux-ui/types';
 import type { DateTime } from 'luxon';
 import { FluxAdapter, ProductAdapter } from '#data/adapter';
 import type { ProductDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantEventProductsService extends BaseService {
-    async get(merchantId: string, eventId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<ProductDto>>> {
+    async get(merchantId: string, eventId: string, params: ListParams): Promise<BaseResponse<Paginated<ProductDto>>> {
         return await this
             .request(`/merchants/${merchantId}/events/${eventId}/products`)
             .method('get')
             .bearerToken()
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .runPaginatedAdapter(ProductAdapter.parseProduct);
     }
 

package/src/service/MerchantEventShopsService.ts

@@ -2,16 +2,15 @@ import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/ht
 import type { DateTime } from 'luxon';
 import { CommonAdapter, EventAdapter } from '#data/adapter';
 import type { ShopDto, StatusResponseDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantEventShopsService extends BaseService {
-    async get(merchantId: string, eventId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<ShopDto>>> {
+    async get(merchantId: string, eventId: string, params: ListParams): Promise<BaseResponse<Paginated<ShopDto>>> {
         return await this
             .request(`/merchants/${merchantId}/events/${eventId}/shops`)
             .method('get')
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .bearerToken()
             .runPaginatedAdapter(EventAdapter.parseShop);
     }

package/src/service/MerchantEventStockPoolsService.ts

@@ -2,16 +2,15 @@ import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/ht
 import type { FluxFormSelectEntry } from '@flux-ui/types';
 import { EventAdapter, FluxAdapter } from '#data/adapter';
 import type { StockOverviewDto, StockPoolDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantEventStockPoolsService extends BaseService {
-    async get(merchantId: string, eventId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<StockPoolDto>>> {
+    async get(merchantId: string, eventId: string, params: ListParams): Promise<BaseResponse<Paginated<StockPoolDto>>> {
         return await this
             .request(`/merchants/${merchantId}/events/${eventId}/stock-pools`)
             .method('get')
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .bearerToken()
             .runPaginatedAdapter(EventAdapter.parseStockPool);
     }

package/src/service/MerchantEventTicketTemplatesService.ts

@@ -2,18 +2,15 @@ import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/ht
 import type { FluxFormSelectEntry } from '@flux-ui/types';
 import { EventAdapter, FluxAdapter } from '#data/adapter';
 import type { TicketTemplateDto } from '#data/dto';
-import type { TicketTemplateType } from '#data/types';
-import { jsonBlob } from '#data/util';
+import type { ListParams, TicketTemplateType } from '#data/types';
+import { buildListQuery, jsonBlob } from '#data/util';
 
 export class MerchantEventTicketTemplatesService extends BaseService {
-    async get(merchantId: string, eventId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<TicketTemplateDto>>> {
+    async get(merchantId: string, eventId: string, params: ListParams): Promise<BaseResponse<Paginated<TicketTemplateDto>>> {
         return await this
             .request(`/merchants/${merchantId}/events/${eventId}/ticket-templates`)
             .method('get')
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .bearerToken()
             .runPaginatedAdapter(EventAdapter.parseTicketTemplate);
     }

package/src/service/MerchantEventTimeSlotsService.ts

@@ -1,6 +1,7 @@
 import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import type { FluxFormSelectEntry } from '@flux-ui/types';
 import type { DateTime } from 'luxon';
-import { EventAdapter } from '#data/adapter';
+import { EventAdapter, FluxAdapter } from '#data/adapter';
 import type { TimeSlotDto } from '#data/dto';
 
 export class MerchantEventTimeSlotsService extends BaseService {
@@ -16,6 +17,18 @@ export class MerchantEventTimeSlotsService extends BaseService {
             .runPaginatedAdapter(EventAdapter.parseTimeSlot);
     }
 
+    async getSelectOptions(merchantId: string, eventId: string, searchQuery: string | null = null, ids: string[] | null = null): Promise<BaseResponse<FluxFormSelectEntry[]>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/${eventId}/time-slots/select-options`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl')
+                .appendArray('ids[]', ids)
+                .append('searchQuery', searchQuery))
+            .bearerToken()
+            .runArrayAdapter(FluxAdapter.parseFluxFormSelectEntry);
+    }
+
     async create(merchantId: string, eventId: string, fromTime: DateTime, toTime: DateTime, label: string | null = null): Promise<BaseResponse<TimeSlotDto>> {
         return await this
             .request(`/merchants/${merchantId}/events/${eventId}/time-slots`)

package/src/service/MerchantEventsService.ts

@@ -1,19 +1,31 @@
 import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import type { FluxFormSelectEntry } from '@flux-ui/types';
 import type { DateTime } from 'luxon';
-import { EventAdapter } from '#data/adapter';
+import { EventAdapter, FluxAdapter } from '#data/adapter';
 import type { EventDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantEventsService extends BaseService {
-    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<EventDto>>> {
+    async get(merchantId: string, params: ListParams): Promise<BaseResponse<Paginated<EventDto>>> {
         return await this
             .request(`/merchants/${merchantId}/events`)
             .method('get')
             .bearerToken()
+            .queryString(buildListQuery(params))
+            .runPaginatedAdapter(EventAdapter.parseEvent);
+    }
+
+    async getSelectOptions(merchantId: string, searchQuery: string | null = null, ids: string[] | null = null): Promise<BaseResponse<FluxFormSelectEntry[]>> {
+        return await this
+            .request(`/merchants/${merchantId}/events/select-options`)
+            .method('get')
             .queryString(QueryString.builder()
                 .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
-            .runPaginatedAdapter(EventAdapter.parseEvent);
+                .appendArray('ids[]', ids)
+                .append('searchQuery', searchQuery))
+            .bearerToken()
+            .runArrayAdapter(FluxAdapter.parseFluxFormSelectEntry);
     }
 
     async post(merchantId: string, name: string, description: string, startsOn: DateTime, endsOn: DateTime, minimumAge: number): Promise<BaseResponse<EventDto>> {

package/src/service/MerchantFinanceInvoicesService.ts

@@ -1,17 +1,16 @@
-import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { BaseResponse, BaseService, Paginated } from '@basmilius/http-client';
 import { FinanceAdapter } from '#data/adapter';
 import type { InvoiceDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantFinanceInvoicesService extends BaseService {
-    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<InvoiceDto>>> {
+    async get(merchantId: string, params: ListParams): Promise<BaseResponse<Paginated<InvoiceDto>>> {
         return await this
             .request(`/merchants/${merchantId}/finance/invoices`)
             .method('get')
             .bearerToken()
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .runPaginatedAdapter(FinanceAdapter.parseInvoice);
     }
 }

package/src/service/MerchantOrdersService.ts

@@ -1,25 +1,15 @@
-import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { BaseResponse, BaseService, Paginated } from '@basmilius/http-client';
 import { OrderAdapter } from '#data/adapter';
 import type { OrderDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantOrdersService extends BaseService {
-    async get(merchantId: string, offset: number, limit: number, filter?: Record<string, string | number | boolean>): Promise<BaseResponse<Paginated<OrderDto>>> {
-        const query = QueryString
-            .builder()
-            .append('language', 'nl')
-            .append('offset', offset)
-            .append('limit', limit);
-
-        if (filter) {
-            Object
-                .entries(filter)
-                .forEach(([key, value]) => query.append(key, value));
-        }
-
+    async get(merchantId: string, params: ListParams): Promise<BaseResponse<Paginated<OrderDto>>> {
         return await this
             .request(`/merchants/${merchantId}/orders`)
             .method('get')
-            .queryString(query)
+            .queryString(buildListQuery(params))
             .bearerToken()
             .runPaginatedAdapter(OrderAdapter.parseOrder);
     }

package/src/service/MerchantShopsService.ts

@@ -1,16 +1,15 @@
-import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { BaseResponse, BaseService, Paginated } from '@basmilius/http-client';
 import { EventAdapter } from '#data/adapter';
 import type { ShopDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantShopsService extends BaseService {
-    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<ShopDto>>> {
+    async get(merchantId: string, params: ListParams): Promise<BaseResponse<Paginated<ShopDto>>> {
         return await this
             .request(`/merchants/${merchantId}/shops`)
             .method('get')
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .bearerToken()
             .runPaginatedAdapter(EventAdapter.parseShop);
     }

package/src/service/MerchantTicketsService.ts

@@ -1,25 +1,15 @@
-import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { BaseResponse, BaseService, Paginated } from '@basmilius/http-client';
 import { TicketAdapter } from '#data/adapter';
 import type { TicketDto } from '#data/dto';
+import type { ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantTicketsService extends BaseService {
-    async get(merchantId: string, offset: number, limit: number, filter?: Record<string, string | number | boolean>): Promise<BaseResponse<Paginated<TicketDto>>> {
-        const query = QueryString
-            .builder()
-            .append('language', 'nl')
-            .append('offset', offset)
-            .append('limit', limit);
-
-        if (filter) {
-            Object
-                .entries(filter)
-                .forEach(([key, value]) => query.append(key, value));
-        }
-
+    async get(merchantId: string, params: ListParams): Promise<BaseResponse<Paginated<TicketDto>>> {
         return await this
             .request(`/merchants/${merchantId}/tickets`)
             .method('get')
-            .queryString(query)
+            .queryString(buildListQuery(params))
             .bearerToken()
             .runPaginatedAdapter(TicketAdapter.parseTicket);
     }

package/src/service/MerchantUsersService.ts

@@ -1,17 +1,15 @@
 import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
 import { MerchantAdapter } from '#data/adapter';
 import type { InvitationDto, MerchantUserDto } from '#data/dto';
-import type { Claim } from '#data/types';
+import type { Claim, ListParams } from '#data/types';
+import { buildListQuery } from '#data/util';
 
 export class MerchantUsersService extends BaseService {
-    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<MerchantUserDto>>> {
+    async get(merchantId: string, params: ListParams): Promise<BaseResponse<Paginated<MerchantUserDto>>> {
         return await this
             .request(`/merchants/${merchantId}/users`)
             .method('get')
-            .queryString(QueryString.builder()
-                .append('language', 'nl')
-                .append('offset', offset)
-                .append('limit', limit))
+            .queryString(buildListQuery(params))
             .bearerToken()
             .runPaginatedAdapter(MerchantAdapter.parseMerchantUser);
     }

package/src/service/PublicShopService.ts

@@ -33,7 +33,7 @@ export class PublicShopService extends BaseService {
     }
 
     async buy(shopId: string, reservationId: string, firstName: string, lastName: string, email: string, phoneNumber: string, dateOfBirth: DateTime | null, gender: Gender | null, addressCity: string | null, addressCountry: string | null, addressNumber: string | null, addressPostalCode: string | null, addressStreet: string | null, attribution: MarketingAttributionDto | null = null): Promise<BaseResponse<OrderDto>> {
-        let address: Record<string, string | null> = null;
+        let address: Record<string, string | null> | null = null;
 
         addressCity = emptyNull(addressCity);
         addressCountry = emptyNull(addressCountry);

package/src/types/index.ts

@@ -10,6 +10,7 @@ export type * from './general';
 export type * from './event';
 export type * from './finance';
 export type * from './insights';
+export type * from './list';
 export type * from './milestone';
 export type * from './order';
 export type * from './payment';

package/src/types/list.ts

@@ -0,0 +1,12 @@
+import type { DateTime } from 'luxon';
+
+export type FilterValueSingle = string | number | boolean | DateTime | null;
+export type FilterValue = FilterValueSingle | FilterValueSingle[];
+export type Filters = Record<string, FilterValue>;
+
+export type ListParams = {
+    readonly offset: number;
+    readonly limit: number;
+    readonly filters?: Filters;
+    readonly search?: string;
+};