@explorins/pers-shared 2.1.59 → 2.1.61

package/dist/cjs/shared-lib/errors/error-codes.js

@@ -38,29 +38,28 @@ exports.CommonErrorCodes = {
     MEMBERSHIP_NOT_FOUND: 'MEMBERSHIP_NOT_FOUND',
     MEMBERSHIP_ALREADY_EXISTS: 'MEMBERSHIP_ALREADY_EXISTS',
     MEMBERSHIP_LAST_OWNER: 'MEMBERSHIP_LAST_OWNER',
-    // Campaign domain
-    CAMPAIGN_NOT_FOUND: 'CAMPAIGN_NOT_FOUND',
-    CAMPAIGN_NOT_ACTIVE: 'CAMPAIGN_NOT_ACTIVE',
-    CAMPAIGN_NOT_STARTED: 'CAMPAIGN_NOT_STARTED',
-    CAMPAIGN_ENDED: 'CAMPAIGN_ENDED',
-    CAMPAIGN_NO_TRIGGER: 'CAMPAIGN_NO_TRIGGER',
-    CAMPAIGN_ALREADY_CLAIMED: 'CAMPAIGN_ALREADY_CLAIMED',
-    CAMPAIGN_CLAIM_LIMIT_REACHED: 'CAMPAIGN_CLAIM_LIMIT_REACHED',
-    CAMPAIGN_DAILY_LIMIT_REACHED: 'CAMPAIGN_DAILY_LIMIT_REACHED',
-    CAMPAIGN_COOLDOWN_ACTIVE: 'CAMPAIGN_COOLDOWN_ACTIVE',
-    CAMPAIGN_BUSINESS_REQUIRED: 'CAMPAIGN_BUSINESS_REQUIRED',
-    CAMPAIGN_CONDITION_NOT_MET: 'CAMPAIGN_CONDITION_NOT_MET',
-    CAMPAIGN_USER_INFO_REQUIRED: 'CAMPAIGN_USER_INFO_REQUIRED',
-    CAMPAIGN_DISTANCE_EXCEEDED: 'CAMPAIGN_DISTANCE_EXCEEDED',
-    CAMPAIGN_LOCATION_REQUIRED: 'CAMPAIGN_LOCATION_REQUIRED',
     // Transaction domain
     TRANSACTION_NOT_FOUND: 'TRANSACTION_NOT_FOUND',
     TRANSACTION_SIGNATURE_INVALID: 'TRANSACTION_SIGNATURE_INVALID',
     TRANSACTION_ALREADY_COMPLETED: 'TRANSACTION_ALREADY_COMPLETED',
     TRANSACTION_NOT_PENDING: 'TRANSACTION_NOT_PENDING',
-    TRANSACTION_VALIDATION_ERROR: 'TRANSACTION_VALIDATION_ERROR',
     TRANSACTION_EXPIRED: 'TRANSACTION_EXPIRED',
+    TRANSACTION_VALIDATION_ERROR: 'TRANSACTION_VALIDATION_ERROR',
     UNEXPECTED_VALIDATION_SCENARIO: 'UNEXPECTED_VALIDATION_SCENARIO',
+    // Campaign domain
+    CAMPAIGN_USER_INFO_REQUIRED: 'CAMPAIGN_USER_INFO_REQUIRED',
+    CAMPAIGN_BUSINESS_REQUIRED: 'CAMPAIGN_BUSINESS_REQUIRED',
+    CAMPAIGN_CONDITION_NOT_MET: 'CAMPAIGN_CONDITION_NOT_MET',
+    CAMPAIGN_ALREADY_CLAIMED: 'CAMPAIGN_ALREADY_CLAIMED',
+    CAMPAIGN_NO_TRIGGER: 'CAMPAIGN_NO_TRIGGER',
+    CAMPAIGN_LOCATION_REQUIRED: 'CAMPAIGN_LOCATION_REQUIRED',
+    CAMPAIGN_DISTANCE_EXCEEDED: 'CAMPAIGN_DISTANCE_EXCEEDED',
+    CAMPAIGN_NOT_ACTIVE: 'CAMPAIGN_NOT_ACTIVE',
+    CAMPAIGN_ENDED: 'CAMPAIGN_ENDED',
+    CAMPAIGN_NOT_STARTED: 'CAMPAIGN_NOT_STARTED',
+    CAMPAIGN_CLAIM_LIMIT_REACHED: 'CAMPAIGN_CLAIM_LIMIT_REACHED',
+    CAMPAIGN_COOLDOWN_ACTIVE: 'CAMPAIGN_COOLDOWN_ACTIVE',
+    CAMPAIGN_DAILY_LIMIT_REACHED: 'CAMPAIGN_DAILY_LIMIT_REACHED',
     // Technical errors
     TECHNICAL_ERROR: 'TECHNICAL_ERROR',
     ORCHESTRATION_ERROR: 'ORCHESTRATION_ERROR',
@@ -80,26 +79,25 @@ exports.CommonErrorCodes = {
     BUSINESS_RULE_VIOLATION: 'BUSINESS_RULE_VIOLATION',
     RESOURCE_NOT_FOUND: 'RESOURCE_NOT_FOUND'
 };
-// Import Domains from canonical location to extend for ErrorDomains
-const domains_1 = require("../types/domains");
-// ============================================================================
-// ERROR-SPECIFIC DOMAIN EXTENSIONS
-// ============================================================================
 /**
- * Extended domains for backend error classification.
- *
- * Includes all business domains from `Domains` plus error-specific categories
- * that don't represent user-facing business concepts.
+ * Domain names used in error classification
  *
- * Use `Domains` for SDK events and user-facing contexts.
- * Use `ErrorDomains` for backend error classification where system-level
- * categories are needed.
+ * Centralized domain strings to ensure consistency across all error classes
+ * and prevent typos in domain names.
  */
 exports.ErrorDomains = {
-    ...domains_1.Domains,
-    // Error-specific categories (not user-facing business domains)
+    USER: 'user',
+    TOKEN: 'token',
+    WALLET: 'wallet',
+    BUSINESS: 'business',
+    BALANCE: 'balance',
+    CONTRACT: 'contract',
+    TRANSACTION: 'transaction',
     VALIDATION: 'validation',
     SYSTEM: 'system',
+    CAMPAIGN: 'campaign',
+    AUTHENTICATION: 'authentication',
     EXTERNAL: 'external',
+    TENANT: 'tenant'
 };
 //# sourceMappingURL=error-codes.js.map

package/dist/cjs/shared-lib/errors/error-codes.js.map

@@ -1 +1 @@
-{"version":3,"file":"error-codes.js","sourceRoot":"","sources":["../../../../src/shared-lib/errors/error-codes.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAEU,QAAA,gBAAgB,GAAG;IAC9B,cAAc;IACd,cAAc,EAAE,gBAAgB;IAChC,mBAAmB,EAAE,qBAAqB;IAC1C,mBAAmB,EAAE,qBAAqB;IAE1C,eAAe;IACf,eAAe,EAAE,iBAAiB;IAClC,gBAAgB,EAAE,kBAAkB;IACpC,iBAAiB,EAAE,mBAAmB;IACtC,oBAAoB,EAAE,sBAAsB;IAE5C,gBAAgB;IAChB,sBAAsB,EAAE,wBAAwB;IAChD,gBAAgB,EAAE,kBAAkB;IACpC,8BAA8B,EAAE,gCAAgC;IAEhE,iBAAiB;IACjB,oBAAoB,EAAE,sBAAsB;IAE5C,kBAAkB;IAClB,kBAAkB,EAAE,oBAAoB;IAExC,kBAAkB;IAClB,kBAAkB,EAAE,oBAAoB;IACxC,mBAAmB,EAAE,qBAAqB;IAE1C,oBAAoB;IACpB,oBAAoB,EAAE,sBAAsB;IAC5C,yBAAyB,EAAE,2BAA2B;IACtD,qBAAqB,EAAE,uBAAuB;IAE9C,kBAAkB;IAClB,kBAAkB,EAAE,oBAAoB;IACxC,mBAAmB,EAAE,qBAAqB;IAC1C,oBAAoB,EAAE,sBAAsB;IAC5C,cAAc,EAAE,gBAAgB;IAChC,mBAAmB,EAAE,qBAAqB;IAC1C,wBAAwB,EAAE,0BAA0B;IACpD,4BAA4B,EAAE,8BAA8B;IAC5D,4BAA4B,EAAE,8BAA8B;IAC5D,wBAAwB,EAAE,0BAA0B;IACpD,0BAA0B,EAAE,4BAA4B;IACxD,0BAA0B,EAAE,4BAA4B;IACxD,2BAA2B,EAAE,6BAA6B;IAC1D,0BAA0B,EAAE,4BAA4B;IACxD,0BAA0B,EAAE,4BAA4B;IAExD,qBAAqB;IACrB,qBAAqB,EAAE,uBAAuB;IAC9C,6BAA6B,EAAE,+BAA+B;IAC9D,6BAA6B,EAAE,+BAA+B;IAC9D,uBAAuB,EAAE,yBAAyB;IAClD,4BAA4B,EAAE,8BAA8B;IAC5D,mBAAmB,EAAE,qBAAqB;IAC1C,8BAA8B,EAAE,gCAAgC;IAEhE,mBAAmB;IACnB,eAAe,EAAE,iBAAiB;IAClC,mBAAmB,EAAE,qBAAqB;IAE1C,gBAAgB;IAChB,YAAY,EAAE,cAAc;IAC5B,sBAAsB,EAAE,wBAAwB;IAChD,uBAAuB,EAAE,yBAAyB;IAClD,oBAAoB,EAAE,sBAAsB;IAE5C,iCAAiC;IACjC,aAAa,EAAE,eAAe;IAC9B,aAAa,EAAE,eAAe;IAC9B,aAAa,EAAE,eAAe;IAC9B,mBAAmB,EAAE,qBAAqB;IAE1C,oBAAoB;IACpB,cAAc,EAAE,gBAAgB;IAChC,gBAAgB,EAAE,kBAAkB;IACpC,uBAAuB,EAAE,yBAAyB;IAClD,kBAAkB,EAAE,oBAAoB;CAChC,CAAC;AAUX,oEAAoE;AACpE,8CAA2C;AAE3C,+EAA+E;AAC/E,mCAAmC;AACnC,+EAA+E;AAE/E;;;;;;;;;GASG;AACU,QAAA,YAAY,GAAG;IAC1B,GAAG,iBAAO;IACV,+DAA+D;IAC/D,UAAU,EAAE,YAAY;IACxB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,UAAU;CACZ,CAAC"}
+{"version":3,"file":"error-codes.js","sourceRoot":"","sources":["../../../../src/shared-lib/errors/error-codes.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAEU,QAAA,gBAAgB,GAAG;IAC9B,cAAc;IACd,cAAc,EAAE,gBAAgB;IAChC,mBAAmB,EAAE,qBAAqB;IAC1C,mBAAmB,EAAE,qBAAqB;IAE1C,eAAe;IACf,eAAe,EAAE,iBAAiB;IAClC,gBAAgB,EAAE,kBAAkB;IACpC,iBAAiB,EAAE,mBAAmB;IACtC,oBAAoB,EAAE,sBAAsB;IAE5C,gBAAgB;IAChB,sBAAsB,EAAE,wBAAwB;IAChD,gBAAgB,EAAE,kBAAkB;IACpC,8BAA8B,EAAE,gCAAgC;IAEhE,iBAAiB;IACjB,oBAAoB,EAAE,sBAAsB;IAE5C,kBAAkB;IAClB,kBAAkB,EAAE,oBAAoB;IAExC,kBAAkB;IAClB,kBAAkB,EAAE,oBAAoB;IACxC,mBAAmB,EAAE,qBAAqB;IAE1C,oBAAoB;IACpB,oBAAoB,EAAE,sBAAsB;IAC5C,yBAAyB,EAAE,2BAA2B;IACtD,qBAAqB,EAAE,uBAAuB;IAE9C,qBAAqB;IACrB,qBAAqB,EAAE,uBAAuB;IAC9C,6BAA6B,EAAE,+BAA+B;IAC9D,6BAA6B,EAAE,+BAA+B;IAC9D,uBAAuB,EAAE,yBAAyB;IAClD,mBAAmB,EAAE,qBAAqB;IAC1C,4BAA4B,EAAE,8BAA8B;IAC5D,8BAA8B,EAAE,gCAAgC;IAEhE,kBAAkB;IAClB,2BAA2B,EAAE,6BAA6B;IAC1D,0BAA0B,EAAE,4BAA4B;IACxD,0BAA0B,EAAE,4BAA4B;IACxD,wBAAwB,EAAE,0BAA0B;IACpD,mBAAmB,EAAE,qBAAqB;IAC1C,0BAA0B,EAAE,4BAA4B;IACxD,0BAA0B,EAAE,4BAA4B;IACxD,mBAAmB,EAAE,qBAAqB;IAC1C,cAAc,EAAE,gBAAgB;IAChC,oBAAoB,EAAE,sBAAsB;IAC5C,4BAA4B,EAAE,8BAA8B;IAC5D,wBAAwB,EAAE,0BAA0B;IACpD,4BAA4B,EAAE,8BAA8B;IAE5D,mBAAmB;IACnB,eAAe,EAAE,iBAAiB;IAClC,mBAAmB,EAAE,qBAAqB;IAE1C,gBAAgB;IAChB,YAAY,EAAE,cAAc;IAC5B,sBAAsB,EAAE,wBAAwB;IAChD,uBAAuB,EAAE,yBAAyB;IAClD,oBAAoB,EAAE,sBAAsB;IAE5C,iCAAiC;IACjC,aAAa,EAAE,eAAe;IAC9B,aAAa,EAAE,eAAe;IAC9B,aAAa,EAAE,eAAe;IAC9B,mBAAmB,EAAE,qBAAqB;IAE1C,oBAAoB;IACpB,cAAc,EAAE,gBAAgB;IAChC,gBAAgB,EAAE,kBAAkB;IACpC,uBAAuB,EAAE,yBAAyB;IAClD,kBAAkB,EAAE,oBAAoB;CAChC,CAAC;AAUX;;;;;GAKG;AACU,QAAA,YAAY,GAAG;IAC1B,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,WAAW,EAAE,aAAa;IAC1B,UAAU,EAAE,YAAY;IACxB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,UAAU;IACpB,cAAc,EAAE,gBAAgB;IAChC,QAAQ,EAAE,UAAU;IACpB,MAAM,EAAE,QAAQ;CACR,CAAC"}

package/dist/cjs/shared-lib/errors/index.d.ts

@@ -14,4 +14,5 @@ export * from './domains/authentication-errors';
 export * from './domains/signing-account-errors';
 export * from './domains/validation-errors';
 export * from './domains/tenant-errors';
+export * from './domains/campaign-errors';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/shared-lib/errors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shared-lib/errors/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,cAAc,EACd,YAAY,EACZ,YAAY,EACb,MAAM,uBAAuB,CAAC;AAE/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,8BAA8B,CAAC;AAG7C,cAAc,mCAAmC,CAAC;AAKlD,cAAc,eAAe,CAAC;AAG9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/shared-lib/errors/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,cAAc,EACd,YAAY,EACZ,YAAY,EACb,MAAM,uBAAuB,CAAC;AAE/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,8BAA8B,CAAC;AAG7C,cAAc,mCAAmC,CAAC;AAKlD,cAAc,eAAe,CAAC;AAG9B,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC"}

package/dist/cjs/shared-lib/errors/index.js

@@ -45,4 +45,5 @@ __exportStar(require("./domains/authentication-errors"), exports);
 __exportStar(require("./domains/signing-account-errors"), exports);
 __exportStar(require("./domains/validation-errors"), exports);
 __exportStar(require("./domains/tenant-errors"), exports);
+__exportStar(require("./domains/campaign-errors"), exports);
 //# sourceMappingURL=index.js.map

package/dist/cjs/shared-lib/errors/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/shared-lib/errors/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,oCAAoC;AACpC,6DAU+B;AAT7B,yHAAA,kBAAkB,OAAA;AAClB,sHAAA,eAAe,OAAA;AACf,sHAAA,eAAe,OAAA;AACf,qHAAA,cAAc,OAAA;AACd,0HAAA,mBAAmB,OAAA;AACnB,oHAAA,aAAa,OAAA;AACb,qHAAA,cAAc,OAAA;AACd,mHAAA,YAAY,OAAA;AACZ,mHAAA,YAAY,OAAA;AAGd,qDAAmC;AACnC,+DAA6C;AAE7C,8BAA8B;AAC9B,oEAAkD;AAElD,6EAA6E;AAE7E,4CAA4C;AAC5C,gDAA8B;AAE9B,+CAA+C;AAC/C,yDAAuC;AACvC,wDAAsC;AACtC,0DAAwC;AACxC,4DAA0C;AAC1C,2DAAyC;AACzC,4DAA0C;AAC1C,0DAAwC;AACxC,kEAAgD;AAChD,mEAAiD;AACjD,8DAA4C;AAC5C,0DAAwC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/shared-lib/errors/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,oCAAoC;AACpC,6DAU+B;AAT7B,yHAAA,kBAAkB,OAAA;AAClB,sHAAA,eAAe,OAAA;AACf,sHAAA,eAAe,OAAA;AACf,qHAAA,cAAc,OAAA;AACd,0HAAA,mBAAmB,OAAA;AACnB,oHAAA,aAAa,OAAA;AACb,qHAAA,cAAc,OAAA;AACd,mHAAA,YAAY,OAAA;AACZ,mHAAA,YAAY,OAAA;AAGd,qDAAmC;AACnC,+DAA6C;AAE7C,8BAA8B;AAC9B,oEAAkD;AAElD,6EAA6E;AAE7E,4CAA4C;AAC5C,gDAA8B;AAE9B,+CAA+C;AAC/C,yDAAuC;AACvC,wDAAsC;AACtC,0DAAwC;AACxC,4DAA0C;AAC1C,2DAAyC;AACzC,4DAA0C;AAC1C,0DAAwC;AACxC,kEAAgD;AAChD,mEAAiD;AACjD,8DAA4C;AAC5C,0DAAwC;AACxC,4DAA0C"}

package/dist/cjs/shared-patterns/errors/error-factory.d.ts

@@ -1,4 +1,15 @@
-import { UserNotFoundError, BusinessNotFoundError, TokenNotFoundError, TransactionNotFoundError, TransactionExpiredError, AuthenticationRequiredError, InvalidTokenError, TokenExpiredError, AuthorizationFailedError, InsufficientBalanceError, InvalidInputError, RequiredFieldError, InvalidFormatError, SystemError, ExternalServiceError, ConfigurationMissingError, TokenNotActiveError, TokenIdRequiredError, TokenTypeNotFoundError, TokenUnitNotFoundError, TransactionAlreadyCompletedError, TransactionNotPendingError, TransactionValidationError, SigningAccountValidationError, SigningAccountNotFoundError, SigningAccountAlreadyExistsError, KeyGenerationError, CampaignNotFoundError, CampaignNotActiveError, CampaignNotStartedError, CampaignEndedError, CampaignNoTriggerError, CampaignAlreadyClaimedError, CampaignClaimLimitReachedError, CampaignDailyLimitReachedError, CampaignCooldownActiveError, CampaignBusinessRequiredError, CampaignConditionNotMetError, CampaignUserInfoRequiredError, CampaignDistanceExceededError, CampaignLocationRequiredError, GeographicRestrictionError, LocationVerificationRequiredError, RedemptionLimitReachedError, UserStatusRestrictedError, WalletNotFoundError, WalletMissingSigningError, SmartWalletProcessingError, BusinessNotMinterError, UnexpectedValidationScenarioError, TenantNotFoundError, MembershipNotFoundError, MembershipAlreadyExistsError, MembershipLastOwnerError, MultipleContextSelectionRequiredError } from '../../shared-lib/errors';
+import { BusinessNotFoundError, BusinessNotMinterError, CampaignNotFoundError, MembershipNotFoundError, MembershipAlreadyExistsError, MembershipLastOwnerError, GeographicRestrictionError, LocationVerificationRequiredError, RedemptionLimitReachedError, UserStatusRestrictedError } from '../../shared-lib/errors/domains/business-errors';
+import { UserNotFoundError } from '../../shared-lib/errors/domains/user-errors';
+import { TokenNotFoundError, TokenNotActiveError, TokenIdRequiredError, TokenTypeNotFoundError, TokenUnitNotFoundError } from '../../shared-lib/errors/domains/token-errors';
+import { TransactionNotFoundError, TransactionAlreadyCompletedError, TransactionNotPendingError, TransactionValidationError, UnexpectedValidationScenarioError, TransactionExpiredError } from '../../shared-lib/errors/domains/transaction-errors';
+import { AuthenticationRequiredError, InvalidTokenError, TokenExpiredError, AuthorizationFailedError, MultipleContextSelectionRequiredError } from '../../shared-lib/errors/domains/authentication-errors';
+import { InsufficientBalanceError } from '../../shared-lib/errors/domains/balance-errors';
+import { InvalidInputError, RequiredFieldError, InvalidFormatError } from '../../shared-lib/errors/domains/validation-errors';
+import { SystemError, ExternalServiceError, ConfigurationMissingError } from '../../shared-lib/errors/domains/system-errors';
+import { SigningAccountValidationError, SigningAccountNotFoundError, SigningAccountAlreadyExistsError, KeyGenerationError } from '../../shared-lib/errors/domains/signing-account-errors';
+import { WalletNotFoundError, WalletMissingSigningError, SmartWalletProcessingError } from '../../shared-lib/errors/domains/wallet-errors';
+import { TenantNotFoundError } from '../../shared-lib/errors/domains/tenant-errors';
+import { CampaignUserInfoRequiredError, CampaignBusinessRequiredError, CampaignConditionNotMetError, CampaignAlreadyClaimedError, CampaignNoTriggerError, CampaignLocationRequiredError, CampaignDistanceExceededError, CampaignNotActiveError, CampaignEndedError, CampaignNotStartedError, CampaignClaimLimitReachedError, CampaignCooldownActiveError, CampaignDailyLimitReachedError } from '../../shared-lib/errors/domains/campaign-errors';
 /**
  * Convenient shortcut object for the most commonly used error patterns
  * Provides clean, discoverable API for NestJS applications
@@ -11,23 +22,23 @@ export declare const Errors: {
     transactionNotFound: (id: string) => TransactionNotFoundError;
     campaignNotFound: (id: string) => CampaignNotFoundError;
     tenantNotFound: (id: string) => TenantNotFoundError;
+    campaignUserInfoRequired: (field: string) => CampaignUserInfoRequiredError;
+    campaignBusinessRequired: (action: string) => CampaignBusinessRequiredError;
+    campaignConditionNotMet: (condition: string, details?: string) => CampaignConditionNotMetError;
+    campaignAlreadyClaimed: (scope: string, name?: string) => CampaignAlreadyClaimedError;
+    campaignNoTrigger: () => CampaignNoTriggerError;
+    campaignLocationRequired: () => CampaignLocationRequiredError;
+    campaignDistanceExceeded: (max: number) => CampaignDistanceExceededError;
+    campaignNotActive: (id: string) => CampaignNotActiveError;
+    campaignEnded: (date: Date) => CampaignEndedError;
+    campaignNotStarted: (date: Date) => CampaignNotStartedError;
+    campaignClaimLimitReached: (limit: number, current: number) => CampaignClaimLimitReachedError;
+    campaignCooldownActive: (seconds: number) => CampaignCooldownActiveError;
+    campaignDailyLimitReached: (limit: number, current: number) => CampaignDailyLimitReachedError;
     authRequired: (resource?: string) => AuthenticationRequiredError;
     invalidToken: (reason?: string) => InvalidTokenError;
     tokenExpired: () => TokenExpiredError;
     forbidden: (action: string, resource: string) => AuthorizationFailedError;
-    campaignNotActive: (campaignId?: string) => CampaignNotActiveError;
-    campaignNotStarted: (startDate: Date) => CampaignNotStartedError;
-    campaignEnded: (endDate: Date) => CampaignEndedError;
-    campaignNoTrigger: () => CampaignNoTriggerError;
-    campaignAlreadyClaimed: (context?: "business" | "user", businessName?: string) => CampaignAlreadyClaimedError;
-    campaignClaimLimitReached: (maxClaims: number, currentClaims: number) => CampaignClaimLimitReachedError;
-    campaignDailyLimitReached: (maxPerDay: number, todayClaims: number) => CampaignDailyLimitReachedError;
-    campaignCooldownActive: (cooldownSeconds: number) => CampaignCooldownActiveError;
-    campaignBusinessRequired: (requirementType?: "claim" | "engagement") => CampaignBusinessRequiredError;
-    campaignConditionNotMet: (conditionKey: string, reason?: string) => CampaignConditionNotMetError;
-    campaignUserInfoRequired: (requiredField: string) => CampaignUserInfoRequiredError;
-    campaignDistanceExceeded: (maxDistanceMeters: number) => CampaignDistanceExceededError;
-    campaignLocationRequired: () => CampaignLocationRequiredError;
     geographicRestriction: (countryCode: string, resource?: string) => GeographicRestrictionError;
     locationRequired: (resource?: string) => LocationVerificationRequiredError;
     limitReached: (limitType: "max_redemption" | "user_limit") => RedemptionLimitReachedError;
@@ -45,7 +56,7 @@ export declare const Errors: {
     transactionAlreadyCompleted: (id: string, status: string) => TransactionAlreadyCompletedError;
     transactionNotPending: (id: string, status: string) => TransactionNotPendingError;
     transactionValidation: (field: string, reason: string) => TransactionValidationError;
-    transactionExpired: (deadline: number, current: number, walletAddress?: string) => TransactionExpiredError;
+    transactionExpired: (deadline: number, current: number, context: string) => TransactionExpiredError;
     signingAccountValidation: (field: string, reason: string) => SigningAccountValidationError;
     signingAccountNotFound: (id: string) => SigningAccountNotFoundError;
     signingAccountAlreadyExists: (address: string) => SigningAccountAlreadyExistsError;

package/dist/cjs/shared-patterns/errors/error-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-factory.d.ts","sourceRoot":"","sources":["../../../../src/shared-patterns/errors/error-factory.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"error-factory.d.ts","sourceRoot":"","sources":["../../../../src/shared-patterns/errors/error-factory.ts"],"names":[],"mappings":"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"}

package/dist/cjs/shared-patterns/errors/error-factory.js

@@ -1,7 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorBuilder = exports.Errors = void 0;
-const errors_1 = require("../../shared-lib/errors");
+// Import directly from source files (not the barrel which only exports types)
+const business_errors_1 = require("../../shared-lib/errors/domains/business-errors");
+const user_errors_1 = require("../../shared-lib/errors/domains/user-errors");
+const token_errors_1 = require("../../shared-lib/errors/domains/token-errors");
+const transaction_errors_1 = require("../../shared-lib/errors/domains/transaction-errors");
+const authentication_errors_1 = require("../../shared-lib/errors/domains/authentication-errors");
+const balance_errors_1 = require("../../shared-lib/errors/domains/balance-errors");
+const validation_errors_1 = require("../../shared-lib/errors/domains/validation-errors");
+const system_errors_1 = require("../../shared-lib/errors/domains/system-errors");
+const signing_account_errors_1 = require("../../shared-lib/errors/domains/signing-account-errors");
+const wallet_errors_1 = require("../../shared-lib/errors/domains/wallet-errors");
+const tenant_errors_1 = require("../../shared-lib/errors/domains/tenant-errors");
+const campaign_errors_1 = require("../../shared-lib/errors/domains/campaign-errors");
 /**
  * Universal Error Factory for NestJS Applications
  *
@@ -20,209 +32,212 @@ class ErrorFactory {
      * Uses domain classes internally for consistency
      */
     static userNotFound(identifier) {
-        return new errors_1.UserNotFoundError(identifier);
+        return new user_errors_1.UserNotFoundError(identifier);
     }
     static businessNotFound(identifier) {
-        return new errors_1.BusinessNotFoundError(identifier);
+        return new business_errors_1.BusinessNotFoundError(identifier);
     }
     static tokenNotFound(tokenId) {
-        return new errors_1.TokenNotFoundError(tokenId);
+        return new token_errors_1.TokenNotFoundError(tokenId);
     }
     static transactionNotFound(transactionId) {
-        return new errors_1.TransactionNotFoundError(transactionId);
+        return new transaction_errors_1.TransactionNotFoundError(transactionId);
     }
     static campaignNotFound(campaignId) {
-        return new errors_1.CampaignNotFoundError(campaignId);
+        return new business_errors_1.CampaignNotFoundError(campaignId);
     }
-    static campaignNotActive(campaignId) {
-        return new errors_1.CampaignNotActiveError(campaignId);
+    static tenantNotFound(tenantId) {
+        return new tenant_errors_1.TenantNotFoundError(tenantId);
     }
-    static campaignNotStarted(startDate) {
-        return new errors_1.CampaignNotStartedError(startDate);
+    static tokenUnitNotFound(tokenUnitId) {
+        return new token_errors_1.TokenUnitNotFoundError(tokenUnitId);
     }
-    static campaignEnded(endDate) {
-        return new errors_1.CampaignEndedError(endDate);
+    /**
+     * Campaign patterns
+     */
+    static campaignUserInfoRequired(requiredField) {
+        return new campaign_errors_1.CampaignUserInfoRequiredError(requiredField);
     }
-    static campaignNoTrigger() {
-        return new errors_1.CampaignNoTriggerError();
+    static campaignBusinessRequired(action) {
+        return new campaign_errors_1.CampaignBusinessRequiredError(action);
     }
-    static campaignAlreadyClaimed(context = 'user', businessName) {
-        return new errors_1.CampaignAlreadyClaimedError(context, businessName);
+    static campaignConditionNotMet(condition, details) {
+        return new campaign_errors_1.CampaignConditionNotMetError(condition, details);
     }
-    static campaignClaimLimitReached(maxClaims, currentClaims) {
-        return new errors_1.CampaignClaimLimitReachedError(maxClaims, currentClaims);
+    static campaignAlreadyClaimed(scope, name) {
+        return new campaign_errors_1.CampaignAlreadyClaimedError(scope, name);
     }
-    static campaignDailyLimitReached(maxPerDay, todayClaims) {
-        return new errors_1.CampaignDailyLimitReachedError(maxPerDay, todayClaims);
+    static campaignNoTrigger() {
+        return new campaign_errors_1.CampaignNoTriggerError();
     }
-    static campaignCooldownActive(cooldownSeconds) {
-        return new errors_1.CampaignCooldownActiveError(cooldownSeconds);
+    static campaignLocationRequired() {
+        return new campaign_errors_1.CampaignLocationRequiredError();
     }
-    static campaignBusinessRequired(requirementType = 'claim') {
-        return new errors_1.CampaignBusinessRequiredError(requirementType);
+    static campaignDistanceExceeded(maxDistance) {
+        return new campaign_errors_1.CampaignDistanceExceededError(maxDistance);
     }
-    static campaignConditionNotMet(conditionKey, reason) {
-        return new errors_1.CampaignConditionNotMetError(conditionKey, reason);
+    static campaignNotActive(campaignId) {
+        return new campaign_errors_1.CampaignNotActiveError(campaignId);
     }
-    static campaignUserInfoRequired(requiredField) {
-        return new errors_1.CampaignUserInfoRequiredError(requiredField);
+    static campaignEnded(endDate) {
+        return new campaign_errors_1.CampaignEndedError(endDate);
     }
-    static campaignDistanceExceeded(maxDistanceMeters) {
-        return new errors_1.CampaignDistanceExceededError(maxDistanceMeters);
+    static campaignNotStarted(startDate) {
+        return new campaign_errors_1.CampaignNotStartedError(startDate);
     }
-    static campaignLocationRequired() {
-        return new errors_1.CampaignLocationRequiredError();
+    static campaignClaimLimitReached(limit, current) {
+        return new campaign_errors_1.CampaignClaimLimitReachedError(limit, current);
     }
-    static tenantNotFound(tenantId) {
-        return new errors_1.TenantNotFoundError(tenantId);
+    static campaignCooldownActive(remainingSeconds) {
+        return new campaign_errors_1.CampaignCooldownActiveError(remainingSeconds);
     }
-    static tokenUnitNotFound(tokenUnitId) {
-        return new errors_1.TokenUnitNotFoundError(tokenUnitId);
+    static campaignDailyLimitReached(limit, current) {
+        return new campaign_errors_1.CampaignDailyLimitReachedError(limit, current);
     }
     /**
      * Authentication & Authorization patterns
      */
     static authRequired(resource) {
-        return new errors_1.AuthenticationRequiredError(resource || 'this resource');
+        return new authentication_errors_1.AuthenticationRequiredError(resource || 'this resource');
     }
     static invalidToken(reason) {
-        return new errors_1.InvalidTokenError(reason);
+        return new authentication_errors_1.InvalidTokenError(reason);
     }
     static tokenExpired() {
-        return new errors_1.TokenExpiredError();
+        return new authentication_errors_1.TokenExpiredError();
     }
     static forbidden(action, resource) {
-        return new errors_1.AuthorizationFailedError(action, resource);
+        return new authentication_errors_1.AuthorizationFailedError(action, resource);
     }
     /**
      * Business rule patterns
      */
     static geographicRestriction(countryCode, resource) {
-        return new errors_1.GeographicRestrictionError(countryCode, resource);
+        return new business_errors_1.GeographicRestrictionError(countryCode, resource);
     }
     static locationRequired(resource) {
-        return new errors_1.LocationVerificationRequiredError(resource);
+        return new business_errors_1.LocationVerificationRequiredError(resource);
     }
     static limitReached(limitType) {
-        return new errors_1.RedemptionLimitReachedError(limitType);
+        return new business_errors_1.RedemptionLimitReachedError(limitType);
     }
     static userStatusRestricted() {
-        return new errors_1.UserStatusRestrictedError();
+        return new business_errors_1.UserStatusRestrictedError();
     }
     /**
      * Validation patterns
      */
     static invalidInput(field, reason) {
-        return new errors_1.InvalidInputError(field, reason);
+        return new validation_errors_1.InvalidInputError(field, reason);
     }
     static requiredField(field) {
-        return new errors_1.RequiredFieldError(field);
+        return new validation_errors_1.RequiredFieldError(field);
     }
     static invalidFormat(field, expectedFormat) {
-        return new errors_1.InvalidFormatError(field, expectedFormat);
+        return new validation_errors_1.InvalidFormatError(field, expectedFormat);
     }
     /**
      * Financial/Balance patterns
      */
     static insufficientBalance(required, available) {
-        return new errors_1.InsufficientBalanceError(required, available);
+        return new balance_errors_1.InsufficientBalanceError(required, available);
     }
     /**
      * Technical/Infrastructure patterns
      */
     static systemError(operation, details) {
-        return new errors_1.SystemError(operation, details);
+        return new system_errors_1.SystemError(operation, details);
     }
     static externalServiceError(serviceName, operation) {
-        return new errors_1.ExternalServiceError(serviceName, operation);
+        return new system_errors_1.ExternalServiceError(serviceName, operation);
     }
     static configMissing(configKey) {
-        return new errors_1.ConfigurationMissingError(configKey);
+        return new system_errors_1.ConfigurationMissingError(configKey);
     }
     /**
      * Token-specific patterns
      */
     static tokenNotActive(tokenId) {
-        return new errors_1.TokenNotActiveError(tokenId);
+        return new token_errors_1.TokenNotActiveError(tokenId);
     }
     static tokenIdRequired(tokenType) {
-        return new errors_1.TokenIdRequiredError(tokenType);
+        return new token_errors_1.TokenIdRequiredError(tokenType);
     }
     static tokenTypeNotFound(tokenType) {
-        return new errors_1.TokenTypeNotFoundError(tokenType);
+        return new token_errors_1.TokenTypeNotFoundError(tokenType);
     }
     /**
      * Transaction-specific patterns
      */
     static transactionAlreadyCompleted(transactionId, currentStatus) {
-        return new errors_1.TransactionAlreadyCompletedError(transactionId, currentStatus);
+        return new transaction_errors_1.TransactionAlreadyCompletedError(transactionId, currentStatus);
     }
     static transactionNotPending(transactionId, currentStatus) {
-        return new errors_1.TransactionNotPendingError(transactionId, currentStatus);
+        return new transaction_errors_1.TransactionNotPendingError(transactionId, currentStatus);
     }
     static transactionValidation(field, reason) {
-        return new errors_1.TransactionValidationError(field, reason);
+        return new transaction_errors_1.TransactionValidationError(field, reason);
     }
-    static transactionExpired(deadlineTimestamp, currentTimestamp, walletAddress) {
-        return new errors_1.TransactionExpiredError(deadlineTimestamp, currentTimestamp, walletAddress);
+    static transactionExpired(deadline, current, context) {
+        return new transaction_errors_1.TransactionExpiredError(deadline, current, context);
     }
     /**
      * Signing account patterns
      */
     static signingAccountValidation(field, reason) {
-        return new errors_1.SigningAccountValidationError(field, reason);
+        return new signing_account_errors_1.SigningAccountValidationError(field, reason);
     }
     static signingAccountNotFound(identifier) {
-        return new errors_1.SigningAccountNotFoundError(identifier);
+        return new signing_account_errors_1.SigningAccountNotFoundError(identifier);
     }
     static signingAccountAlreadyExists(accountAddress) {
-        return new errors_1.SigningAccountAlreadyExistsError(accountAddress);
+        return new signing_account_errors_1.SigningAccountAlreadyExistsError(accountAddress);
     }
     static keyGeneration(reason) {
-        return new errors_1.KeyGenerationError(reason);
+        return new signing_account_errors_1.KeyGenerationError(reason);
     }
     /**
      * Wallet patterns
      */
     static walletNotFound(ownerAddress) {
-        return new errors_1.WalletNotFoundError(ownerAddress);
+        return new wallet_errors_1.WalletNotFoundError(ownerAddress);
     }
     static walletMissingSigning(walletAddress, reason) {
-        return new errors_1.WalletMissingSigningError(walletAddress, reason);
+        return new wallet_errors_1.WalletMissingSigningError(walletAddress, reason);
     }
     static smartWalletProcessing(reason) {
-        return new errors_1.SmartWalletProcessingError(reason);
+        return new wallet_errors_1.SmartWalletProcessingError(reason);
     }
     /**
      * Business patterns
      */
     static businessNotMinter(businessId, tokenAddress) {
-        return new errors_1.BusinessNotMinterError(businessId, tokenAddress);
+        return new business_errors_1.BusinessNotMinterError(businessId, tokenAddress);
     }
     /**
      * Membership patterns (generic - works for business, tenant, etc.)
      */
     static membershipNotFound(userId, entityId, entityType = 'entity') {
-        return new errors_1.MembershipNotFoundError(userId, entityId, entityType);
+        return new business_errors_1.MembershipNotFoundError(userId, entityId, entityType);
     }
     static membershipAlreadyExists(userId, entityId, entityType = 'entity') {
-        return new errors_1.MembershipAlreadyExistsError(userId, entityId, entityType);
+        return new business_errors_1.MembershipAlreadyExistsError(userId, entityId, entityType);
     }
     static membershipLastOwner(entityId, entityType = 'entity') {
-        return new errors_1.MembershipLastOwnerError(entityId, entityType);
+        return new business_errors_1.MembershipLastOwnerError(entityId, entityType);
     }
     /**
      * Multiple context selection required (business/tenant)
      * Used when user has access to multiple entities and must explicitly select one
      */
     static multipleContextSelectionRequired(contextType, availableOptions) {
-        return new errors_1.MultipleContextSelectionRequiredError(contextType, availableOptions);
+        return new authentication_errors_1.MultipleContextSelectionRequiredError(contextType, availableOptions);
     }
     /**
      * Validation patterns
      */
     static unexpectedValidationScenario(context) {
-        return new errors_1.UnexpectedValidationScenarioError(context);
+        return new transaction_errors_1.UnexpectedValidationScenarioError(context);
     }
 }
 /**
@@ -238,25 +253,25 @@ exports.Errors = {
     transactionNotFound: (id) => ErrorFactory.transactionNotFound(id),
     campaignNotFound: (id) => ErrorFactory.campaignNotFound(id),
     tenantNotFound: (id) => ErrorFactory.tenantNotFound(id),
+    // Campaign
+    campaignUserInfoRequired: (field) => ErrorFactory.campaignUserInfoRequired(field),
+    campaignBusinessRequired: (action) => ErrorFactory.campaignBusinessRequired(action),
+    campaignConditionNotMet: (condition, details) => ErrorFactory.campaignConditionNotMet(condition, details),
+    campaignAlreadyClaimed: (scope, name) => ErrorFactory.campaignAlreadyClaimed(scope, name),
+    campaignNoTrigger: () => ErrorFactory.campaignNoTrigger(),
+    campaignLocationRequired: () => ErrorFactory.campaignLocationRequired(),
+    campaignDistanceExceeded: (max) => ErrorFactory.campaignDistanceExceeded(max),
+    campaignNotActive: (id) => ErrorFactory.campaignNotActive(id),
+    campaignEnded: (date) => ErrorFactory.campaignEnded(date),
+    campaignNotStarted: (date) => ErrorFactory.campaignNotStarted(date),
+    campaignClaimLimitReached: (limit, current) => ErrorFactory.campaignClaimLimitReached(limit, current),
+    campaignCooldownActive: (seconds) => ErrorFactory.campaignCooldownActive(seconds),
+    campaignDailyLimitReached: (limit, current) => ErrorFactory.campaignDailyLimitReached(limit, current),
     // Authentication
     authRequired: (resource) => ErrorFactory.authRequired(resource),
     invalidToken: (reason) => ErrorFactory.invalidToken(reason),
     tokenExpired: () => ErrorFactory.tokenExpired(),
     forbidden: (action, resource) => ErrorFactory.forbidden(action, resource),
-    // Campaign claim errors
-    campaignNotActive: (campaignId) => ErrorFactory.campaignNotActive(campaignId),
-    campaignNotStarted: (startDate) => ErrorFactory.campaignNotStarted(startDate),
-    campaignEnded: (endDate) => ErrorFactory.campaignEnded(endDate),
-    campaignNoTrigger: () => ErrorFactory.campaignNoTrigger(),
-    campaignAlreadyClaimed: (context = 'user', businessName) => ErrorFactory.campaignAlreadyClaimed(context, businessName),
-    campaignClaimLimitReached: (maxClaims, currentClaims) => ErrorFactory.campaignClaimLimitReached(maxClaims, currentClaims),
-    campaignDailyLimitReached: (maxPerDay, todayClaims) => ErrorFactory.campaignDailyLimitReached(maxPerDay, todayClaims),
-    campaignCooldownActive: (cooldownSeconds) => ErrorFactory.campaignCooldownActive(cooldownSeconds),
-    campaignBusinessRequired: (requirementType = 'claim') => ErrorFactory.campaignBusinessRequired(requirementType),
-    campaignConditionNotMet: (conditionKey, reason) => ErrorFactory.campaignConditionNotMet(conditionKey, reason),
-    campaignUserInfoRequired: (requiredField) => ErrorFactory.campaignUserInfoRequired(requiredField),
-    campaignDistanceExceeded: (maxDistanceMeters) => ErrorFactory.campaignDistanceExceeded(maxDistanceMeters),
-    campaignLocationRequired: () => ErrorFactory.campaignLocationRequired(),
     // Business rules
     geographicRestriction: (countryCode, resource) => ErrorFactory.geographicRestriction(countryCode, resource),
     locationRequired: (resource) => ErrorFactory.locationRequired(resource),
@@ -280,7 +295,7 @@ exports.Errors = {
     transactionAlreadyCompleted: (id, status) => ErrorFactory.transactionAlreadyCompleted(id, status),
     transactionNotPending: (id, status) => ErrorFactory.transactionNotPending(id, status),
     transactionValidation: (field, reason) => ErrorFactory.transactionValidation(field, reason),
-    transactionExpired: (deadline, current, walletAddress) => ErrorFactory.transactionExpired(deadline, current, walletAddress),
+    transactionExpired: (deadline, current, context) => ErrorFactory.transactionExpired(deadline, current, context),
     // Signing account
     signingAccountValidation: (field, reason) => ErrorFactory.signingAccountValidation(field, reason),
     signingAccountNotFound: (id) => ErrorFactory.signingAccountNotFound(id),
@@ -329,16 +344,16 @@ class ErrorBuilder {
     }
     // Convenience methods for common error types
     buildUserNotFound(id) {
-        return new errors_1.UserNotFoundError(id);
+        return new user_errors_1.UserNotFoundError(id);
     }
     buildBusinessNotFound(id) {
-        return new errors_1.BusinessNotFoundError(id);
+        return new business_errors_1.BusinessNotFoundError(id);
     }
     buildTenantNotFound(id) {
-        return new errors_1.TenantNotFoundError(id);
+        return new tenant_errors_1.TenantNotFoundError(id);
     }
     buildAuthRequired(resource) {
-        return new errors_1.AuthenticationRequiredError(resource);
+        return new authentication_errors_1.AuthenticationRequiredError(resource);
     }
 }
 exports.ErrorBuilder = ErrorBuilder;