@forklaunch/implementation-billing-base 0.3.2 → 0.3.3

package/lib/services/index.d.ts

@@ -1,253 +1,247 @@
-import { IdDto, IdsDto } from '@forklaunch/common';
+import { InstanceTypeRecord, IdDto, IdsDto } from '@forklaunch/common';
 import { TtlCache } from '@forklaunch/core/cache';
-import { MetricsDefinition, OpenTelemetryCollector, TelemetryOptions } from '@forklaunch/core/http';
-import { ResponseDtoMapperConstructor, RequestDtoMapperConstructor } from '@forklaunch/core/mappers';
+import { OpenTelemetryCollector, MetricsDefinition, TelemetryOptions } from '@forklaunch/core/http';
 import { BillingPortalService, CheckoutSessionService, PaymentLinkService, PlanService, SubscriptionService } from '@forklaunch/interfaces-billing/interfaces';
 import { BillingPortalDto, CreateBillingPortalDto, UpdateBillingPortalDto, CheckoutSessionDto, CreateCheckoutSessionDto, UpdateCheckoutSessionDto, PaymentLinkDto, CreatePaymentLinkDto, UpdatePaymentLinkDto, PlanDto, CreatePlanDto, UpdatePlanDto, SubscriptionDto, CreateSubscriptionDto, UpdateSubscriptionDto } from '@forklaunch/interfaces-billing/types';
+import { ResponseMapperConstructor, RequestMapperConstructor, InternalMapper } from '@forklaunch/internal';
 import { AnySchemaValidator } from '@forklaunch/validator';
 import { EntityManager } from '@mikro-orm/core';
 
-declare class BaseBillingPortalService<SchemaValidator extends AnySchemaValidator, Metrics extends MetricsDefinition = MetricsDefinition, Dto extends {
-    BillingPortalDtoMapper: BillingPortalDto;
-    CreateBillingPortalDtoMapper: CreateBillingPortalDto;
-    UpdateBillingPortalDtoMapper: UpdateBillingPortalDto;
-} = {
-    BillingPortalDtoMapper: BillingPortalDto;
-    CreateBillingPortalDtoMapper: CreateBillingPortalDto;
-    UpdateBillingPortalDtoMapper: UpdateBillingPortalDto;
-}, Entities extends {
-    BillingPortalDtoMapper: BillingPortalDto;
-    CreateBillingPortalDtoMapper: BillingPortalDto;
-    UpdateBillingPortalDtoMapper: BillingPortalDto;
-} = {
-    BillingPortalDtoMapper: BillingPortalDto;
-    CreateBillingPortalDtoMapper: BillingPortalDto;
-    UpdateBillingPortalDtoMapper: BillingPortalDto;
-}> implements BillingPortalService {
-    #private;
+type BaseBillingDtos = {
+    BillingPortalMapper: BillingPortalDto;
+    CreateBillingPortalMapper: CreateBillingPortalDto;
+    UpdateBillingPortalMapper: UpdateBillingPortalDto;
+};
+type BaseCheckoutSessionDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum> = {
+    CheckoutSessionMapper: CheckoutSessionDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+    CreateCheckoutSessionMapper: CreateCheckoutSessionDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+    UpdateCheckoutSessionMapper: UpdateCheckoutSessionDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+};
+type BasePaymentLinkDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum> = {
+    PaymentLinkMapper: PaymentLinkDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+    CreatePaymentLinkMapper: CreatePaymentLinkDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+    UpdatePaymentLinkMapper: UpdatePaymentLinkDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+};
+type BasePlanDtos<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum> = {
+    PlanMapper: PlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>;
+    CreatePlanMapper: CreatePlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>;
+    UpdatePlanMapper: UpdatePlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>;
+};
+type BaseSubscriptionDtos<PartyType, BillingProviderType> = {
+    SubscriptionMapper: SubscriptionDto<PartyType, BillingProviderType>;
+    CreateSubscriptionMapper: CreateSubscriptionDto<PartyType, BillingProviderType>;
+    UpdateSubscriptionMapper: UpdateSubscriptionDto<PartyType, BillingProviderType>;
+};
+
+type BaseBillingEntities = {
+    BillingPortalMapper: BillingPortalDto;
+    CreateBillingPortalMapper: BillingPortalDto;
+    UpdateBillingPortalMapper: BillingPortalDto;
+};
+type BaseCheckoutSessionEntities<PaymentMethodEnum, CurrencyEnum, StatusEnum> = {
+    CheckoutSessionMapper: CheckoutSessionDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+    CreateCheckoutSessionMapper: CheckoutSessionDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+    UpdateCheckoutSessionMapper: CheckoutSessionDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+};
+type BasePaymentLinkEntities<PaymentMethodEnum, CurrencyEnum, StatusEnum> = {
+    PaymentLinkMapper: PaymentLinkDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+    CreatePaymentLinkMapper: PaymentLinkDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+    UpdatePaymentLinkMapper: PaymentLinkDto<PaymentMethodEnum, CurrencyEnum, StatusEnum>;
+};
+type BasePlanEntities<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum> = {
+    PlanMapper: PlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>;
+    CreatePlanMapper: PlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>;
+    UpdatePlanMapper: PlanDto<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>;
+};
+type BaseSubscriptionEntities<PartyType, BillingProviderType> = {
+    SubscriptionMapper: SubscriptionDto<PartyType, BillingProviderType>;
+    CreateSubscriptionMapper: SubscriptionDto<PartyType, BillingProviderType>;
+    UpdateSubscriptionMapper: SubscriptionDto<PartyType, BillingProviderType>;
+};
+
+declare class BaseBillingPortalService<SchemaValidator extends AnySchemaValidator, Entities extends BaseBillingEntities, Dto extends BaseBillingDtos = BaseBillingDtos> implements BillingPortalService {
     protected em: EntityManager;
     protected cache: TtlCache;
-    protected openTelemetryCollector: OpenTelemetryCollector<Metrics>;
+    protected openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
     protected schemaValidator: SchemaValidator;
     protected mappers: {
-        BillingPortalDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['BillingPortalDtoMapper'], Entities['BillingPortalDtoMapper']>;
-        CreateBillingPortalDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreateBillingPortalDtoMapper'], Entities['CreateBillingPortalDtoMapper']>;
-        UpdateBillingPortalDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdateBillingPortalDtoMapper'], Entities['UpdateBillingPortalDtoMapper']>;
+        BillingPortalMapper: ResponseMapperConstructor<SchemaValidator, Dto['BillingPortalMapper'], Entities['BillingPortalMapper']>;
+        CreateBillingPortalMapper: RequestMapperConstructor<SchemaValidator, Dto['CreateBillingPortalMapper'], Entities['CreateBillingPortalMapper'], (dto: Dto['CreateBillingPortalMapper'], em: EntityManager) => Promise<Entities['CreateBillingPortalMapper']>>;
+        UpdateBillingPortalMapper: RequestMapperConstructor<SchemaValidator, Dto['UpdateBillingPortalMapper'], Entities['UpdateBillingPortalMapper'], (dto: Dto['UpdateBillingPortalMapper'], em: EntityManager) => Promise<Entities['UpdateBillingPortalMapper']>>;
     };
     readonly options?: {
         telemetry?: TelemetryOptions;
         enableDatabaseBackup?: boolean;
     } | undefined;
-    private evaluatedTelemetryOptions;
-    private enableDatabaseBackup;
-    constructor(em: EntityManager, cache: TtlCache, openTelemetryCollector: OpenTelemetryCollector<Metrics>, schemaValidator: SchemaValidator, mappers: {
-        BillingPortalDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['BillingPortalDtoMapper'], Entities['BillingPortalDtoMapper']>;
-        CreateBillingPortalDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreateBillingPortalDtoMapper'], Entities['CreateBillingPortalDtoMapper']>;
-        UpdateBillingPortalDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdateBillingPortalDtoMapper'], Entities['UpdateBillingPortalDtoMapper']>;
+    protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+    protected evaluatedTelemetryOptions: {
+        logging?: boolean;
+        metrics?: boolean;
+        tracing?: boolean;
+    };
+    protected enableDatabaseBackup: boolean;
+    constructor(em: EntityManager, cache: TtlCache, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, schemaValidator: SchemaValidator, mappers: {
+        BillingPortalMapper: ResponseMapperConstructor<SchemaValidator, Dto['BillingPortalMapper'], Entities['BillingPortalMapper']>;
+        CreateBillingPortalMapper: RequestMapperConstructor<SchemaValidator, Dto['CreateBillingPortalMapper'], Entities['CreateBillingPortalMapper'], (dto: Dto['CreateBillingPortalMapper'], em: EntityManager) => Promise<Entities['CreateBillingPortalMapper']>>;
+        UpdateBillingPortalMapper: RequestMapperConstructor<SchemaValidator, Dto['UpdateBillingPortalMapper'], Entities['UpdateBillingPortalMapper'], (dto: Dto['UpdateBillingPortalMapper'], em: EntityManager) => Promise<Entities['UpdateBillingPortalMapper']>>;
     }, options?: {
         telemetry?: TelemetryOptions;
         enableDatabaseBackup?: boolean;
     } | undefined);
     protected createCacheKey: (id: string) => string;
-    createBillingPortalSession(billingPortalDto: Dto['CreateBillingPortalDtoMapper']): Promise<Dto['BillingPortalDtoMapper']>;
-    getBillingPortalSession(idDto: IdDto): Promise<Dto['BillingPortalDtoMapper']>;
-    updateBillingPortalSession(billingPortalDto: UpdateBillingPortalDto): Promise<Dto['BillingPortalDtoMapper']>;
+    createBillingPortalSession(billingPortalDto: Dto['CreateBillingPortalMapper']): Promise<Dto['BillingPortalMapper']>;
+    getBillingPortalSession(idDto: IdDto): Promise<Dto['BillingPortalMapper']>;
+    updateBillingPortalSession(billingPortalDto: UpdateBillingPortalDto): Promise<Dto['BillingPortalMapper']>;
     expireBillingPortalSession(idDto: IdDto): Promise<void>;
 }
 
-declare class BaseCheckoutSessionService<SchemaValidator extends AnySchemaValidator, PaymentMethodEnum, StatusEnum, Metrics extends MetricsDefinition = MetricsDefinition, Dto extends {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    CreateCheckoutSessionDtoMapper: CreateCheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    UpdateCheckoutSessionDtoMapper: UpdateCheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-} = {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    CreateCheckoutSessionDtoMapper: CreateCheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    UpdateCheckoutSessionDtoMapper: UpdateCheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-}, Entities extends {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    CreateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    UpdateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-} = {
-    CheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    CreateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-    UpdateCheckoutSessionDtoMapper: CheckoutSessionDto<PaymentMethodEnum, StatusEnum>;
-}> implements CheckoutSessionService<PaymentMethodEnum, StatusEnum> {
-    #private;
+declare class BaseCheckoutSessionService<SchemaValidator extends AnySchemaValidator, PaymentMethodEnum, CurrencyEnum, StatusEnum, Entities extends BaseCheckoutSessionEntities<PaymentMethodEnum, CurrencyEnum, StatusEnum>, Dto extends BaseCheckoutSessionDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum> = BaseCheckoutSessionDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum>> implements CheckoutSessionService<PaymentMethodEnum, CurrencyEnum, StatusEnum> {
     protected readonly em: EntityManager;
     protected readonly cache: TtlCache;
-    protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>;
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
     protected readonly schemaValidator: SchemaValidator;
     protected readonly mappers: {
-        CheckoutSessionDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['CheckoutSessionDtoMapper'], Entities['CheckoutSessionDtoMapper']>;
-        CreateCheckoutSessionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreateCheckoutSessionDtoMapper'], Entities['CreateCheckoutSessionDtoMapper']>;
-        UpdateCheckoutSessionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdateCheckoutSessionDtoMapper'], Entities['UpdateCheckoutSessionDtoMapper']>;
+        CheckoutSessionMapper: ResponseMapperConstructor<SchemaValidator, Dto['CheckoutSessionMapper'], Entities['CheckoutSessionMapper']>;
+        CreateCheckoutSessionMapper: RequestMapperConstructor<SchemaValidator, Dto['CreateCheckoutSessionMapper'], Entities['CreateCheckoutSessionMapper'], (dto: Dto['CreateCheckoutSessionMapper'], em: EntityManager) => Promise<Entities['CreateCheckoutSessionMapper']>>;
+        UpdateCheckoutSessionMapper: RequestMapperConstructor<SchemaValidator, Dto['UpdateCheckoutSessionMapper'], Entities['UpdateCheckoutSessionMapper'], (dto: Dto['UpdateCheckoutSessionMapper'], em: EntityManager) => Promise<Entities['UpdateCheckoutSessionMapper']>>;
     };
     readonly options?: {
         enableDatabaseBackup?: boolean;
         telemetry?: TelemetryOptions;
     } | undefined;
-    private evaluatedTelemetryOptions;
-    private enableDatabaseBackup;
-    constructor(em: EntityManager, cache: TtlCache, openTelemetryCollector: OpenTelemetryCollector<Metrics>, schemaValidator: SchemaValidator, mappers: {
-        CheckoutSessionDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['CheckoutSessionDtoMapper'], Entities['CheckoutSessionDtoMapper']>;
-        CreateCheckoutSessionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreateCheckoutSessionDtoMapper'], Entities['CreateCheckoutSessionDtoMapper']>;
-        UpdateCheckoutSessionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdateCheckoutSessionDtoMapper'], Entities['UpdateCheckoutSessionDtoMapper']>;
+    protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+    protected evaluatedTelemetryOptions: {
+        logging?: boolean;
+        metrics?: boolean;
+        tracing?: boolean;
+    };
+    protected enableDatabaseBackup: boolean;
+    constructor(em: EntityManager, cache: TtlCache, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, schemaValidator: SchemaValidator, mappers: {
+        CheckoutSessionMapper: ResponseMapperConstructor<SchemaValidator, Dto['CheckoutSessionMapper'], Entities['CheckoutSessionMapper']>;
+        CreateCheckoutSessionMapper: RequestMapperConstructor<SchemaValidator, Dto['CreateCheckoutSessionMapper'], Entities['CreateCheckoutSessionMapper'], (dto: Dto['CreateCheckoutSessionMapper'], em: EntityManager) => Promise<Entities['CreateCheckoutSessionMapper']>>;
+        UpdateCheckoutSessionMapper: RequestMapperConstructor<SchemaValidator, Dto['UpdateCheckoutSessionMapper'], Entities['UpdateCheckoutSessionMapper'], (dto: Dto['UpdateCheckoutSessionMapper'], em: EntityManager) => Promise<Entities['UpdateCheckoutSessionMapper']>>;
     }, options?: {
         enableDatabaseBackup?: boolean;
         telemetry?: TelemetryOptions;
     } | undefined);
     protected createCacheKey: (id: string) => string;
-    createCheckoutSession(checkoutSessionDto: Dto['CreateCheckoutSessionDtoMapper']): Promise<Dto['CheckoutSessionDtoMapper']>;
-    getCheckoutSession({ id }: IdDto): Promise<Dto['CheckoutSessionDtoMapper']>;
+    createCheckoutSession(checkoutSessionDto: Dto['CreateCheckoutSessionMapper']): Promise<Dto['CheckoutSessionMapper']>;
+    getCheckoutSession({ id }: IdDto): Promise<Dto['CheckoutSessionMapper']>;
     expireCheckoutSession({ id }: IdDto): Promise<void>;
     handleCheckoutSuccess({ id }: IdDto): Promise<void>;
     handleCheckoutFailure({ id }: IdDto): Promise<void>;
 }
 
-declare class BasePaymentLinkService<SchemaValidator extends AnySchemaValidator, CurrencyEnum, StatusEnum, Metrics extends MetricsDefinition = MetricsDefinition, Dto extends {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    CreatePaymentLinkDtoMapper: CreatePaymentLinkDto<CurrencyEnum, StatusEnum>;
-    UpdatePaymentLinkDtoMapper: UpdatePaymentLinkDto<CurrencyEnum, StatusEnum>;
-} = {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    CreatePaymentLinkDtoMapper: CreatePaymentLinkDto<CurrencyEnum, StatusEnum>;
-    UpdatePaymentLinkDtoMapper: UpdatePaymentLinkDto<CurrencyEnum, StatusEnum>;
-}, Entities extends {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    CreatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    UpdatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-} = {
-    PaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    CreatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-    UpdatePaymentLinkDtoMapper: PaymentLinkDto<CurrencyEnum, StatusEnum>;
-}> implements PaymentLinkService<CurrencyEnum, StatusEnum> {
-    #private;
+declare class BasePaymentLinkService<SchemaValidator extends AnySchemaValidator, PaymentMethodEnum, CurrencyEnum, StatusEnum, Entities extends BasePaymentLinkEntities<PaymentMethodEnum, CurrencyEnum, StatusEnum>, Dto extends BasePaymentLinkDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum> = BasePaymentLinkDtos<PaymentMethodEnum, CurrencyEnum, StatusEnum>> implements PaymentLinkService<PaymentMethodEnum, CurrencyEnum, StatusEnum> {
     protected readonly em: EntityManager;
     protected readonly cache: TtlCache;
-    protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>;
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
     protected readonly schemaValidator: SchemaValidator;
     protected readonly mappers: {
-        PaymentLinkDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['PaymentLinkDtoMapper'], Entities['PaymentLinkDtoMapper']>;
-        CreatePaymentLinkDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreatePaymentLinkDtoMapper'], Entities['CreatePaymentLinkDtoMapper']>;
-        UpdatePaymentLinkDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdatePaymentLinkDtoMapper'], Entities['UpdatePaymentLinkDtoMapper']>;
+        PaymentLinkMapper: ResponseMapperConstructor<SchemaValidator, Dto['PaymentLinkMapper'], Entities['PaymentLinkMapper']>;
+        CreatePaymentLinkMapper: RequestMapperConstructor<SchemaValidator, Dto['CreatePaymentLinkMapper'], Entities['CreatePaymentLinkMapper'], (dto: Dto['CreatePaymentLinkMapper'], em: EntityManager) => Promise<Entities['CreatePaymentLinkMapper']>>;
+        UpdatePaymentLinkMapper: RequestMapperConstructor<SchemaValidator, Dto['UpdatePaymentLinkMapper'], Entities['UpdatePaymentLinkMapper'], (dto: Dto['UpdatePaymentLinkMapper'], em: EntityManager) => Promise<Entities['UpdatePaymentLinkMapper']>>;
     };
     readonly options?: {
         enableDatabaseBackup?: boolean;
         telemetry?: TelemetryOptions;
     } | undefined;
-    private evaluatedTelemetryOptions;
-    private enableDatabaseBackup;
-    constructor(em: EntityManager, cache: TtlCache, openTelemetryCollector: OpenTelemetryCollector<Metrics>, schemaValidator: SchemaValidator, mappers: {
-        PaymentLinkDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['PaymentLinkDtoMapper'], Entities['PaymentLinkDtoMapper']>;
-        CreatePaymentLinkDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreatePaymentLinkDtoMapper'], Entities['CreatePaymentLinkDtoMapper']>;
-        UpdatePaymentLinkDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdatePaymentLinkDtoMapper'], Entities['UpdatePaymentLinkDtoMapper']>;
+    protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+    protected evaluatedTelemetryOptions: {
+        logging?: boolean;
+        metrics?: boolean;
+        tracing?: boolean;
+    };
+    protected enableDatabaseBackup: boolean;
+    constructor(em: EntityManager, cache: TtlCache, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, schemaValidator: SchemaValidator, mappers: {
+        PaymentLinkMapper: ResponseMapperConstructor<SchemaValidator, Dto['PaymentLinkMapper'], Entities['PaymentLinkMapper']>;
+        CreatePaymentLinkMapper: RequestMapperConstructor<SchemaValidator, Dto['CreatePaymentLinkMapper'], Entities['CreatePaymentLinkMapper'], (dto: Dto['CreatePaymentLinkMapper'], em: EntityManager) => Promise<Entities['CreatePaymentLinkMapper']>>;
+        UpdatePaymentLinkMapper: RequestMapperConstructor<SchemaValidator, Dto['UpdatePaymentLinkMapper'], Entities['UpdatePaymentLinkMapper'], (dto: Dto['UpdatePaymentLinkMapper'], em: EntityManager) => Promise<Entities['UpdatePaymentLinkMapper']>>;
     }, options?: {
         enableDatabaseBackup?: boolean;
         telemetry?: TelemetryOptions;
     } | undefined);
     protected cacheKeyPrefix: string;
     protected createCacheKey: (id: string) => string;
-    createPaymentLink(paymentLinkDto: Dto['CreatePaymentLinkDtoMapper']): Promise<Dto['PaymentLinkDtoMapper']>;
-    updatePaymentLink(paymentLinkDto: Dto['UpdatePaymentLinkDtoMapper']): Promise<Dto['PaymentLinkDtoMapper']>;
-    getPaymentLink({ id }: IdDto): Promise<Dto['PaymentLinkDtoMapper']>;
+    createPaymentLink(paymentLinkDto: Dto['CreatePaymentLinkMapper']): Promise<Dto['PaymentLinkMapper']>;
+    updatePaymentLink(paymentLinkDto: Dto['UpdatePaymentLinkMapper']): Promise<Dto['PaymentLinkMapper']>;
+    getPaymentLink({ id }: IdDto): Promise<Dto['PaymentLinkMapper']>;
     expirePaymentLink({ id }: IdDto): Promise<void>;
     handlePaymentSuccess({ id }: IdDto): Promise<void>;
     handlePaymentFailure({ id }: IdDto): Promise<void>;
-    listPaymentLinks(idsDto?: IdsDto): Promise<Dto['PaymentLinkDtoMapper'][]>;
+    listPaymentLinks(idsDto?: IdsDto): Promise<Dto['PaymentLinkMapper'][]>;
 }
 
-declare class BasePlanService<SchemaValidator extends AnySchemaValidator, PlanCadenceEnum, BillingProviderEnum, Metrics extends MetricsDefinition = MetricsDefinition, Dto extends {
-    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    CreatePlanDtoMapper: CreatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    UpdatePlanDtoMapper: UpdatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
-} = {
-    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    CreatePlanDtoMapper: CreatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    UpdatePlanDtoMapper: UpdatePlanDto<PlanCadenceEnum, BillingProviderEnum>;
-}, Entities extends {
-    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    CreatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    UpdatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-} = {
-    PlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    CreatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-    UpdatePlanDtoMapper: PlanDto<PlanCadenceEnum, BillingProviderEnum>;
-}> implements PlanService<PlanCadenceEnum, BillingProviderEnum> {
-    #private;
-    private em;
-    private readonly openTelemetryCollector;
-    private readonly schemaValidator;
-    private readonly mappers;
+declare class BasePlanService<SchemaValidator extends AnySchemaValidator, PlanCadenceEnum, CurrencyEnum, BillingProviderEnum, Entities extends BasePlanEntities<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>, Dto extends BasePlanDtos<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum> = BasePlanDtos<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum>> implements PlanService<PlanCadenceEnum, CurrencyEnum, BillingProviderEnum> {
+    protected em: EntityManager;
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
+    protected readonly schemaValidator: SchemaValidator;
+    protected readonly mappers: {
+        PlanMapper: ResponseMapperConstructor<SchemaValidator, Dto['PlanMapper'], Entities['PlanMapper']>;
+        CreatePlanMapper: RequestMapperConstructor<SchemaValidator, Dto['CreatePlanMapper'], Entities['CreatePlanMapper'], (dto: Dto['CreatePlanMapper'], em: EntityManager) => Promise<Entities['CreatePlanMapper']>>;
+        UpdatePlanMapper: RequestMapperConstructor<SchemaValidator, Dto['UpdatePlanMapper'], Entities['UpdatePlanMapper'], (dto: Dto['UpdatePlanMapper'], em: EntityManager) => Promise<Entities['UpdatePlanMapper']>>;
+    };
     readonly options?: {
         telemetry?: TelemetryOptions;
     } | undefined;
-    private evaluatedTelemetryOptions;
-    constructor(em: EntityManager, openTelemetryCollector: OpenTelemetryCollector<Metrics>, schemaValidator: SchemaValidator, mappers: {
-        PlanDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['PlanDtoMapper'], Entities['PlanDtoMapper']>;
-        CreatePlanDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreatePlanDtoMapper'], Entities['CreatePlanDtoMapper']>;
-        UpdatePlanDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdatePlanDtoMapper'], Entities['UpdatePlanDtoMapper']>;
+    protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+    protected evaluatedTelemetryOptions: {
+        logging?: boolean;
+        metrics?: boolean;
+        tracing?: boolean;
+    };
+    constructor(em: EntityManager, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, schemaValidator: SchemaValidator, mappers: {
+        PlanMapper: ResponseMapperConstructor<SchemaValidator, Dto['PlanMapper'], Entities['PlanMapper']>;
+        CreatePlanMapper: RequestMapperConstructor<SchemaValidator, Dto['CreatePlanMapper'], Entities['CreatePlanMapper'], (dto: Dto['CreatePlanMapper'], em: EntityManager) => Promise<Entities['CreatePlanMapper']>>;
+        UpdatePlanMapper: RequestMapperConstructor<SchemaValidator, Dto['UpdatePlanMapper'], Entities['UpdatePlanMapper'], (dto: Dto['UpdatePlanMapper'], em: EntityManager) => Promise<Entities['UpdatePlanMapper']>>;
     }, options?: {
         telemetry?: TelemetryOptions;
     } | undefined);
-    listPlans(idsDto?: IdsDto, em?: EntityManager): Promise<Dto['PlanDtoMapper'][]>;
-    createPlan(planDto: Dto['CreatePlanDtoMapper'], em?: EntityManager): Promise<Dto['PlanDtoMapper']>;
-    getPlan(idDto: IdDto, em?: EntityManager): Promise<Dto['PlanDtoMapper']>;
-    updatePlan(planDto: Dto['UpdatePlanDtoMapper'], em?: EntityManager): Promise<Dto['PlanDtoMapper']>;
+    listPlans(idsDto?: IdsDto, em?: EntityManager): Promise<Dto['PlanMapper'][]>;
+    createPlan(planDto: Dto['CreatePlanMapper'], em?: EntityManager): Promise<Dto['PlanMapper']>;
+    getPlan(idDto: IdDto, em?: EntityManager): Promise<Dto['PlanMapper']>;
+    updatePlan(planDto: Dto['UpdatePlanMapper'], em?: EntityManager): Promise<Dto['PlanMapper']>;
     deletePlan(idDto: {
         id: string;
     }, em?: EntityManager): Promise<void>;
 }
 
-declare class BaseSubscriptionService<SchemaValidator extends AnySchemaValidator, PartyType, BillingProviderType, Metrics extends MetricsDefinition = MetricsDefinition, Dto extends {
-    SubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-    CreateSubscriptionDtoMapper: CreateSubscriptionDto<PartyType, BillingProviderType>;
-    UpdateSubscriptionDtoMapper: UpdateSubscriptionDto<PartyType, BillingProviderType>;
-} = {
-    SubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-    CreateSubscriptionDtoMapper: CreateSubscriptionDto<PartyType, BillingProviderType>;
-    UpdateSubscriptionDtoMapper: UpdateSubscriptionDto<PartyType, BillingProviderType>;
-}, Entities extends {
-    SubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-    CreateSubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-    UpdateSubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-} = {
-    SubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-    CreateSubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-    UpdateSubscriptionDtoMapper: SubscriptionDto<PartyType, BillingProviderType>;
-}> implements SubscriptionService<PartyType, BillingProviderType> {
-    #private;
+declare class BaseSubscriptionService<SchemaValidator extends AnySchemaValidator, PartyType, BillingProviderType, Entities extends BaseSubscriptionEntities<PartyType, BillingProviderType>, Dto extends BaseSubscriptionDtos<PartyType, BillingProviderType> = BaseSubscriptionDtos<PartyType, BillingProviderType>> implements SubscriptionService<PartyType, BillingProviderType> {
     protected em: EntityManager;
-    protected readonly openTelemetryCollector: OpenTelemetryCollector<Metrics>;
+    protected readonly openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>;
     protected readonly schemaValidator: SchemaValidator;
     protected readonly mappers: {
-        SubscriptionDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['SubscriptionDtoMapper'], Entities['SubscriptionDtoMapper']>;
-        CreateSubscriptionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreateSubscriptionDtoMapper'], Entities['CreateSubscriptionDtoMapper']>;
-        UpdateSubscriptionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdateSubscriptionDtoMapper'], Entities['UpdateSubscriptionDtoMapper']>;
+        SubscriptionMapper: ResponseMapperConstructor<SchemaValidator, Dto['SubscriptionMapper'], Entities['SubscriptionMapper']>;
+        CreateSubscriptionMapper: RequestMapperConstructor<SchemaValidator, Dto['CreateSubscriptionMapper'], Entities['CreateSubscriptionMapper'], (dto: Dto['CreateSubscriptionMapper'], em: EntityManager) => Promise<Entities['CreateSubscriptionMapper']>>;
+        UpdateSubscriptionMapper: RequestMapperConstructor<SchemaValidator, Dto['UpdateSubscriptionMapper'], Entities['UpdateSubscriptionMapper'], (dto: Dto['UpdateSubscriptionMapper'], em: EntityManager) => Promise<Entities['UpdateSubscriptionMapper']>>;
     };
     readonly options?: {
-        enableDatabaseBackup?: boolean;
         telemetry?: TelemetryOptions;
     } | undefined;
-    private evaluatedTelemetryOptions;
-    constructor(em: EntityManager, openTelemetryCollector: OpenTelemetryCollector<Metrics>, schemaValidator: SchemaValidator, mappers: {
-        SubscriptionDtoMapper: ResponseDtoMapperConstructor<SchemaValidator, Dto['SubscriptionDtoMapper'], Entities['SubscriptionDtoMapper']>;
-        CreateSubscriptionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['CreateSubscriptionDtoMapper'], Entities['CreateSubscriptionDtoMapper']>;
-        UpdateSubscriptionDtoMapper: RequestDtoMapperConstructor<SchemaValidator, Dto['UpdateSubscriptionDtoMapper'], Entities['UpdateSubscriptionDtoMapper']>;
+    protected _mappers: InternalMapper<InstanceTypeRecord<typeof this.mappers>>;
+    protected evaluatedTelemetryOptions: {
+        logging?: boolean;
+        metrics?: boolean;
+        tracing?: boolean;
+    };
+    constructor(em: EntityManager, openTelemetryCollector: OpenTelemetryCollector<MetricsDefinition>, schemaValidator: SchemaValidator, mappers: {
+        SubscriptionMapper: ResponseMapperConstructor<SchemaValidator, Dto['SubscriptionMapper'], Entities['SubscriptionMapper']>;
+        CreateSubscriptionMapper: RequestMapperConstructor<SchemaValidator, Dto['CreateSubscriptionMapper'], Entities['CreateSubscriptionMapper'], (dto: Dto['CreateSubscriptionMapper'], em: EntityManager) => Promise<Entities['CreateSubscriptionMapper']>>;
+        UpdateSubscriptionMapper: RequestMapperConstructor<SchemaValidator, Dto['UpdateSubscriptionMapper'], Entities['UpdateSubscriptionMapper'], (dto: Dto['UpdateSubscriptionMapper'], em: EntityManager) => Promise<Entities['UpdateSubscriptionMapper']>>;
     }, options?: {
-        enableDatabaseBackup?: boolean;
         telemetry?: TelemetryOptions;
     } | undefined);
-    createSubscription(subscriptionDto: Dto['CreateSubscriptionDtoMapper'], em?: EntityManager): Promise<Dto['SubscriptionDtoMapper']>;
-    getSubscription(idDto: IdDto, em?: EntityManager): Promise<Dto['SubscriptionDtoMapper']>;
-    getUserSubscription({ id }: IdDto, em?: EntityManager): Promise<Dto['SubscriptionDtoMapper']>;
-    getOrganizationSubscription({ id }: IdDto, em?: EntityManager): Promise<Dto['SubscriptionDtoMapper']>;
-    updateSubscription(subscriptionDto: Dto['UpdateSubscriptionDtoMapper'], em?: EntityManager): Promise<Dto['SubscriptionDtoMapper']>;
+    createSubscription(subscriptionDto: Dto['CreateSubscriptionMapper'], em?: EntityManager): Promise<Dto['SubscriptionMapper']>;
+    getSubscription(idDto: IdDto, em?: EntityManager): Promise<Dto['SubscriptionMapper']>;
+    getUserSubscription({ id }: IdDto, em?: EntityManager): Promise<Dto['SubscriptionMapper']>;
+    getOrganizationSubscription({ id }: IdDto, em?: EntityManager): Promise<Dto['SubscriptionMapper']>;
+    updateSubscription(subscriptionDto: Dto['UpdateSubscriptionMapper'], em?: EntityManager): Promise<Dto['SubscriptionMapper']>;
     deleteSubscription(idDto: {
         id: string;
     }, em?: EntityManager): Promise<void>;
     listSubscriptions(idsDto: {
         ids?: string[];
-    }, em?: EntityManager): Promise<Dto['SubscriptionDtoMapper'][]>;
+    }, em?: EntityManager): Promise<Dto['SubscriptionMapper'][]>;
     cancelSubscription(idDto: IdDto, em?: EntityManager): Promise<void>;
     resumeSubscription(idDto: IdDto, em?: EntityManager): Promise<void>;
 }