ztechno_core 0.0.105 → 0.0.108

package/lib/mollie/services/mollie_service.d.ts

@@ -0,0 +1,42 @@
+import { Payment, PaymentStatus, Locale, Customer, Subscription, SubscriptionCreateParams } from '@mollie/api-client';
+import { ZSQLService } from '../../core';
+import { RecoveryStats } from '../types/mollie_types';
+export declare class MollieService {
+  private opt;
+  protected key: string;
+  readonly webhookUrl: string;
+  constructor(opt: {
+    sqlService: ZSQLService;
+    env: 'PROD' | 'DEV';
+    apiKeyLive?: string;
+    apiKeyTest?: string;
+    webhookUrl: string;
+  });
+  private get client();
+  resetDatabase(options?: { dryRun?: boolean }): Promise<{
+    dryRun: boolean;
+    deleted: Record<string, number>;
+  }>;
+  recoverFromMollie(options?: { dryRun?: boolean }): Promise<RecoveryStats>;
+  createCustomer(payload: {
+    name: string;
+    email: string;
+    locale?: Locale;
+    metadata?: Record<string, any>;
+  }): Promise<Customer>;
+  getCustomer(customerId: string): Promise<Customer>;
+  createSubscription(
+    input: SubscriptionCreateParams & {
+      customerId: string;
+    },
+  ): Promise<Subscription>;
+  getSubscription(customerId: string, subscriptionId: string): Promise<Subscription>;
+  cancelSubscription(customerId: string, subscriptionId: string): Promise<Subscription>;
+  getPayment(id: string): Promise<Payment>;
+  listPayments(opt?: {
+    limit?: number;
+    profileId?: string;
+    customerId?: string;
+  }): Promise<import('@mollie/api-client').Page<Payment>>;
+  mapPaymentStatus(status: PaymentStatus): 'pending' | 'paid' | 'failed' | 'canceled' | 'expired' | 'refunded';
+}

package/lib/mollie/services/mollie_service.js

@@ -0,0 +1,370 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.MollieService = void 0;
+const api_client_1 = require('@mollie/api-client');
+const customers_orm_1 = require('../orm/customers_orm');
+const invoice_payments_orm_1 = require('../orm/invoice_payments_orm');
+const invoices_orm_1 = require('../orm/invoices_orm');
+const subscriptions_orm_1 = require('../orm/subscriptions_orm');
+const orm_1 = require('../../core/orm/orm');
+const invoice_items_orm_1 = require('../orm/invoice_items_orm');
+const subscription_items_orm_1 = require('../orm/subscription_items_orm');
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class MollieService {
+  constructor(opt) {
+    this.opt = opt;
+    this.webhookUrl = opt.webhookUrl;
+    switch (opt.env) {
+      case 'PROD':
+        if (!opt.apiKeyLive) {
+          throw new Error('MollieService is missing MOLLIE_LIVE_KEY');
+        }
+        this.key = opt.apiKeyLive;
+        break;
+      case 'DEV':
+        if (!opt.apiKeyTest) {
+          throw new Error('MollieService is missing MOLLIE_TEST_KEY');
+        }
+        this.key = opt.apiKeyTest;
+        break;
+    }
+  }
+  get client() {
+    const apiKey = this.key;
+    if (!apiKey || apiKey === '') {
+      throw new Error('MOLLIE_LIVE_KEY or MOLLIE_TEST_KEY is missing');
+    }
+    return (0, api_client_1.createMollieClient)({ apiKey });
+  }
+  async resetDatabase(options) {
+    const customersOrm = new customers_orm_1.CustomersOrm({ sqlService: this.opt.sqlService });
+    const subscriptionsOrm = new subscriptions_orm_1.SubscriptionsOrm({ sqlService: this.opt.sqlService });
+    const subscriptionItemsOrm = new subscription_items_orm_1.SubscriptionItemsOrm({ sqlService: this.opt.sqlService });
+    const invoicesOrm = new invoices_orm_1.InvoicesOrm({ sqlService: this.opt.sqlService });
+    const invoiceItemsOrm = new invoice_items_orm_1.InvoiceItemsOrm({ sqlService: this.opt.sqlService });
+    const paymentsOrm = new invoice_payments_orm_1.InvoicePaymentsOrm({ sqlService: this.opt.sqlService });
+    // Child tables first, then parent tables (respect FK ordering)
+    const orms = [invoiceItemsOrm, paymentsOrm, invoicesOrm, subscriptionItemsOrm, subscriptionsOrm, customersOrm];
+    if (options?.dryRun) {
+      const counts = {};
+      for (const orm of orms) {
+        const rows = await this.opt.sqlService.exec({
+          query: `SELECT COUNT(*) AS cnt FROM \`${orm.alias}\``,
+        });
+        counts[orm.alias] = rows[0]?.cnt ?? 0;
+      }
+      return { dryRun: true, deleted: counts };
+    }
+    return await this.opt.sqlService.transaction(async (trx) => {
+      const deleted = {};
+      trx.query('SET FOREIGN_KEY_CHECKS = 0');
+      for (const orm of orms) {
+        const res = await trx.query(`DELETE FROM \`${orm.alias}\``);
+        deleted[orm.alias] = res?.affectedRows ?? 0;
+      }
+      await trx.query('SET FOREIGN_KEY_CHECKS = 1');
+      return { dryRun: false, deleted };
+    });
+  }
+  async recoverFromMollie(options) {
+    const dryRun = options?.dryRun ?? false;
+    const mollie = this.client;
+    const startedAt = new Date();
+    const customersOrm = new customers_orm_1.CustomersOrm({ sqlService: this.opt.sqlService });
+    const subscriptionsOrm = new subscriptions_orm_1.SubscriptionsOrm({ sqlService: this.opt.sqlService });
+    const subscriptionItemsOrm = new subscription_items_orm_1.SubscriptionItemsOrm({ sqlService: this.opt.sqlService });
+    const invoicesOrm = new invoices_orm_1.InvoicesOrm({ sqlService: this.opt.sqlService });
+    const invoiceItemsOrm = new invoice_items_orm_1.InvoiceItemsOrm({ sqlService: this.opt.sqlService });
+    const paymentsOrm = new invoice_payments_orm_1.InvoicePaymentsOrm({ sqlService: this.opt.sqlService });
+    const stats = {
+      dryRun,
+      startedAt: startedAt.toISOString(),
+      durationMs: 0,
+      customers: { recovered: 0, skipped: 0 },
+      subscriptions: { recovered: 0 },
+      invoices: { recovered: 0, skippedExisting: 0 },
+      payments: { recovered: 0, skippedNoCustomer: 0 },
+      errors: [],
+    };
+    // 1. Recover customers
+    const allCustomers = [];
+    let customerPage = await mollie.customers.page();
+    while (customerPage.length > 0) {
+      for (const mc of customerPage) {
+        try {
+          // Re-run safety: check if local record has richer data
+          const existing = await customersOrm.findByMollieCustomerId(mc.id);
+          if (existing) {
+            const hasLocalData = existing.company || existing.phone || existing.address_line1 || existing.btw_nummer;
+            if (hasLocalData) {
+              // Only update Mollie-exclusive fields, don't blank out local data
+              if (!dryRun) {
+                await customersOrm.update(existing.id, {
+                  name: mc.name ?? existing.name,
+                  email: mc.email ?? existing.email,
+                  locale: mc.locale ?? existing.locale,
+                  metadata: mc.metadata ?? existing.metadata,
+                });
+              }
+              allCustomers.push({ mollieId: mc.id, localId: existing.id });
+              stats.customers.skipped++;
+              continue;
+            }
+          }
+          if (!dryRun) {
+            // Extract customer details from Mollie metadata
+            const meta = mc.metadata ?? {};
+            await customersOrm.create({
+              mollie_customer_id: mc.id,
+              email: mc.email ?? '',
+              name: mc.name ?? '',
+              company: meta.company ?? null,
+              phone: meta.phone ?? null,
+              btw_nummer: meta.btw_nummer ?? null,
+              address_line1: meta.address_line1 ?? null,
+              address_line2: meta.address_line2 ?? null,
+              postal_code: meta.postal_code ?? null,
+              city: meta.city ?? null,
+              country: meta.country ?? null,
+              locale: mc.locale ?? null,
+              metadata: mc.metadata ?? null,
+            });
+          }
+          const local = dryRun ? existing : await customersOrm.findByEmail(mc.email ?? '');
+          if (local) {
+            allCustomers.push({ mollieId: mc.id, localId: local.id });
+          }
+          stats.customers.recovered++;
+        } catch (err) {
+          stats.errors.push({ entity: 'customer', mollieId: mc.id, error: err?.message ?? String(err) });
+        }
+      }
+      if (customerPage.nextPageCursor) {
+        await sleep(100);
+        customerPage = await mollie.customers.page({ from: customerPage.nextPageCursor });
+      } else break;
+    }
+    // 2. Recover subscriptions per customer
+    for (const { mollieId, localId } of allCustomers) {
+      let subPage = await mollie.customerSubscriptions.page({ customerId: mollieId });
+      while (subPage.length > 0) {
+        for (const ms of subPage) {
+          try {
+            if (!dryRun) {
+              await subscriptionsOrm.create({
+                customer_id: localId,
+                mollie_customer_id: mollieId,
+                mollie_subscription_id: ms.id,
+                status: ms.status,
+                interval: ms.interval,
+                description: ms.description ?? null,
+                amount: Number(ms.amount.value),
+                currency: ms.amount.currency,
+                mandate_id: ms.mandateId ?? null,
+                next_payment_date: (0, orm_1.toDatetime)(ms.nextPaymentDate) ?? null,
+                canceled_at: (0, orm_1.toDatetime)(ms.canceledAt) ?? null,
+                metadata: ms.metadata ?? null,
+              });
+              // Recover subscription items from metadata
+              const subMeta = ms.metadata ?? {};
+              if (Array.isArray(subMeta.items) && subMeta.items.length > 0) {
+                const localSub = await subscriptionsOrm.findByMollieSubscriptionId(ms.id);
+                if (localSub) {
+                  const existingItems = await subscriptionItemsOrm.findBySubscription(localSub.id);
+                  if (existingItems.length === 0) {
+                    await subscriptionItemsOrm.bulkInsert(
+                      subMeta.items.map((it, idx) => {
+                        const unitPrice = Number(it.u);
+                        const quantity = Number(it.q);
+                        const vatRate = Number(it.v ?? 0);
+                        const totalExVat = Number((unitPrice * quantity).toFixed(2));
+                        const totalIncVat = Number((totalExVat * (1 + vatRate / 100)).toFixed(2));
+                        return {
+                          subscription_id: localSub.id,
+                          description: it.d,
+                          quantity,
+                          unit_price: unitPrice,
+                          vat_rate: vatRate,
+                          total_ex_vat: totalExVat,
+                          total_inc_vat: totalIncVat,
+                          sort_order: idx,
+                        };
+                      }),
+                    );
+                  }
+                }
+              }
+            }
+            stats.subscriptions.recovered++;
+          } catch (err) {
+            stats.errors.push({ entity: 'subscription', mollieId: ms.id, error: err?.message ?? String(err) });
+          }
+        }
+        if (subPage.nextPageCursor) {
+          await sleep(100);
+          subPage = await mollie.customerSubscriptions.page({ customerId: mollieId, from: subPage.nextPageCursor });
+        } else break;
+      }
+    }
+    // 3. Recover payments → create skeleton invoices
+    let payPage = await mollie.payments.page({ limit: 250 });
+    while (payPage.length > 0) {
+      for (const mp of payPage) {
+        try {
+          const meta = mp.metadata ?? {};
+          const customerId = allCustomers.find((c) => c.mollieId === mp.customerId)?.localId;
+          if (!customerId) {
+            stats.payments.skippedNoCustomer++;
+            continue;
+          }
+          // Improved invoice numbering: use metadata or REC-YYYY-paymentId
+          const createdYear = mp.createdAt ? new Date(mp.createdAt).getFullYear() : new Date().getFullYear();
+          const invoiceNumber = meta.invoice_number ?? `REC-${createdYear}-${mp.id}`;
+          // Group payments: check if invoice already exists before creating
+          let invoice = await invoicesOrm.findByInvoiceNumber(invoiceNumber);
+          if (invoice) {
+            stats.invoices.skippedExisting++;
+          } else {
+            // Use mapPaymentStatus for correct status mapping
+            const mappedStatus = this.mapPaymentStatus(mp.status);
+            // Link to subscription if available
+            let subscriptionId = null;
+            const mollieSubId = mp.subscriptionId ?? null;
+            if (mollieSubId) {
+              const localSub = await subscriptionsOrm.findByMollieSubscriptionId(mollieSubId);
+              if (localSub) subscriptionId = localSub.id;
+            }
+            if (!dryRun) {
+              await invoicesOrm.create({
+                invoice_number: invoiceNumber,
+                customer_id: customerId,
+                subscription_id: subscriptionId,
+                subscription_period_start: null,
+                subscription_period_end: null,
+                mollie_customer_id: mp.customerId ?? null,
+                mollie_payment_id: mp.id,
+                pay_token_hash: null,
+                pay_token_expires_at: null,
+                pay_token_finalized_at: null,
+                status: mappedStatus,
+                amount_due: Number(mp.amount.value),
+                amount_paid: mappedStatus === 'paid' ? Number(mp.amount.value) : 0,
+                currency: mp.amount.currency,
+                description: mp.description ?? null,
+                payment_terms: meta.payment_terms ?? null,
+                due_date: meta.due_date ?? null,
+                issued_at: (0, orm_1.toDatetime)(mp.createdAt) ?? null,
+                paid_at: (0, orm_1.toDatetime)(mp.paidAt) ?? null,
+                checkout_url: mp._links?.checkout?.href ?? null,
+                metadata: mp.metadata ?? null,
+              });
+              invoice = await invoicesOrm.findByInvoiceNumber(invoiceNumber);
+              // Recover invoice line items from payment metadata
+              if (invoice && Array.isArray(meta.items) && meta.items.length > 0) {
+                await invoiceItemsOrm.bulkInsert(
+                  meta.items.map((it, idx) => {
+                    const unitPrice = Number(it.u);
+                    const quantity = Number(it.q);
+                    const vatRate = Number(it.v ?? 0);
+                    const totalExVat = Number((unitPrice * quantity).toFixed(2));
+                    const totalIncVat = Number((totalExVat * (1 + vatRate / 100)).toFixed(2));
+                    return {
+                      invoice_id: invoice.id,
+                      item_type: it.t ?? 'service',
+                      description: it.d,
+                      quantity,
+                      unit_price: unitPrice,
+                      vat_rate: vatRate,
+                      total_ex_vat: totalExVat,
+                      total_inc_vat: totalIncVat,
+                      sort_order: idx,
+                    };
+                  }),
+                );
+              }
+            }
+            stats.invoices.recovered++;
+          }
+          if (invoice && !dryRun) {
+            await paymentsOrm.upsert({
+              invoice_id: invoice.id,
+              mollie_payment_id: mp.id,
+              status: mp.status,
+              sequence_type: mp.sequenceType ?? null,
+              mollie_subscription_id: mp.subscriptionId ?? null,
+              method: mp.method ?? null,
+              amount: Number(mp.amount.value),
+              currency: mp.amount.currency,
+              checkout_url: mp._links?.checkout?.href ?? null,
+              paid_at: (0, orm_1.toDatetime)(mp.paidAt) ?? null,
+              expires_at: (0, orm_1.toDatetime)(mp.expiresAt) ?? null,
+              mandate_id: mp.mandateId ?? null,
+            });
+          }
+          stats.payments.recovered++;
+        } catch (err) {
+          stats.errors.push({ entity: 'payment', mollieId: mp.id, error: err?.message ?? String(err) });
+        }
+      }
+      if (payPage.nextPageCursor) {
+        await sleep(100);
+        payPage = await mollie.payments.page({ from: payPage.nextPageCursor });
+      } else break;
+    }
+    stats.durationMs = Date.now() - startedAt.getTime();
+    console.log(
+      `[Recovery] ${dryRun ? 'DRY RUN' : 'COMPLETE'} — ` +
+        `customers: ${stats.customers.recovered} recovered / ${stats.customers.skipped} skipped, ` +
+        `subscriptions: ${stats.subscriptions.recovered}, ` +
+        `invoices: ${stats.invoices.recovered} recovered / ${stats.invoices.skippedExisting} existing, ` +
+        `payments: ${stats.payments.recovered} recovered / ${stats.payments.skippedNoCustomer} skipped (no customer), ` +
+        `errors: ${stats.errors.length}, ` +
+        `duration: ${stats.durationMs}ms`,
+    );
+    return stats;
+  }
+  async createCustomer(payload) {
+    return await this.client.customers.create(payload);
+  }
+  async getCustomer(customerId) {
+    return await this.client.customers.get(customerId);
+  }
+  /** @internal */
+  async createPayment(input) {
+    return await this.client.payments.create({
+      ...input,
+      sequenceType: input.sequenceType ?? 'oneoff',
+      mandateId: input.mandateId ?? undefined,
+    });
+  }
+  async createSubscription(input) {
+    return await this.client.customerSubscriptions.create(input);
+  }
+  async getSubscription(customerId, subscriptionId) {
+    return await this.client.customerSubscriptions.get(subscriptionId, { customerId });
+  }
+  async cancelSubscription(customerId, subscriptionId) {
+    return await this.client.customerSubscriptions.cancel(subscriptionId, { customerId });
+  }
+  async getPayment(id) {
+    return await this.client.payments.get(id);
+  }
+  async listPayments(opt) {
+    return await this.client.payments.page({ limit: opt?.limit ?? 250 });
+  }
+  mapPaymentStatus(status) {
+    switch (status) {
+      case 'paid':
+        return 'paid';
+      case 'failed':
+        return 'failed';
+      case 'canceled':
+        return 'canceled';
+      case 'expired':
+        return 'expired';
+      default:
+        return 'pending';
+    }
+  }
+}
+exports.MollieService = MollieService;

package/lib/mollie/services/subscription_service.d.ts

@@ -0,0 +1,32 @@
+import { ZSQLService } from '../../core';
+import { ZSubscription, CreateSubscriptionInput, ZSubscriptionItem } from '../types/mollie_types';
+import { CustomerService } from './customer_service';
+import { InvoiceService } from './invoice_service';
+import { MollieService } from './mollie_service';
+export declare class SubscriptionService {
+  private opt;
+  private subscriptionsOrm;
+  private itemsOrm;
+  constructor(opt: {
+    sqlService: ZSQLService;
+    mollieService: MollieService;
+    customerService: CustomerService;
+    invoiceService: InvoiceService;
+  });
+  autoInit(): Promise<void>;
+  private calcTotals;
+  list(): Promise<ZSubscription[]>;
+  get(id: number): Promise<{
+    subscription: ZSubscription;
+    items: ZSubscriptionItem[];
+  }>;
+  createSubscription(input: CreateSubscriptionInput): Promise<{
+    subscription: ZSubscription;
+    invoice: import('../types/mollie_types').ZInvoice;
+    payUrl: string;
+    payTokenExpiresAt: string;
+    checkoutUrl: string;
+  }>;
+  cancelSubscription(id: number): Promise<ZSubscription>;
+  getNextStartDate(interval: string, baseDate?: Date): string;
+}

package/lib/mollie/services/subscription_service.js

@@ -0,0 +1,134 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.SubscriptionService = void 0;
+const orm_1 = require('../../core/orm/orm');
+const subscription_items_orm_1 = require('../orm/subscription_items_orm');
+const subscriptions_orm_1 = require('../orm/subscriptions_orm');
+const subscription_utils_1 = require('../util/subscription_utils');
+class SubscriptionService {
+  constructor(opt) {
+    this.opt = opt;
+    this.subscriptionsOrm = new subscriptions_orm_1.SubscriptionsOrm({ sqlService: this.opt.sqlService });
+    this.itemsOrm = new subscription_items_orm_1.SubscriptionItemsOrm({ sqlService: this.opt.sqlService });
+  }
+  async autoInit() {
+    await this.subscriptionsOrm.ensureTableExists();
+    await this.itemsOrm.ensureTableExists();
+  }
+  calcTotals(items) {
+    let amount_due = 0;
+    const mapped = items.map((item, idx) => {
+      const total_ex_vat = Number(item.quantity) * Number(item.unit_price);
+      const total_inc_vat = total_ex_vat * (1 + Number(item.vat_rate || 0) / 100);
+      amount_due += total_inc_vat;
+      return {
+        subscription_id: 0,
+        description: item.description,
+        quantity: Number(item.quantity),
+        unit_price: Number(item.unit_price),
+        vat_rate: Number(item.vat_rate || 0),
+        total_ex_vat,
+        total_inc_vat,
+        sort_order: item.sort_order ?? idx,
+      };
+    });
+    return { amount_due: Number(amount_due.toFixed(2)), items: mapped };
+  }
+  async list() {
+    return await this.subscriptionsOrm.findAll();
+  }
+  async get(id) {
+    const subscription = await this.subscriptionsOrm.findById(id);
+    if (!subscription) {
+      throw new Error(`Subscription ${id} not found`);
+    }
+    const items = await this.itemsOrm.findBySubscription(subscription.id);
+    return { subscription, items };
+  }
+  async createSubscription(input) {
+    if (!Array.isArray(input.items) || input.items.length === 0) {
+      throw new Error('Subscription items are required');
+    }
+    const customer = await this.opt.customerService.findById(input.customer_id);
+    if (!customer) {
+      throw new Error(`Customer ${input.customer_id} not found`);
+    }
+    if (!customer.mollie_customer_id) {
+      throw new Error(`Customer ${customer.id} missing mollie_customer_id`);
+    }
+    (0, subscription_utils_1.parseSubscriptionInterval)(input.interval);
+    const { items, amount_due } = this.calcTotals(input.items);
+    const payload = {
+      customer_id: customer.id,
+      mollie_customer_id: customer.mollie_customer_id,
+      mollie_subscription_id: null,
+      status: 'setup_pending',
+      interval: input.interval.trim(),
+      description: input.description ?? null,
+      amount: amount_due,
+      currency: input.currency || 'EUR',
+      mandate_id: null,
+      next_payment_date: null,
+      canceled_at: null,
+      metadata: input.metadata ?? null,
+    };
+    const res = await this.subscriptionsOrm.create(payload);
+    const subscriptionId = res?.insertId;
+    const subscription = subscriptionId
+      ? await this.subscriptionsOrm.findById(subscriptionId)
+      : await this.subscriptionsOrm.findLatestByCustomer(customer.id);
+    if (!subscription) {
+      throw new Error('Failed to persist subscription');
+    }
+    const itemsWithSubscription = items.map((it) => ({ ...it, subscription_id: subscription.id }));
+    await this.itemsOrm.bulkInsert(itemsWithSubscription);
+    const invoiceResult = await this.opt.invoiceService.createInvoiceFromItems(
+      {
+        customer_id: customer.id,
+        description: input.description,
+        currency: input.currency || 'EUR',
+        items: input.items,
+        metadata: input.metadata ?? null,
+      },
+      {
+        subscription_id: subscription.id,
+        issuePayToken: true,
+      },
+    );
+    const payment = await this.opt.invoiceService.createMolliePaymentForInvoice(invoiceResult.invoice, {
+      sequenceType: 'first',
+    });
+    const pay = invoiceResult.pay ?? (await this.opt.invoiceService.ensurePayLink(invoiceResult.invoice.id));
+    const updatedInvoice = await this.opt.invoiceService.getInvoiceById(invoiceResult.invoice.id);
+    return {
+      subscription,
+      invoice: updatedInvoice || invoiceResult.invoice,
+      payUrl: pay.payUrl,
+      payTokenExpiresAt: pay.expiresAt,
+      checkoutUrl: payment?.getCheckoutUrl?.() ?? payment?._links?.checkout?.href ?? null,
+    };
+  }
+  async cancelSubscription(id) {
+    const subscription = await this.subscriptionsOrm.findById(id);
+    if (!subscription) {
+      throw new Error(`Subscription ${id} not found`);
+    }
+    if (subscription.mollie_subscription_id && subscription.mollie_customer_id) {
+      await this.opt.mollieService.cancelSubscription(
+        subscription.mollie_customer_id,
+        subscription.mollie_subscription_id,
+      );
+    }
+    await this.subscriptionsOrm.update(id, {
+      status: 'canceled',
+      canceled_at: (0, orm_1.formatDatetime)(new Date()),
+    });
+    return await this.subscriptionsOrm.findById(id);
+  }
+  getNextStartDate(interval, baseDate) {
+    const parsed = (0, subscription_utils_1.parseSubscriptionInterval)(interval);
+    const start = (0, subscription_utils_1.addSubscriptionInterval)(baseDate ?? new Date(), parsed);
+    return (0, subscription_utils_1.formatDateOnly)(start);
+  }
+}
+exports.SubscriptionService = SubscriptionService;

package/lib/mollie/types/internal_types.d.ts

@@ -0,0 +1,19 @@
+import { Locale, SequenceType } from '@mollie/api-client';
+/**
+ * Internal type for building Mollie API payment requests.
+ * Consumers should use InvoiceService/SubscriptionService instead of calling MollieService.createPayment() directly.
+ */
+export type ZCreatePaymentInput = {
+  amount: {
+    currency: string;
+    value: string;
+  };
+  description: string;
+  redirectUrl: string;
+  webhookUrl: string;
+  customerId?: string;
+  metadata?: Record<string, any>;
+  locale?: Locale;
+  sequenceType?: SequenceType;
+  mandateId?: string;
+};

package/lib/mollie/types/internal_types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });