@plyaz/types 1.14.4 → 1.14.6

package/dist/logger/types.d.ts

@@ -21,6 +21,7 @@ export interface LoggerInterface {
 }
 export type LoggerMethodTypes = 'debug' | 'info' | 'warn' | 'error' | 'fatal';
 export type LoggerEnvironment = 'development' | 'production' | 'staging';
+export type LoggerTransport = 'pino' | 'console';
 /**
  * Configuration for PackageLogger instances
  */
@@ -35,6 +36,8 @@ export interface PackageLoggerConfig {
     correlationId?: string;
     /** Minimum log level to output */
     minLevel?: LoggerMethodTypes;
+    /** Transport type: 'pino' (structured JSON) or 'console' (formatted output with ANSI colors). Default: 'pino' */
+    transport?: LoggerTransport;
 }
 /**
  * Extended logger interface with package context support

package/dist/payments/base-error/types.d.ts

@@ -1,7 +1,7 @@
-import type { PAYMENTMETHOD, PAYMENTPROVIDERTYPE, ProviderCapabilities, ProviderConfiguration } from '../provider';
+import type { PAYMENT_METHOD, PAYMENT_PROVIDER_TYPE, ProviderCapabilities, ProviderConfiguration } from '../provider';
 import type { Money } from '../transaction';
 import type { BaseErrorContext } from '../../api';
-import type { EventProcessingMetadata, PaymentEventPayload, PAYMENTEVENTTYPE } from '../events';
+import type { EventProcessingMetadata, PaymentEventPayload, PAYMENT_EVENT_TYPE } from '../events';
 import type { PAYMENT_ERROR_CATEGORY } from './enum';
 import type { ERROR_SEVERITY } from '../../errors';
 import type { CurrencyCode } from '../../locale/types';
@@ -9,9 +9,9 @@ import type { CurrencyCode } from '../../locale/types';
  * Base adapter options used for constructing provider adapters.
  */
 export interface BasePaymentAdapterOptions {
-    name: PAYMENTPROVIDERTYPE;
+    name: PAYMENT_PROVIDER_TYPE;
     apiVersion: string;
-    methods: PAYMENTMETHOD[];
+    methods: PAYMENT_METHOD[];
     currencies: CurrencyCode[];
     capabilities: ProviderCapabilities;
     providerConfiguration: ProviderConfiguration;
@@ -19,7 +19,7 @@ export interface BasePaymentAdapterOptions {
 export interface ErrorPatternAnalysis {
     totalErrors: number;
     errorsByCategory: Record<PAYMENT_ERROR_CATEGORY, number>;
-    errorsByProvider: Record<PAYMENTPROVIDERTYPE, number>;
+    errorsByProvider: Record<PAYMENT_PROVIDER_TYPE, number>;
     errorsBySeverity: Record<SeverityError, number>;
     errorsByCode: Record<string, number>;
     retryableErrorsCount: number;
@@ -56,7 +56,7 @@ export interface VelocityMetrics {
  */
 export interface PaymentErrorOptions {
     /** Payment provider involved */
-    provider?: PAYMENTPROVIDERTYPE;
+    provider?: PAYMENT_PROVIDER_TYPE;
     /** Related transaction ID */
     transactionId?: string;
     /** Affected user ID */
@@ -91,7 +91,7 @@ export interface PaymentErrorContext extends BaseErrorContext {
     /** IP address of the request */
     ipAddress?: string;
     /** Payment method being used */
-    paymentMethod?: PAYMENTMETHOD;
+    paymentMethod?: PAYMENT_METHOD;
     /** Payment amount involved */
     amount?: Money;
     /** Provider-specific error information */
@@ -144,7 +144,7 @@ export interface PaymentErrorLogFormat {
         severity: SeverityError;
         retryable: boolean;
         userFacing: boolean;
-        provider?: PAYMENTPROVIDERTYPE;
+        provider?: PAYMENT_PROVIDER_TYPE;
         transactionId?: string;
         userId?: string;
         context: PaymentErrorContext;
@@ -154,8 +154,8 @@ export interface PaymentErrorLogFormat {
 }
 export interface BuildUnifiedEventOptions {
     rawEvent: Record<string, unknown>;
-    provider: PAYMENTPROVIDERTYPE;
-    normalizedEventType: PAYMENTEVENTTYPE;
+    provider: PAYMENT_PROVIDER_TYPE;
+    normalizedEventType: PAYMENT_EVENT_TYPE;
     normalizedData: PaymentEventPayload;
     processingMetadata: EventProcessingMetadata;
 }

package/dist/payments/events/emitter/types.d.ts

@@ -1,4 +1,4 @@
-import type { PAYMENTEVENTTYPE } from '../enums';
+import type { PAYMENT_EVENT_TYPE } from '../enums';
 import type { EventRetryConfig, PaymentEvent, PaymentEventPayload } from '../types';
 /**
  * Payment event emitter interface that extends the base event system
@@ -19,7 +19,7 @@ export interface EventProcessingResult<TMetadata extends object = {}> {
     /** Unique emission ID for tracking this processing */
     emissionId: string;
     /** Event type that was processed */
-    eventType: PAYMENTEVENTTYPE;
+    eventType: PAYMENT_EVENT_TYPE;
     /** Total number of handlers triggered */
     totalHandlers: number;
     /** Number of handlers that succeeded */
@@ -51,7 +51,7 @@ export interface PaymentEventEmitter {
      * @param options - Additional emission options
      * @returns Promise that resolves when emission is complete
      */
-    emit(eventType: PAYMENTEVENTTYPE, payload: PaymentEventPayload, options?: EventEmissionOptions): Promise<EventEmissionResult>;
+    emit(eventType: PAYMENT_EVENT_TYPE, payload: PaymentEventPayload, options?: EventEmissionOptions): Promise<EventEmissionResult>;
     /**
      * Emit event and wait for all handlers to complete processing.
      * Useful for critical events that require synchronous processing.
@@ -61,7 +61,7 @@ export interface PaymentEventEmitter {
      * @param timeout - Maximum wait time in milliseconds
      * @returns Promise with aggregated handler results
      */
-    emitAndWait(eventType: PAYMENTEVENTTYPE, payload: PaymentEventPayload, timeout?: number): Promise<EventProcessingResult[]>;
+    emitAndWait(eventType: PAYMENT_EVENT_TYPE, payload: PaymentEventPayload, timeout?: number): Promise<EventProcessingResult[]>;
     /**
      * Subscribe to specific payment event types with typed handlers.
      * Handlers will be called for matching events.
@@ -70,7 +70,7 @@ export interface PaymentEventEmitter {
      * @param handler - Typed event handler function
      * @param options - Handler configuration options
      */
-    on(eventType: PAYMENTEVENTTYPE, handler: PaymentEventHandler, options?: EventHandlerOptions): void;
+    on(eventType: PAYMENT_EVENT_TYPE, handler: PaymentEventHandler, options?: EventHandlerOptions): void;
     /**
      * Subscribe to multiple event types with pattern matching.
      * Supports wildcards and complex filtering patterns.
@@ -96,20 +96,20 @@ export interface PaymentEventEmitter {
      * @param handler - Event handler function
      * @param options - Handler configuration options
      */
-    once(eventType: PAYMENTEVENTTYPE, handler: PaymentEventHandler, options?: EventHandlerOptions): void;
+    once(eventType: PAYMENT_EVENT_TYPE, handler: PaymentEventHandler, options?: EventHandlerOptions): void;
     /**
      * Remove event listener for specific event type and handler.
      *
      * @param eventType - Event type to unsubscribe from
      * @param handler - Handler function to remove
      */
-    off(eventType: PAYMENTEVENTTYPE, handler: PaymentEventHandler): void;
+    off(eventType: PAYMENT_EVENT_TYPE, handler: PaymentEventHandler): void;
     /**
      * Remove all event listeners for specific event type.
      *
      * @param eventType - Event type to clear all handlers for
      */
-    removeAllListeners(eventType: PAYMENTEVENTTYPE): void;
+    removeAllListeners(eventType: PAYMENT_EVENT_TYPE): void;
     /**
      * Get current event emission metrics and statistics.
      *
@@ -276,7 +276,7 @@ export interface EventEmissionMetrics {
         averageExecutionTime: number;
     };
     /** Event type breakdown */
-    eventTypeBreakdown: Record<PAYMENTEVENTTYPE, number>;
+    eventTypeBreakdown: Record<PAYMENT_EVENT_TYPE, number>;
     /** Error statistics */
     errorStatistics: {
         totalErrors: number;

package/dist/payments/events/enums.d.ts

@@ -8,7 +8,7 @@
  * - Use present tense for ongoing events, past tense for completed events
  * - Include both success and failure events for complete audit trails
  */
-export declare enum PAYMENTEVENTTYPE {
+export declare enum PAYMENT_EVENT_TYPE {
     PaymentInitiated = "payment.initiated",
     PaymentProcessing = "payment.processing",
     PaymentRequiresAction = "payment.requires_action",
@@ -82,7 +82,7 @@ export declare enum PAYMENTEVENTTYPE {
 /**
  * Payment event categories for organization and routing.
  */
-export declare enum PAYMENTEVENTCATEGORY {
+export declare enum PAYMENT_EVENT_CATEGORY {
     TRANSACTION = "transaction",
     REFUND = "refund",
     PROVIDER = "provider",
@@ -96,7 +96,7 @@ export declare enum PAYMENTEVENTCATEGORY {
 /**
  * Error categories for payment events.
  */
-export declare enum PAYMENTERRORCATEGORY {
+export declare enum PAYMENT_EVENT_ERROR_CATEGORY {
     UserError = "user_error",// User input or action errors
     ProviderError = "provider_error",// Payment provider errors
     SystemError = "system_error",// Internal system errors

package/dist/payments/events/types.d.ts

@@ -1,13 +1,13 @@
-import type { PAYMENTMETHOD, PAYMENTPROVIDERTYPE, PAYMENTSTATUS, PRODUCTTYPE, USERTYPE } from '../provider';
+import type { PAYMENT_METHOD, PAYMENT_PROVIDER_TYPE, PAYMENT_STATUS, PRODUCT_TYPE, USER_TYPE } from '../provider';
 import type { FeeBreakdown, Money } from '../transaction';
-import type { PAYMENTERRORCATEGORY, PAYMENTEVENTCATEGORY, PAYMENTEVENTTYPE } from './enums';
+import type { PAYMENT_EVENT_ERROR_CATEGORY, PAYMENT_EVENT_CATEGORY, PAYMENT_EVENT_TYPE } from './enums';
 /**
  * Core payment event interface that extends the base Event interface
  * from @plyaz/events while adding payment-specific data and context.
  */
 export interface PaymentEvent extends Event {
     /** Payment-specific event type */
-    type: PAYMENTEVENTTYPE;
+    type: PAYMENT_EVENT_TYPE;
     /** Payment event payload with business data */
     payload: PaymentEventPayload;
     /** Event metadata for processing and routing */
@@ -24,21 +24,21 @@ export interface PaymentEventPayload<TProviderMetadata extends Record<string, st
     /** User ID who initiated or is affected by this event */
     userId: string;
     /** Type of user for business logic and permissions */
-    userType: USERTYPE;
+    userType: USER_TYPE;
     /** Payment amount and currency (for monetary events) */
     amount?: Money;
     /** Payment provider involved in this event */
-    provider: PAYMENTPROVIDERTYPE;
+    provider: PAYMENT_PROVIDER_TYPE;
     /** Current payment status after this event */
-    status: PAYMENTSTATUS;
+    status: PAYMENT_STATUS;
     /** Previous status before this event (for status changes) */
-    previousStatus?: PAYMENTSTATUS;
+    previousStatus?: PAYMENT_STATUS;
     /** Payment method used or affected */
-    paymentMethod?: PAYMENTMETHOD;
+    paymentMethod?: PAYMENT_METHOD;
     /** Product information related to the payment */
     productInfo?: {
         productId: string;
-        productType: PRODUCTTYPE;
+        productType: PRODUCT_TYPE;
         productTitle?: string;
     };
     /** Error information for failed events */
@@ -78,7 +78,7 @@ export interface PaymentEventMetadata {
     /** Whether this event requires immediate processing */
     urgent: boolean;
     /** Event category for filtering and routing */
-    category: PAYMENTEVENTCATEGORY;
+    category: PAYMENT_EVENT_CATEGORY;
     /** Tags for event classification and filtering */
     tags: string[];
     /** Correlation ID for tracking related events */
@@ -115,7 +115,7 @@ export interface PaymentEventError {
     /** Human-readable error message */
     message: string;
     /** Error category for handling logic */
-    category: PAYMENTERRORCATEGORY;
+    category: PAYMENT_EVENT_ERROR_CATEGORY;
     /** Whether this error condition is retryable */
     retryable: boolean;
     /** Provider-specific error code if applicable */

package/dist/payments/events/unified-event/types.d.ts

@@ -1,5 +1,5 @@
-import type { PAYMENTPROVIDERTYPE, PAYMENTSTATUS } from '../../provider';
-import type { PAYMENTEVENTTYPE } from '../enums';
+import type { PAYMENT_PROVIDER_TYPE, PAYMENT_STATUS } from '../../provider';
+import type { PAYMENT_EVENT_TYPE } from '../enums';
 import type { PaymentEventPayload } from '../types';
 import type { EVENTPROCESSINGSTATUS } from './enums';
 /**
@@ -16,13 +16,13 @@ export interface UnifiedProviderEvent<TRawEvent extends object = {}, TNormalized
     /** Unique event ID generated by our system */
     id: string;
     /** Provider that sent this event */
-    provider: PAYMENTPROVIDERTYPE;
+    provider: PAYMENT_PROVIDER_TYPE;
     /** Provider's original event ID for reference */
     providerEventId: string;
     /** Provider's original event type as received */
     providerEventType: string;
     /** Our normalized event type */
-    normalizedEventType: PAYMENTEVENTTYPE;
+    normalizedEventType: PAYMENT_EVENT_TYPE;
     /** Normalized event data in our standard format */
     normalizedData: TNormalizedData;
     /** Original raw event data from provider (for debugging/audit) */
@@ -110,7 +110,7 @@ export interface DataExtractionResult<TValue extends object | string | number |
  */
 export interface ProviderEventMapping {
     /** Provider this mapping applies to */
-    provider: PAYMENTPROVIDERTYPE;
+    provider: PAYMENT_PROVIDER_TYPE;
     /** Provider API version this mapping supports */
     providerApiVersion?: string;
     /** Mapping configuration version */
@@ -135,7 +135,7 @@ export interface EventTypeMapping {
     /** Provider's event type */
     providerEventType: string;
     /** Our normalized event type */
-    normalizedEventType: PAYMENTEVENTTYPE;
+    normalizedEventType: PAYMENT_EVENT_TYPE;
     /** Confidence level of this mapping (0.0 - 1.0) */
     confidence: number;
     /** Whether this mapping is currently active */
@@ -152,7 +152,7 @@ export interface StatusMapping<TContext extends object = {}> {
     /** Provider's status value */
     providerStatus: string;
     /** Our normalized status */
-    normalizedStatus: PAYMENTSTATUS;
+    normalizedStatus: PAYMENT_STATUS;
     /** Additional context required for this mapping */
     context?: TContext;
     /** Whether this is a terminal status */

package/dist/payments/gateways/provider/types.d.ts

@@ -1,12 +1,12 @@
 import type { CurrencyCode } from '../../../locale/types';
-import type { PAYMENTMETHOD, PAYMENTPROVIDERTYPE } from '../../provider';
+import type { PAYMENT_METHOD, PAYMENT_PROVIDER_TYPE } from '../../provider';
 /**
  * Base configuration interface that all payment providers must implement.
  * This ensures consistent configuration structure across all providers.
  */
 export interface BaseProviderConfig {
     /** Provider identification */
-    provider: PAYMENTPROVIDERTYPE;
+    provider: PAYMENT_PROVIDER_TYPE;
     /** Display name for this provider */
     displayName: string;
     /** Whether this provider is currently enabled */
@@ -241,7 +241,7 @@ export interface ProviderFeeConfiguration {
         currency: CurrencyCode;
     };
     /** Payment method specific fees */
-    methodFees: Record<PAYMENTMETHOD, {
+    methodFees: Record<PAYMENT_METHOD, {
         percentage: number;
         fixed: number;
         currency: CurrencyCode;
@@ -322,12 +322,12 @@ export interface ProviderLimitsConfiguration<TProviderSpecific extends object =
     /** Transaction amount limits */
     amounts: {
         /** Minimum transaction amount */
-        minimum: Record<PAYMENTMETHOD, {
+        minimum: Record<PAYMENT_METHOD, {
             amount: number;
             currency: CurrencyCode;
         }>;
         /** Maximum transaction amount */
-        maximum: Record<PAYMENTMETHOD, {
+        maximum: Record<PAYMENT_METHOD, {
             amount: number;
             currency: CurrencyCode;
         }>;

package/dist/payments/gateways/routings/types.d.ts

@@ -1,5 +1,5 @@
 import type { CurrencyCode } from '../../../locale/types';
-import type { PAYMENTMETHOD, PAYMENTPROVIDERTYPE, TRANSACTIONTYPE, USERTYPE } from '../../provider';
+import type { PAYMENT_METHOD, PAYMENT_PROVIDER_TYPE, TRANSACTION_TYPE, USER_TYPE } from '../../provider';
 import type { VolumeTier } from '../provider/types';
 import type { COSTOPTIMIZATIONSTRATEGY, FAILOVERSTRATEGY, LOADBALANCINGSTRATEGY, PERFORMANCEMETRICTYPE, REGULATORYFRAMEWORK, ROUTINGSTRATEGY } from './enums';
 /**
@@ -31,7 +31,7 @@ export interface ProviderSelectionRules {
     /** Default provider preferences */
     defaultProviders: ProviderPreference[];
     /** Payment method specific preferences */
-    methodSpecificProviders: Record<PAYMENTMETHOD, ProviderPreference[]>;
+    methodSpecificProviders: Record<PAYMENT_METHOD, ProviderPreference[]>;
     /** Amount-based provider selection */
     amountBasedSelection: AmountBasedRule[];
     /** Currency-specific provider preferences */
@@ -39,7 +39,7 @@ export interface ProviderSelectionRules {
     /** Region-specific provider preferences */
     regionSpecificProviders: Record<string, ProviderPreference[]>;
     /** User type specific preferences */
-    userTypeProviders: Record<USERTYPE, ProviderPreference[]>;
+    userTypeProviders: Record<USER_TYPE, ProviderPreference[]>;
     /** Time-based provider selection */
     timeBasedSelection: TimeBasedRule[];
     /** Custom selection rules */
@@ -50,7 +50,7 @@ export interface ProviderSelectionRules {
  */
 export interface ProviderPreference {
     /** Provider identifier */
-    provider: PAYMENTPROVIDERTYPE;
+    provider: PAYMENT_PROVIDER_TYPE;
     /** Weight/priority (higher = preferred) */
     weight: number;
     /** Traffic allocation percentage */
@@ -159,11 +159,11 @@ export interface CustomSelectionRule {
     /** Provider selection when rule matches */
     providerSelection: {
         /** Providers to prefer */
-        preferred: PAYMENTPROVIDERTYPE[];
+        preferred: PAYMENT_PROVIDER_TYPE[];
         /** Providers to avoid */
-        excluded: PAYMENTPROVIDERTYPE[];
+        excluded: PAYMENT_PROVIDER_TYPE[];
         /** Weight adjustments */
-        weightAdjustments: Record<PAYMENTPROVIDERTYPE, number>;
+        weightAdjustments: Record<PAYMENT_PROVIDER_TYPE, number>;
     };
     /** Rule priority */
     priority: number;
@@ -228,7 +228,7 @@ export interface FailoverConfiguration {
     /** Failover strategy */
     strategy: FAILOVERSTRATEGY;
     /** Provider priority order for failover */
-    providerOrder: PAYMENTPROVIDERTYPE[];
+    providerOrder: PAYMENT_PROVIDER_TYPE[];
     /** Failure detection settings */
     failureDetection: {
         /** Consecutive failures before failover */
@@ -287,7 +287,7 @@ export interface GeographicRoutingConfig {
         /** Enable cross-border payments */
         enabled: boolean;
         /** Preferred providers for cross-border */
-        preferredProviders: PAYMENTPROVIDERTYPE[];
+        preferredProviders: PAYMENT_PROVIDER_TYPE[];
         /** Additional fees for cross-border */
         additionalFees: {
             percentage: number;
@@ -308,7 +308,7 @@ export interface GeographicRoutingConfig {
         /** Zone definitions */
         zones: Record<string, {
             currencies: CurrencyCode[];
-            preferredProviders: PAYMENTPROVIDERTYPE[];
+            preferredProviders: PAYMENT_PROVIDER_TYPE[];
         }>;
     };
 }
@@ -321,7 +321,7 @@ export interface RegionRoutingConfig {
     /** Preferred providers for this region */
     preferredProviders: ProviderPreference[];
     /** Local payment methods */
-    localPaymentMethods: PAYMENTMETHOD[];
+    localPaymentMethods: PAYMENT_METHOD[];
     /** Regulatory requirements */
     regulations: {
         /** KYC requirements */
@@ -363,7 +363,7 @@ export interface ComplianceRule {
     /** Rule conditions */
     conditions: {
         /** Transaction types affected */
-        transactionTypes: TRANSACTIONTYPE[];
+        transactionTypes: TRANSACTION_TYPE[];
         /** Amount thresholds */
         amountThresholds?: {
             min?: {
@@ -376,7 +376,7 @@ export interface ComplianceRule {
             };
         };
         /** User types affected */
-        userTypes?: USERTYPE[];
+        userTypes?: USER_TYPE[];
     };
     /** Required actions */
     actions: {
@@ -401,9 +401,9 @@ export interface LoadBalancingConfig {
     /** Load balancing strategy */
     strategy: LOADBALANCINGSTRATEGY;
     /** Traffic weights per provider */
-    providerWeights: Record<PAYMENTPROVIDERTYPE, number>;
+    providerWeights: Record<PAYMENT_PROVIDER_TYPE, number>;
     /** Maximum concurrent connections per provider */
-    maxConnections?: Record<PAYMENTPROVIDERTYPE, number>;
+    maxConnections?: Record<PAYMENT_PROVIDER_TYPE, number>;
     /** Session stickiness settings */
     stickiness?: {
         enabled: boolean;
@@ -489,7 +489,7 @@ export interface ABTestExperiment {
         /** Routing strategy for variant group */
         strategy?: ROUTINGSTRATEGY;
         /** Preferred provider list */
-        preferredProviders?: PAYMENTPROVIDERTYPE[];
+        preferredProviders?: PAYMENT_PROVIDER_TYPE[];
         /** Special fee or cost weighting */
         costOptimization?: Partial<CostOptimizationConfig>;
     };
@@ -498,9 +498,9 @@ export interface ABTestExperiment {
         /** Regions to include */
         regions?: string[];
         /** User types to include */
-        userTypes?: USERTYPE[];
+        userTypes?: USER_TYPE[];
         /** Payment methods to include */
-        paymentMethods?: PAYMENTMETHOD[];
+        paymentMethods?: PAYMENT_METHOD[];
     };
     /** Start and end times */
     schedule?: {