cabloy 5.1.124 → 5.1.126

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/service/refundOperation.ts

@@ -0,0 +1,226 @@
+import type { TableIdentity } from 'table-identity';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { Core } from 'vona-module-a-core';
+
+import type { EntityRefundOperation } from '../entity/refundOperation.tsx';
+import type { IPayProviderRefundSnapshot } from '../types/payment.ts';
+
+export interface IRefundOperationCreateCommand {
+  paymentSessionId: TableIdentity;
+  businessReference: string;
+  amountMinor: number;
+  currency: string;
+  idempotencyKey: string;
+  correlationId: string;
+}
+
+@Service()
+export class ServiceRefundOperation extends BeanBase {
+  @Core.transaction()
+  async create(command: IRefundOperationCreateCommand): Promise<EntityRefundOperation> {
+    if (!Number.isSafeInteger(command.amountMinor) || command.amountMinor <= 0) {
+      this.app.throw(422, 'refund amount is invalid');
+    }
+    const session = await this.scope.model.paymentSession.getByIdForUpdate(
+      command.paymentSessionId,
+    );
+    if (!session) this.app.throw(404, 'payment session not found');
+    if (session.state !== 'succeeded' || !session.providerCaptureId) {
+      this.app.throw(409, 'payment session is not refundable');
+    }
+    if (session.currency !== command.currency) this.app.throw(409, 'refund currency conflicts');
+    const scene = this.bean.payScene.getOptions(session.payScene as never);
+    if (!scene.refund?.enabled) this.app.throw(409, 'payment scene refunds are disabled');
+    if (!scene.refund.allowPartial && command.amountMinor !== session.amountMinor) {
+      this.app.throw(422, 'payment scene does not allow partial refunds');
+    }
+
+    const existing = await this.scope.model.refundOperation.getForUpdate({
+      paymentSessionId: session.id,
+      idempotencyKey: command.idempotencyKey,
+    });
+    if (existing) {
+      if (
+        existing.amountMinor !== command.amountMinor ||
+        existing.currency !== command.currency ||
+        existing.businessReference !== command.businessReference
+      ) {
+        this.app.throw(409, 'refund idempotency key conflicts with an existing operation');
+      }
+      return existing;
+    }
+    const operations = await this.scope.model.refundOperation.select({
+      where: { paymentSessionId: session.id },
+    });
+    const committedAmount = operations
+      .filter(item => ['created', 'submitting', 'pending', 'succeeded'].includes(item.state))
+      .reduce((total, item) => total + item.amountMinor, 0);
+    if (committedAmount + command.amountMinor > session.amountMinor) {
+      this.app.throw(422, 'refund amount exceeds the remaining captured amount');
+    }
+    const refund = await this.scope.model.refundOperation.insert({
+      paymentSessionId: session.id,
+      businessReference: command.businessReference,
+      amountMinor: command.amountMinor,
+      currency: command.currency,
+      state: 'created',
+      idempotencyKey: command.idempotencyKey,
+    });
+    await this.scope.model.providerOperation.insert({
+      paymentSessionId: session.id,
+      refundOperationId: refund.id,
+      kind: 'refund',
+      state: 'created',
+      idempotencyKey: `${command.idempotencyKey}:provider`,
+      correlationId: command.correlationId,
+      attemptCount: 0,
+      nextAttemptAt: new Date(Date.now() - 1_000),
+    });
+    return refund;
+  }
+
+  async submit(refundOperationId: TableIdentity) {
+    const operation = await this.scope.model.providerOperation.get({
+      refundOperationId,
+      kind: 'refund',
+    });
+    if (!operation) this.app.throw(404, 'refund provider operation not found');
+    await this.scope.service.providerOperation.execute(operation.id);
+    return await this.scope.model.refundOperation.getById(refundOperationId);
+  }
+
+  @Core.transaction()
+  async settleProviderSnapshot(
+    providerOperationId: TableIdentity,
+    claimToken: string,
+    snapshot: IPayProviderRefundSnapshot,
+  ) {
+    const providerOperation =
+      await this.scope.model.providerOperation.getByIdForUpdate(providerOperationId);
+    if (
+      !providerOperation ||
+      providerOperation.kind !== 'refund' ||
+      !['claimed', 'submitted'].includes(providerOperation.state) ||
+      providerOperation.claimToken !== claimToken ||
+      !providerOperation.refundOperationId
+    ) {
+      return undefined;
+    }
+    const refund = await this.scope.model.refundOperation.getByIdForUpdate(
+      providerOperation.refundOperationId,
+    );
+    if (!refund) this.app.throw(404, 'refund operation not found');
+    const session = await this.scope.model.paymentSession.getByIdForUpdate(refund.paymentSessionId);
+    if (!session) this.app.throw(404, 'payment session not found');
+    if (
+      refund.providerRefundId &&
+      snapshot.providerRefundId &&
+      refund.providerRefundId !== snapshot.providerRefundId
+    ) {
+      this.app.throw(409, 'provider refund identifier conflicts with the refund operation');
+    }
+    if (['succeeded', 'failed', 'cancelled'].includes(refund.state)) {
+      await this._completeProviderOperation(providerOperation, snapshot.providerRefundId);
+      return refund;
+    }
+    const finalizedAt = isTerminalRefundState(snapshot.state) ? new Date() : undefined;
+    await this.scope.model.refundOperation.updateById(refund.id, {
+      state: snapshot.state,
+      providerRefundId: snapshot.providerRefundId,
+      finalizedAt,
+    });
+    if (finalizedAt) {
+      await this.scope.service.outbox.enqueue(session.id, 'refund.outcome.v1', {
+        eventId: `${providerOperation.correlationId}:refund`,
+        paymentSessionId: session.id,
+        refundOperationId: refund.id,
+        businessReference: refund.businessReference,
+        providerName: session.providerName,
+        state: snapshot.state as 'succeeded' | 'failed' | 'cancelled',
+        providerRefundId: snapshot.providerRefundId,
+        amountMinor: refund.amountMinor,
+        currency: refund.currency,
+      });
+    }
+    await this._completeProviderOperation(providerOperation, snapshot.providerRefundId);
+    return { ...refund, ...snapshot, finalizedAt };
+  }
+
+  @Core.transaction()
+  async transitionFromWebhook(
+    refundOperationId: TableIdentity,
+    options: {
+      eventId: string;
+      state: IPayProviderRefundSnapshot['state'];
+      providerRefundId?: string;
+    },
+  ) {
+    const refund = await this.scope.model.refundOperation.getByIdForUpdate(refundOperationId);
+    if (!refund) this.app.throw(404, 'refund operation not found');
+    const session = await this.scope.model.paymentSession.getByIdForUpdate(refund.paymentSessionId);
+    if (!session) this.app.throw(404, 'payment session not found');
+    if (
+      refund.providerRefundId &&
+      options.providerRefundId &&
+      refund.providerRefundId !== options.providerRefundId
+    ) {
+      this.app.throw(409, 'provider refund identifier conflicts with the refund operation');
+    }
+    if (refund.state === options.state) return { refund, changed: false };
+    if (['succeeded', 'failed', 'cancelled'].includes(refund.state)) {
+      return { refund, changed: false, ignoredReason: 'refund operation is already finalized' };
+    }
+    const finalizedAt = isTerminalRefundState(options.state) ? new Date() : undefined;
+    await this.scope.model.refundOperation.updateById(refund.id, {
+      state: options.state as 'succeeded' | 'failed' | 'cancelled',
+      providerRefundId: options.providerRefundId,
+      finalizedAt,
+    });
+    if (finalizedAt) {
+      await this.scope.service.outbox.enqueue(session.id, 'refund.outcome.v1', {
+        eventId: options.eventId,
+        paymentSessionId: session.id,
+        refundOperationId: refund.id,
+        businessReference: refund.businessReference,
+        providerName: session.providerName,
+        state: options.state as 'succeeded' | 'failed' | 'cancelled',
+        providerRefundId: options.providerRefundId,
+        amountMinor: refund.amountMinor,
+        currency: refund.currency,
+      });
+    }
+    return {
+      refund: {
+        ...refund,
+        state: options.state,
+        providerRefundId: options.providerRefundId,
+        finalizedAt,
+      },
+      changed: true,
+    };
+  }
+
+  private async _completeProviderOperation(
+    providerOperation: { id: TableIdentity },
+    providerResourceId?: string,
+  ) {
+    await this.scope.model.providerOperation.updateById(providerOperation.id, {
+      state: 'succeeded',
+      providerResourceId,
+      claimToken: undefined,
+      claimExpiresAt: undefined,
+      nextAttemptAt: undefined,
+      finalizedAt: new Date(),
+      errorCode: undefined,
+      errorSummary: undefined,
+    });
+  }
+}
+
+function isTerminalRefundState(
+  state: IPayProviderRefundSnapshot['state'],
+): state is 'succeeded' | 'failed' | 'cancelled' {
+  return ['succeeded', 'failed', 'cancelled'].includes(state);
+}

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/service/webhook.ts

@@ -5,8 +5,8 @@ import { Core } from 'vona-module-a-core';
 
 import type {
   IPayProviderVerifiedWebhook,
-  IPaymentOutcomeEvent,
   TypePaymentSessionState,
+  TypeRefundOperationState,
 } from '../types/payment.ts';
 
 export interface IWebhookReceiveCommand {
@@ -29,53 +29,49 @@ export class ServiceWebhook extends BeanBase {
   @Core.transaction()
   async receiveLocked(command: IWebhookReceiveCommand) {
     const payment = command.verified.payment;
-    const paymentSessionId = command.verified.paymentSessionId;
+    const refund = command.verified.refund;
+    if (!!payment === !!refund)
+      this.app.throw(400, 'webhook must contain exactly one payment or refund');
     const amountMinor = command.verified.summary?.amountMinor;
     const currency = command.verified.summary?.currency;
-    const paymentState = payment?.state as
-      | Extract<TypePaymentSessionState, 'succeeded' | 'failed' | 'cancelled'>
-      | undefined;
     if (
-      !payment ||
-      !paymentSessionId ||
-      !['succeeded', 'failed', 'cancelled'].includes(paymentState ?? '') ||
       typeof amountMinor !== 'number' ||
       !Number.isInteger(amountMinor) ||
       amountMinor < 0 ||
       typeof currency !== 'string' ||
       currency.length !== 3
     ) {
-      this.app.throw(400, 'payment webhook is incomplete');
+      this.app.throw(400, 'payment webhook amount is incomplete');
     }
+    if (payment) {
+      return await this._receivePayment(command, payment, amountMinor, currency);
+    }
+    return await this._receiveRefund(command, refund!, amountMinor, currency);
+  }
 
-    const session = await this.scope.model.paymentSession.getByIdForUpdate(paymentSessionId);
-    if (!session) this.app.throw(404, 'payment session not found');
+  private async _receivePayment(
+    command: IWebhookReceiveCommand,
+    payment: NonNullable<IPayProviderVerifiedWebhook['payment']>,
+    amountMinor: number,
+    currency: string,
+  ) {
+    const paymentSessionId = command.verified.paymentSessionId;
+    const paymentState = payment.state as Extract<
+      TypePaymentSessionState,
+      'succeeded' | 'failed' | 'cancelled'
+    >;
     if (
-      session.providerName !== command.providerName ||
-      session.clientName !== command.clientName ||
-      session.environment !== command.environment ||
-      session.amountMinor !== amountMinor ||
-      session.currency !== currency
+      !paymentSessionId ||
+      !['succeeded', 'failed', 'cancelled'].includes(paymentState) ||
+      command.verified.refundOperationId
     ) {
-      this.app.throw(409, 'payment webhook conflicts with the payment session');
-    }
-
-    const payloadHash = createHash('sha256')
-      .update(command.rawBody ?? JSON.stringify(command.verified))
-      .digest('hex');
-    const existing = await this.scope.model.webhookInbox.getForUpdate({
-      providerName: command.providerName,
-      clientName: command.clientName,
-      environment: command.environment,
-      providerEventId: command.verified.eventId,
-    });
-    if (existing) {
-      if (existing.payloadHash !== payloadHash) {
-        this.app.throw(409, 'payment webhook event conflicts with a prior payload');
-      }
-      return existing;
+      this.app.throw(400, 'payment webhook is incomplete');
     }
-
+    const session = await this.scope.model.paymentSession.getByIdForUpdate(paymentSessionId);
+    if (!session) this.app.throw(404, 'payment session not found');
+    this._assertSessionMatches(command, session, currency);
+    const existing = await this._getExistingInbox(command);
+    if (existing) return existing;
     const inbox = await this.scope.model.webhookInbox.insert({
       providerName: command.providerName,
       clientName: command.clientName,
@@ -83,45 +79,147 @@ export class ServiceWebhook extends BeanBase {
       providerEventId: command.verified.eventId,
       eventType: command.verified.eventType,
       paymentSessionId: session.id,
-      paymentState: paymentState!,
+      paymentState,
       amountMinor,
       currency,
       providerCaptureId: payment.providerCaptureId,
-      payloadHash,
+      payloadHash: this._payloadHash(command),
       state: 'received',
       retryCount: 0,
     });
-
     const transition = await this.scope.service.paymentSession.transitionFromWebhook(session.id, {
-      state: paymentState!,
+      state: paymentState,
       providerPaymentId: payment.providerPaymentId,
       providerCaptureId: payment.providerCaptureId,
       webhookInboxId: inbox.id,
     });
     if (transition.changed) {
-      const event: IPaymentOutcomeEvent = {
+      await this.scope.service.outbox.enqueue(session.id, 'payment.outcome.v1', {
         eventId: command.verified.eventId,
         paymentSessionId: session.id,
         businessReference: session.businessReference,
         providerName: session.providerName,
-        state: paymentState!,
+        state: paymentState,
         providerCaptureId: payment.providerCaptureId,
         amountMinor,
         currency,
-      };
-      await this.scope.service.outbox.enqueue(session.id, 'payment.outcome.v1', { ...event });
+      });
+    }
+    return await this._markProcessed(inbox.id, transition.ignoredReason);
+  }
+
+  private async _receiveRefund(
+    command: IWebhookReceiveCommand,
+    refund: NonNullable<IPayProviderVerifiedWebhook['refund']>,
+    amountMinor: number,
+    currency: string,
+  ) {
+    const refundOperationId = command.verified.refundOperationId;
+    if (!refundOperationId || command.verified.paymentSessionId) {
+      this.app.throw(400, 'refund webhook is incomplete');
+    }
+    const refundOperation =
+      await this.scope.model.refundOperation.getByIdForUpdate(refundOperationId);
+    if (!refundOperation) this.app.throw(404, 'refund operation not found');
+    const session = await this.scope.model.paymentSession.getByIdForUpdate(
+      refundOperation.paymentSessionId,
+    );
+    if (!session) this.app.throw(404, 'payment session not found');
+    this._assertSessionMatches(command, session, currency, false);
+    if (refundOperation.amountMinor !== amountMinor || refundOperation.currency !== currency) {
+      this.app.throw(409, 'refund webhook conflicts with the refund operation');
+    }
+    if (
+      refundOperation.providerRefundId &&
+      refund.providerRefundId &&
+      refundOperation.providerRefundId !== refund.providerRefundId
+    ) {
+      this.app.throw(409, 'refund webhook provider identifier conflicts with the refund operation');
+    }
+    const existing = await this._getExistingInbox(command);
+    if (existing) return existing;
+    const inbox = await this.scope.model.webhookInbox.insert({
+      providerName: command.providerName,
+      clientName: command.clientName,
+      environment: command.environment,
+      providerEventId: command.verified.eventId,
+      eventType: command.verified.eventType,
+      paymentSessionId: session.id,
+      refundOperationId: refundOperation.id,
+      refundState: refund.state,
+      amountMinor,
+      currency,
+      providerCaptureId: session.providerCaptureId,
+      providerRefundId: refund.providerRefundId,
+      payloadHash: this._payloadHash(command),
+      state: 'received',
+      retryCount: 0,
+    });
+    const transition = await this.scope.service.refundOperation.transitionFromWebhook(
+      refundOperation.id,
+      {
+        eventId: command.verified.eventId,
+        state: refund.state as Extract<
+          TypeRefundOperationState,
+          'pending' | 'succeeded' | 'failed' | 'cancelled'
+        >,
+        providerRefundId: refund.providerRefundId,
+      },
+    );
+    return await this._markProcessed(inbox.id, transition.ignoredReason);
+  }
+
+  private _assertSessionMatches(
+    command: IWebhookReceiveCommand,
+    session: {
+      providerName: string;
+      clientName: string;
+      environment: string;
+      amountMinor: number;
+      currency: string;
+    },
+    currency: string,
+    assertAmount = true,
+  ) {
+    if (
+      session.providerName !== command.providerName ||
+      session.clientName !== command.clientName ||
+      session.environment !== command.environment ||
+      (assertAmount && session.amountMinor !== command.verified.summary?.amountMinor) ||
+      session.currency !== currency
+    ) {
+      this.app.throw(409, 'payment webhook conflicts with the payment session');
     }
+  }
+
+  private async _getExistingInbox(command: IWebhookReceiveCommand) {
+    const existing = await this.scope.model.webhookInbox.getForUpdate({
+      providerName: command.providerName,
+      clientName: command.clientName,
+      environment: command.environment,
+      providerEventId: command.verified.eventId,
+    });
+    if (existing && existing.payloadHash !== this._payloadHash(command)) {
+      this.app.throw(409, 'payment webhook event conflicts with a prior payload');
+    }
+    return existing;
+  }
+
+  private _payloadHash(command: IWebhookReceiveCommand) {
+    return createHash('sha256')
+      .update(command.rawBody ?? JSON.stringify(command.verified))
+      .digest('hex');
+  }
+
+  private async _markProcessed(inboxId: string | number, errorSummary?: string) {
     const processedAt = new Date();
-    await this.scope.model.webhookInbox.updateById(inbox.id, {
+    await this.scope.model.webhookInbox.updateById(inboxId, {
       state: 'processed',
       processedAt,
-      errorSummary: transition.ignoredReason,
+      errorSummary,
     });
-    return {
-      ...inbox,
-      state: 'processed' as const,
-      processedAt,
-      errorSummary: transition.ignoredReason,
-    };
+    const inbox = await this.scope.model.webhookInbox.getById(inboxId);
+    if (!inbox) this.app.throw(500, 'persisted webhook inbox not found');
+    return inbox;
   }
 }

package/vona/src/suite-vendor/a-pay/modules/a-pay/src/types/payScene.ts

@@ -2,11 +2,12 @@ import type { TableIdentity } from 'table-identity';
 import type { OmitNever, VonaContext } from 'vona';
 import type { ServiceOnion } from 'vona-module-a-onion';
 
-import type { IPaymentOutcomeEvent } from './payment.ts';
+import type { IPaymentOutcomeEvent, IRefundOutcomeEvent } from './payment.ts';
 import type { IPayProviderRecord } from './payProvider.ts';
 
 export interface IPaySceneExecute {
   onPaymentOutcome(event: IPaymentOutcomeEvent): Promise<void>;
+  onRefundOutcome(event: IRefundOutcomeEvent): Promise<void>;
 }
 
 export interface IPaySceneRecord {}

package/vona/src/suite-vendor/a-pay/modules/pay-mock/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-pay-mock",
-  "version": "5.0.1",
+  "version": "5.0.3",
   "description": "",
   "keywords": [
     "Vona Module"

package/vona/src/suite-vendor/a-pay/modules/pay-mock/src/.metadata/index.ts

@@ -6,15 +6,15 @@ export * from '../service/payMock.ts';
 
 import 'vona-module-a-bean';
 declare module 'vona-module-a-bean' {
-
+  
     export interface IServiceRecord {
       'pay-mock:payMock': never;
     }
 
-
+  
 }
 declare module 'vona-module-pay-mock' {
-
+  
         export interface ServicePayMock {
           /** @internal */
           get scope(): ScopeModulePayMock;
@@ -23,8 +23,8 @@ declare module 'vona-module-pay-mock' {
           export interface ServicePayMock {
             get $beanFullName(): 'pay-mock.service.payMock';
             get $onionName(): 'pay-mock:payMock';
-
-          }
+            
+          } 
 }
 /** service: end */
 /** service: begin */
@@ -45,27 +45,35 @@ declare module 'vona' {
 /** dto: begin */
 export * from '../dto/mockPaymentComplete.tsx';
 export * from '../dto/mockPaymentReceipt.tsx';
+export * from '../dto/mockRefundComplete.tsx';
+export * from '../dto/mockRefundReceipt.tsx';
 import type { IDtoOptionsMockPaymentComplete } from '../dto/mockPaymentComplete.tsx';
 import type { IDtoOptionsMockPaymentReceipt } from '../dto/mockPaymentReceipt.tsx';
+import type { IDtoOptionsMockRefundComplete } from '../dto/mockRefundComplete.tsx';
+import type { IDtoOptionsMockRefundReceipt } from '../dto/mockRefundReceipt.tsx';
 import 'vona-module-a-web';
 declare module 'vona-module-a-web' {
-
+  
     export interface IDtoRecord {
       'pay-mock:mockPaymentComplete': IDtoOptionsMockPaymentComplete;
 'pay-mock:mockPaymentReceipt': IDtoOptionsMockPaymentReceipt;
+'pay-mock:mockRefundComplete': IDtoOptionsMockRefundComplete;
+'pay-mock:mockRefundReceipt': IDtoOptionsMockRefundReceipt;
     }
 
-
+  
 }
 declare module 'vona-module-pay-mock' {
-
+   
 }
 /** dto: end */
 /** dto: begin */
 import type { DtoMockPaymentComplete } from '../dto/mockPaymentComplete.tsx';
 import type { DtoMockPaymentReceipt } from '../dto/mockPaymentReceipt.tsx';
+import type { DtoMockRefundComplete } from '../dto/mockRefundComplete.tsx';
+import type { DtoMockRefundReceipt } from '../dto/mockRefundReceipt.tsx';
 declare module 'vona-module-pay-mock' {
-
+  
     export interface IDtoOptionsMockPaymentComplete {
       fields?: TypeEntityOptionsFields<DtoMockPaymentComplete, IDtoOptionsMockPaymentComplete[TypeSymbolKeyFieldsMore]>;
     }
@@ -73,6 +81,14 @@ declare module 'vona-module-pay-mock' {
     export interface IDtoOptionsMockPaymentReceipt {
       fields?: TypeEntityOptionsFields<DtoMockPaymentReceipt, IDtoOptionsMockPaymentReceipt[TypeSymbolKeyFieldsMore]>;
     }
+
+    export interface IDtoOptionsMockRefundComplete {
+      fields?: TypeEntityOptionsFields<DtoMockRefundComplete, IDtoOptionsMockRefundComplete[TypeSymbolKeyFieldsMore]>;
+    }
+
+    export interface IDtoOptionsMockRefundReceipt {
+      fields?: TypeEntityOptionsFields<DtoMockRefundReceipt, IDtoOptionsMockRefundReceipt[TypeSymbolKeyFieldsMore]>;
+    }
 }
 /** dto: end */
 /** controller: begin */
@@ -80,15 +96,15 @@ export * from '../controller/mockPayment.ts';
 import type { IControllerOptionsMockPayment } from '../controller/mockPayment.ts';
 import 'vona-module-a-web';
 declare module 'vona-module-a-web' {
-
+  
     export interface IControllerRecord {
       'pay-mock:mockPayment': IControllerOptionsMockPayment;
     }
 
-
+  
 }
 declare module 'vona-module-pay-mock' {
-
+  
         export interface ControllerMockPayment {
           /** @internal */
           get scope(): ScopeModulePayMock;
@@ -98,14 +114,14 @@ declare module 'vona-module-pay-mock' {
             get $beanFullName(): 'pay-mock.controller.mockPayment';
             get $onionName(): 'pay-mock:mockPayment';
             get $onionOptions(): IControllerOptionsMockPayment;
-          }
+          } 
 }
 /** controller: end */
 /** controller: begin */
 // @ts-ignore ignore
 import type { ControllerMockPayment } from '../controller/mockPayment.ts';
 declare module 'vona-module-pay-mock' {
-
+  
     export interface IControllerOptionsMockPayment {
       actions?: TypeControllerOptionsActions<ControllerMockPayment>;
     }
@@ -113,6 +129,7 @@ declare module 'vona-module-pay-mock' {
 declare module 'vona-module-a-web' {
   export interface IApiPathPostRecord{
         '/pay/mock/payment-session/:id/complete': undefined;
+'/pay/mock/payment-session/refund-operation/:id/complete': undefined;
     }
 
 }
@@ -123,15 +140,15 @@ export * from '../bean/payProvider.mock.ts';
 import type { IPayProviderOptionsMock } from '../bean/payProvider.mock.ts';
 import 'vona-module-a-pay';
 declare module 'vona-module-a-pay' {
-
+  
     export interface IPayProviderRecord {
       'pay-mock:mock': IPayProviderOptionsMock;
     }
 
-
+  
 }
 declare module 'vona-module-pay-mock' {
-
+  
         export interface PayProviderMock {
           /** @internal */
           get scope(): ScopeModulePayMock;
@@ -141,7 +158,7 @@ declare module 'vona-module-pay-mock' {
             get $beanFullName(): 'pay-mock.payProvider.mock';
             get $onionName(): 'pay-mock:mock';
             get $onionOptions(): IPayProviderOptionsMock;
-          }
+          } 
 }
 /** payProvider: end */
 /** payProvider: begin */
@@ -172,11 +189,11 @@ declare module 'vona' {
   export interface IBeanScopeContainer {
     payMock: ScopeModulePayMock;
   }
+  
+  
 
+  
 
-
-
-
-
+  
 }
 /** scope: end */