@passly-nl/data 1.0.0-beta.2 → 1.0.0-beta.5

package/src/adapter/PublicShopAdapter.ts

@@ -1,149 +1,149 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import { AddressAdapter, DateTimeAdapter, FileSystemAdapter, PaymentAdapter } from '#data/adapter';
 import { PublicShopDesignDto, PublicShopDto, PublicShopElementButtonDto, PublicShopElementDividerDto, PublicShopElementDto, PublicShopElementHeadingDto, PublicShopElementNoticeDto, PublicShopElementProductDto, PublicShopElementTextDto, PublicShopEventDto, PublicShopMerchantDto, PublicShopProductDto, PublicShopReservationDto, PublicShopReservationProductDetailsDto, PublicShopReservationProductDto, PublicShopTimeSlotDto } from '#data/dto';
 import { optional, optionalArray } from '#data/util';
 
 @adapter
 export class PublicShopAdapter {
-    static parsePublicShopFromObject(shop: Record<string, any>): PublicShopDto {
+    static parsePublicShop(data: ForeignData): PublicShopDto {
         return new PublicShopDto(
-            shop.id,
-            shop.name,
-            DateTimeAdapter.parseDateTimeFromString(shop.starts_on),
-            DateTimeAdapter.parseDateTimeFromString(shop.ends_on),
-            shop.field_address,
-            shop.field_birthdate,
-            shop.field_gender,
-            shop.field_phone_number,
-            optional(shop.design, PublicShopAdapter.parsePublicShopDesignFromObject),
-            optionalArray(shop.elements, PublicShopAdapter.parsePublicShopElementFromObject),
-            PublicShopAdapter.parsePublicShopEventFromObject(shop.event),
-            PublicShopAdapter.parsePublicShopMerchantFromObject(shop.merchant)
+            data.id,
+            data.name,
+            DateTimeAdapter.parseDateTime(data.starts_on),
+            DateTimeAdapter.parseDateTime(data.ends_on),
+            data.field_address,
+            data.field_birthdate,
+            data.field_gender,
+            data.field_phone_number,
+            optional(data.design, PublicShopAdapter.parsePublicShopDesign),
+            optionalArray(data.elements, PublicShopAdapter.parsePublicShopElement),
+            PublicShopAdapter.parsePublicShopEvent(data.event),
+            PublicShopAdapter.parsePublicShopMerchant(data.merchant)
         );
     }
 
-    static parsePublicShopDesignFromObject(design: Record<string, any>): PublicShopDesignDto {
+    static parsePublicShopDesign(data: ForeignData): PublicShopDesignDto {
         return new PublicShopDesignDto(
-            design.background_color,
-            design.foreground_color,
-            design.primary_color
+            data.background_color,
+            data.foreground_color,
+            data.primary_color
         );
     }
 
-    static parsePublicShopElementFromObject(element: Record<string, any>): PublicShopElementDto {
-        switch (element.type) {
+    static parsePublicShopElement(data: ForeignData): PublicShopElementDto {
+        switch (data.type) {
             case 'button':
                 return new PublicShopElementButtonDto(
-                    element.id,
-                    element.icon,
-                    element.text,
-                    element.url
+                    data.id,
+                    data.icon,
+                    data.text,
+                    data.url
                 );
 
             case 'divider':
                 return new PublicShopElementDividerDto(
-                    element.id,
-                    element.icon,
-                    element.text
+                    data.id,
+                    data.icon,
+                    data.text
                 );
 
             case 'heading':
                 return new PublicShopElementHeadingDto(
-                    element.id,
-                    element.heading_level,
-                    element.title
+                    data.id,
+                    data.heading_level,
+                    data.title
                 );
 
             case 'notice':
                 return new PublicShopElementNoticeDto(
-                    element.id,
-                    element.icon,
-                    element.notice_type,
-                    element.title,
-                    element.text
+                    data.id,
+                    data.icon,
+                    data.notice_type,
+                    data.title,
+                    data.text
                 );
 
             case 'product':
                 return new PublicShopElementProductDto(
-                    element.id,
-                    PublicShopAdapter.parsePublicShopProductFromObject(element.product)
+                    data.id,
+                    PublicShopAdapter.parsePublicShopProduct(data.product)
                 );
 
             case 'text':
                 return new PublicShopElementTextDto(
-                    element.id,
-                    element.text
+                    data.id,
+                    data.text
                 );
         }
 
         throw new Error('Unknown shop element.');
     }
 
-    static parsePublicShopEventFromObject(event: Record<string, any>): PublicShopEventDto {
+    static parsePublicShopEvent(data: ForeignData): PublicShopEventDto {
         return new PublicShopEventDto(
-            event.id,
-            event.name,
-            event.status,
-            AddressAdapter.parseAddressFromObject(event.address),
-            optional(event.header_file, FileSystemAdapter.parsePictureFromObject)
+            data.id,
+            data.name,
+            data.status,
+            AddressAdapter.parseAddress(data.address),
+            optional(data.header_file, FileSystemAdapter.parsePicture)
         );
     }
 
-    static parsePublicShopMerchantFromObject(merchant: Record<string, any>): PublicShopMerchantDto {
+    static parsePublicShopMerchant(data: ForeignData): PublicShopMerchantDto {
         return new PublicShopMerchantDto(
-            merchant.id,
-            merchant.name
+            data.id,
+            data.name
         );
     }
 
-    static parsePublicShopProductFromObject(product: Record<string, any>): PublicShopProductDto {
+    static parsePublicShopProduct(data: ForeignData): PublicShopProductDto {
         return new PublicShopProductDto(
-            product.id,
-            product.type,
-            product.name,
-            product.description,
-            PaymentAdapter.parseCostFromObject(product.price),
-            product.max_quantity,
-            product.is_active,
-            product.is_timeslotted,
-            optionalArray(product.time_slots, PublicShopAdapter.parsePublicShopTimeSlotFromObject)!,
-            optional(product.image, FileSystemAdapter.parsePictureFromObject),
-            optionalArray(product.images, FileSystemAdapter.parsePictureFromObject)!
+            data.id,
+            data.type,
+            data.name,
+            data.description,
+            PaymentAdapter.parseCost(data.price),
+            data.max_quantity,
+            data.is_active,
+            data.is_timeslotted,
+            optionalArray(data.time_slots, PublicShopAdapter.parsePublicShopTimeSlot)!,
+            optional(data.image, FileSystemAdapter.parsePicture),
+            optionalArray(data.images, FileSystemAdapter.parsePicture)!
         );
     }
 
-    static parsePublicShopReservationFromObject(reservation: Record<string, any>): PublicShopReservationDto {
+    static parsePublicShopReservation(data: ForeignData): PublicShopReservationDto {
         return new PublicShopReservationDto(
-            reservation.id,
-            DateTimeAdapter.parseDateTimeFromString(reservation.created_on),
-            DateTimeAdapter.parseDateTimeFromString(reservation.expires_on),
-            reservation.products.map(PublicShopAdapter.parsePublicShopReservationProductFromObject)
+            data.id,
+            DateTimeAdapter.parseDateTime(data.created_on),
+            DateTimeAdapter.parseDateTime(data.expires_on),
+            data.products.map(PublicShopAdapter.parsePublicShopReservationProduct)
         );
     }
 
-    static parsePublicShopReservationProductFromObject(product: Record<string, any>): PublicShopReservationProductDto {
+    static parsePublicShopReservationProduct(data: ForeignData): PublicShopReservationProductDto {
         return new PublicShopReservationProductDto(
-            PublicShopAdapter.parsePublicShopReservationProductDetailsFromObject(product.product),
-            product.quantity
+            PublicShopAdapter.parsePublicShopReservationProductDetails(data.product),
+            data.quantity
         );
     }
 
-    static parsePublicShopReservationProductDetailsFromObject(details: Record<string, any>): PublicShopReservationProductDetailsDto {
+    static parsePublicShopReservationProductDetails(data: ForeignData): PublicShopReservationProductDetailsDto {
         return new PublicShopReservationProductDetailsDto(
-            details.id,
-            details.name,
-            details.description,
-            optional(details.image, FileSystemAdapter.parsePictureFromObject)
+            data.id,
+            data.name,
+            data.description,
+            optional(data.image, FileSystemAdapter.parsePicture)
         );
     }
 
-    static parsePublicShopTimeSlotFromObject(timeSlot: Record<string, any>): PublicShopTimeSlotDto {
+    static parsePublicShopTimeSlot(data: ForeignData): PublicShopTimeSlotDto {
         return new PublicShopTimeSlotDto(
-            timeSlot.id,
-            timeSlot.label,
-            DateTimeAdapter.parseDateTimeFromString(timeSlot.from_time),
-            DateTimeAdapter.parseDateTimeFromString(timeSlot.to_time),
-            timeSlot.max_quantity
+            data.id,
+            data.label,
+            DateTimeAdapter.parseDateTime(data.from_time),
+            DateTimeAdapter.parseDateTime(data.to_time),
+            data.max_quantity
         );
     }
 }

package/src/adapter/ReservationAdapter.ts

@@ -1,33 +1,33 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import { DateTimeAdapter, FileSystemAdapter } from '#data/adapter';
 import { ReservationDto, ReservationItemDto, ReservationProductDto } from '#data/dto';
 import { optional, optionalArray } from '#data/util';
 
 @adapter
 export class ReservationAdapter {
-    static parseReservationFromObject(reservation: Record<string, any>): ReservationDto {
+    static parseReservation(data: ForeignData): ReservationDto {
         return new ReservationDto(
-            reservation.id,
-            DateTimeAdapter.parseDateTimeFromString(reservation.created_on),
-            DateTimeAdapter.parseDateTimeFromString(reservation.expires_on),
-            reservation.is_expired,
-            optionalArray(reservation.products, ReservationAdapter.parseReservationItemFromObject)!
+            data.id,
+            DateTimeAdapter.parseDateTime(data.created_on),
+            DateTimeAdapter.parseDateTime(data.expires_on),
+            data.is_expired,
+            optionalArray(data.products, ReservationAdapter.parseReservationItem)!
         );
     }
 
-    static parseReservationItemFromObject(item: Record<string, any>): ReservationItemDto {
+    static parseReservationItem(data: ForeignData): ReservationItemDto {
         return new ReservationItemDto(
-            item.quantity,
-            ReservationAdapter.parseReservationProductFromObject(item.product)
+            data.quantity,
+            ReservationAdapter.parseReservationProduct(data.product)
         );
     }
 
-    static parseReservationProductFromObject(product: Record<string, any>): ReservationProductDto {
+    static parseReservationProduct(data: ForeignData): ReservationProductDto {
         return new ReservationProductDto(
-            product.id,
-            product.name,
-            product.description,
-            optional(product.image, FileSystemAdapter.parsePictureFromObject)
+            data.id,
+            data.name,
+            data.description,
+            optional(data.image, FileSystemAdapter.parsePicture)
         );
     }
 }

package/src/adapter/StatisticsAdapter.ts

@@ -0,0 +1,13 @@
+import { adapter, ForeignData } from '@basmilius/http-client';
+import { StatisticsTrendDto } from '#data/dto';
+
+@adapter
+export class StatisticsAdapter {
+    static parseTrend<TValue>(data: ForeignData, adapter: (value: ForeignData) => TValue): StatisticsTrendDto<TValue> {
+        return new StatisticsTrendDto(
+            adapter(data.current),
+            adapter(data.previous),
+            data.growth_rate
+        );
+    }
+}

package/src/adapter/StatisticsBuyersAdapter.ts

@@ -0,0 +1,28 @@
+import { adapter, ForeignData } from '@basmilius/http-client';
+import { BuyerAdapter, PaymentAdapter, StatisticsAdapter } from '#data/adapter';
+import { StatisticsBuyersOverviewDto, StatisticsBuyersRankedDto } from '#data/dto';
+
+@adapter
+export class StatisticsBuyersAdapter {
+    static parseOverview(data: ForeignData): StatisticsBuyersOverviewDto {
+        return new StatisticsBuyersOverviewDto(
+            StatisticsAdapter.parseTrend(data.buyers, Number),
+            StatisticsAdapter.parseTrend(data.new_buyers, Number),
+            StatisticsAdapter.parseTrend(data.retention_rate, Number),
+            data.total_buyers,
+            PaymentAdapter.parseCost(data.lifetime_value_per_buyer),
+            data.average_tickets_per_buyer
+        );
+    }
+
+    static parseRanked(data: ForeignData): StatisticsBuyersRankedDto {
+        return new StatisticsBuyersRankedDto(
+            data.ranking,
+            BuyerAdapter.parseBuyer(data.buyer),
+            data.order_count,
+            PaymentAdapter.parseCost(data.total_spend),
+            data.events_attended,
+            PaymentAdapter.parseCost(data.average_order_value)
+        );
+    }
+}

package/src/adapter/StatisticsEventsAdapter.ts

@@ -0,0 +1,16 @@
+import { adapter, type ForeignData } from '@basmilius/http-client';
+import { PaymentAdapter } from '#data/adapter';
+import { StatisticsEventsOverviewDto } from '#data/dto';
+
+@adapter
+export class StatisticsEventsAdapter {
+    static parseOverview(data: ForeignData): StatisticsEventsOverviewDto {
+        return new StatisticsEventsOverviewDto(
+            data.total_events,
+            data.active_events,
+            PaymentAdapter.parseCost(data.average_revenue_per_event),
+            data.average_tickets_per_event,
+            data.average_sell_through_rate
+        );
+    }
+}

package/src/adapter/StatisticsOverviewAdapter.ts

@@ -0,0 +1,85 @@
+import { adapter, ForeignData } from '@basmilius/http-client';
+import { DateTimeAdapter, FileSystemAdapter, PaymentAdapter, StatisticsAdapter } from '#data/adapter';
+import { StatisticsOverviewBestRevenueMonthDto, StatisticsOverviewEventPerformanceDto, StatisticsOverviewEventPerformanceEventDto, StatisticsOverviewEventPerformanceSummaryDto, StatisticsOverviewKPIsDto, StatisticsOverviewKPIsTotalEventsHostedDto, StatisticsOverviewKPIsTotalRevenueDto, StatisticsOverviewKPIsTotalTicketsSoldDto } from '#data/dto';
+import { optional } from '#data/util';
+
+@adapter
+export class StatisticsOverviewAdapter {
+    static parseBestRevenueMonth(data: ForeignData): StatisticsOverviewBestRevenueMonthDto {
+        return new StatisticsOverviewBestRevenueMonthDto(
+            DateTimeAdapter.parseDateTimeFromMonth(data.period),
+            PaymentAdapter.parseCost(data.revenue),
+            data.orders,
+            data.tickets
+        );
+    }
+
+    static parseEventPerformance(data: ForeignData): StatisticsOverviewEventPerformanceDto {
+        return new StatisticsOverviewEventPerformanceDto(
+            data.events.map(StatisticsOverviewAdapter.parseEventPerformanceEvent),
+            StatisticsOverviewAdapter.parseEventPerformanceSummary(data.summary)
+        );
+    }
+
+    static parseEventPerformanceEvent(data: ForeignData): StatisticsOverviewEventPerformanceEventDto {
+        return new StatisticsOverviewEventPerformanceEventDto(
+            data.id,
+            data.name,
+            DateTimeAdapter.parseDateTime(data.starts_on),
+            DateTimeAdapter.parseDateTime(data.ends_on),
+            optional(data.header_file, FileSystemAdapter.parsePicture),
+            data.status,
+            PaymentAdapter.parseCost(data.revenue),
+            data.tickets_sold,
+            data.tickets_total,
+            data.sell_through_rate,
+            data.attendance_rate,
+            data.attended_count,
+            data.orders_count
+        );
+    }
+
+    static parseEventPerformanceSummary(data: ForeignData): StatisticsOverviewEventPerformanceSummaryDto {
+        return new StatisticsOverviewEventPerformanceSummaryDto(
+            PaymentAdapter.parseCost(data.total_revenue),
+            data.total_tickets_sold,
+            data.total_tickets_capacity,
+            data.average_sell_through_rate,
+            data.average_attendance_rate
+        );
+    }
+
+    static parseKPIs(data: ForeignData): StatisticsOverviewKPIsDto {
+        return new StatisticsOverviewKPIsDto(
+            StatisticsOverviewAdapter.parseKPIsTotalRevenue(data.total_revenue),
+            StatisticsOverviewAdapter.parseKPIsTotalTicketsSold(data.total_tickets_sold),
+            StatisticsOverviewAdapter.parseKPIsTotalEventsHosted(data.total_events_hosted),
+            data.total_customers,
+            PaymentAdapter.parseCost(data.average_order_value),
+            data.average_attendance_rate
+        );
+    }
+
+    static parseKPIsTotalEventsHosted(data: ForeignData): StatisticsOverviewKPIsTotalEventsHostedDto {
+        return new StatisticsOverviewKPIsTotalEventsHostedDto(
+            data.active,
+            data.concluded,
+            data.total,
+            data.upcoming
+        );
+    }
+
+    static parseKPIsTotalRevenue(data: ForeignData): StatisticsOverviewKPIsTotalRevenueDto {
+        return new StatisticsOverviewKPIsTotalRevenueDto(
+            PaymentAdapter.parseCost(data.lifetime),
+            StatisticsAdapter.parseTrend(data.trend, PaymentAdapter.parseCost)
+        );
+    }
+
+    static parseKPIsTotalTicketsSold(data: ForeignData): StatisticsOverviewKPIsTotalTicketsSoldDto {
+        return new StatisticsOverviewKPIsTotalTicketsSoldDto(
+            data.lifetime,
+            StatisticsAdapter.parseTrend(data.trend, Number)
+        );
+    }
+}

package/src/adapter/StatisticsSalesAdapter.ts

@@ -0,0 +1,33 @@
+import { adapter, ForeignData } from '@basmilius/http-client';
+import { DateTimeAdapter, PaymentAdapter } from '#data/adapter';
+import { StatisticsSalesLifetimeTotalsDto, StatisticsSalesPurchaseBehaviorDto, StatisticsSalesTransactionSuccessRateDto } from '#data/dto';
+
+@adapter
+export class StatisticsSalesAdapter {
+    static parseLifetimeTotals(data: ForeignData): StatisticsSalesLifetimeTotalsDto {
+        return new StatisticsSalesLifetimeTotalsDto(
+            PaymentAdapter.parseCost(data.total_revenue),
+            PaymentAdapter.parseCost(data.total_platform_cost),
+            PaymentAdapter.parseCost(data.net_revenue),
+            PaymentAdapter.parseCost(data.average_order_value),
+            PaymentAdapter.parseCost(data.average_revenue_per_ticket)
+        );
+    }
+
+    static parsePurchaseBehavior(data: ForeignData): StatisticsSalesPurchaseBehaviorDto {
+        return new StatisticsSalesPurchaseBehaviorDto(
+            data.average_time_to_purchase,
+            data.cart_abandonment_rate,
+            data.peak_buying_count,
+            DateTimeAdapter.parseDateTime(data.peak_buying_time)
+        );
+    }
+
+    static parseTransactionSuccessRate(data: ForeignData): StatisticsSalesTransactionSuccessRateDto {
+        return new StatisticsSalesTransactionSuccessRateDto(
+            data.success_rate,
+            data.failed_rate,
+            data.reasons
+        );
+    }
+}

package/src/adapter/TicketAdapter.ts

@@ -1,24 +1,24 @@
-import { adapter } from '@basmilius/http-client';
+import { adapter, ForeignData } from '@basmilius/http-client';
 import { BuyerAdapter, DateTimeAdapter, EventAdapter, OrderAdapter, ProductAdapter } from '#data/adapter';
 import { TicketDto } from '#data/dto';
 import { optional } from '#data/util';
 
 @adapter
 export class TicketAdapter {
-    static parseTicketFromObject(ticket: Record<string, any>): TicketDto {
+    static parseTicket(data: ForeignData): TicketDto {
         return new TicketDto(
-            ticket.id,
-            ticket.sequence,
-            ticket.code,
-            ticket.status,
-            ticket.validity,
-            optional(ticket.buyer, BuyerAdapter.parseBuyerFromObject)!,
-            optional(ticket.event, EventAdapter.parseEventFromObject)!,
-            optional(ticket.holder, BuyerAdapter.parseBuyerFromObject)!,
-            optional(ticket.order, OrderAdapter.parseOrderFromObject)!,
-            optional(ticket.product, ProductAdapter.parseProductFromObject)!,
-            DateTimeAdapter.parseDateTimeFromString(ticket.created_on),
-            DateTimeAdapter.parseDateTimeFromString(ticket.updated_on)
+            data.id,
+            data.sequence,
+            data.code,
+            data.status,
+            data.validity,
+            optional(data.buyer, BuyerAdapter.parseBuyer)!,
+            optional(data.event, EventAdapter.parseEvent)!,
+            optional(data.holder, BuyerAdapter.parseBuyer)!,
+            optional(data.order, OrderAdapter.parseOrder)!,
+            optional(data.product, ProductAdapter.parseProduct)!,
+            DateTimeAdapter.parseDateTime(data.created_on),
+            DateTimeAdapter.parseDateTime(data.updated_on)
         );
     }
 }

package/src/adapter/index.ts

@@ -15,4 +15,9 @@ export * from './ProductAdapter';
 export * from './PublicPayAdapter';
 export * from './PublicShopAdapter';
 export * from './ReservationAdapter';
+export * from './StatisticsAdapter';
+export * from './StatisticsBuyersAdapter';
+export * from './StatisticsEventsAdapter';
+export * from './StatisticsOverviewAdapter';
+export * from './StatisticsSalesAdapter';
 export * from './TicketAdapter';

package/src/dto/index.ts

@@ -11,4 +11,5 @@ export * from './product';
 export * from './publicPay';
 export * from './publicShop';
 export * from './reservation';
+export * from './statistics';
 export * from './ticket';

package/src/dto/statistics/StatisticsBuyersOverviewDto.ts

@@ -0,0 +1,69 @@
+import { dto } from '@basmilius/http-client';
+import type { CostDto, StatisticsTrendDto } from '#data/dto';
+
+@dto
+export class StatisticsBuyersOverviewDto {
+    get buyers(): StatisticsTrendDto<number> {
+        return this.#buyers;
+    }
+
+    set buyers(value: StatisticsTrendDto<number>) {
+        this.#buyers = value;
+    }
+
+    get newBuyers(): StatisticsTrendDto<number> {
+        return this.#newBuyers;
+    }
+
+    set newBuyers(value: StatisticsTrendDto<number>) {
+        this.#newBuyers = value;
+    }
+
+    get retentionRate(): StatisticsTrendDto<number> {
+        return this.#retentionRate;
+    }
+
+    set retentionRate(value: StatisticsTrendDto<number>) {
+        this.#retentionRate = value;
+    }
+
+    get totalBuyers(): number {
+        return this.#totalBuyers;
+    }
+
+    set totalBuyers(value: number) {
+        this.#totalBuyers = value;
+    }
+
+    get lifetimeValuePerBuyer(): CostDto {
+        return this.#lifetimeValuePerBuyer;
+    }
+
+    set lifetimeValuePerBuyer(value: CostDto) {
+        this.#lifetimeValuePerBuyer = value;
+    }
+
+    get averageTicketsPerBuyer(): number {
+        return this.#averageTicketsPerBuyer;
+    }
+
+    set averageTicketsPerBuyer(value: number) {
+        this.#averageTicketsPerBuyer = value;
+    }
+
+    #buyers: StatisticsTrendDto<number>;
+    #newBuyers: StatisticsTrendDto<number>;
+    #retentionRate: StatisticsTrendDto<number>;
+    #totalBuyers: number;
+    #lifetimeValuePerBuyer: CostDto;
+    #averageTicketsPerBuyer: number;
+
+    constructor(buyers: StatisticsTrendDto<number>, newBuyers: StatisticsTrendDto<number>, retentionRate: StatisticsTrendDto<number>, totalBuyers: number, lifetimeValuePerBuyer: CostDto, averageTicketsPerBuyer: number) {
+        this.#buyers = buyers;
+        this.#newBuyers = newBuyers;
+        this.#retentionRate = retentionRate;
+        this.#totalBuyers = totalBuyers;
+        this.#lifetimeValuePerBuyer = lifetimeValuePerBuyer;
+        this.#averageTicketsPerBuyer = averageTicketsPerBuyer;
+    }
+}

package/src/dto/statistics/StatisticsBuyersRankedDto.ts

@@ -0,0 +1,69 @@
+import { dto } from '@basmilius/http-client';
+import { type BuyerDto, type CostDto } from '#data/dto';
+
+@dto
+export class StatisticsBuyersRankedDto {
+    get ranking(): number {
+        return this.#ranking;
+    }
+
+    set ranking(value: number) {
+        this.#ranking = value;
+    }
+
+    get buyer(): BuyerDto {
+        return this.#buyer;
+    }
+
+    set buyer(value: BuyerDto) {
+        this.#buyer = value;
+    }
+
+    get orderCount(): number {
+        return this.#orderCount;
+    }
+
+    set orderCount(value: number) {
+        this.#orderCount = value;
+    }
+
+    get totalSpend(): CostDto {
+        return this.#totalSpend;
+    }
+
+    set totalSpend(value: CostDto) {
+        this.#totalSpend = value;
+    }
+
+    get eventsAttended(): number {
+        return this.#eventsAttended;
+    }
+
+    set eventsAttended(value: number) {
+        this.#eventsAttended = value;
+    }
+
+    get averageOrderValue(): CostDto {
+        return this.#averageOrderValue;
+    }
+
+    set averageOrderValue(value: CostDto) {
+        this.#averageOrderValue = value;
+    }
+
+    #ranking: number;
+    #buyer: BuyerDto;
+    #orderCount: number;
+    #totalSpend: CostDto;
+    #eventsAttended: number;
+    #averageOrderValue: CostDto;
+
+    constructor(ranking: number, buyer: BuyerDto, orderCount: number, totalSpend: CostDto, eventsAttended: number, averageOrderValue: CostDto) {
+        this.#ranking = ranking;
+        this.#buyer = buyer;
+        this.#orderCount = orderCount;
+        this.#totalSpend = totalSpend;
+        this.#eventsAttended = eventsAttended;
+        this.#averageOrderValue = averageOrderValue;
+    }
+}