@mpgd/platform 0.19.0 → 0.20.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/dist/commerce-conformance.d.ts +136 -4
  2. package/dist/commerce-conformance.js +485 -24
  3. package/dist/commerce-contract.d.ts +222 -0
  4. package/dist/commerce-contract.js +1 -0
  5. package/dist/commerce-vectors.d.ts +8 -0
  6. package/dist/commerce-vectors.js +38 -33
  7. package/dist/commerce.d.ts +3 -145
  8. package/dist/commerce.js +228 -228
  9. package/dist/index.d.ts +8 -0
  10. package/package.json +1 -1
package/dist/commerce.js CHANGED
@@ -293,32 +293,32 @@ export const assertStoreProduct = (() => {
293
293
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
294
294
  method: "typia.createAssertEquals",
295
295
  path: _path + ".logicalId",
296
- expected: "string & MinLength<1>",
296
+ expected: "string & CommerceMinLength<1>",
297
297
  value: input.logicalId
298
298
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
299
299
  method: "typia.createAssertEquals",
300
300
  path: _path + ".logicalId",
301
- expected: "(string & MinLength<1>)",
301
+ expected: "(string & CommerceMinLength<1>)",
302
302
  value: input.logicalId
303
303
  }, _errorFactory)) && ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
304
304
  method: "typia.createAssertEquals",
305
305
  path: _path + ".store",
306
- expected: "string & MinLength<1>",
306
+ expected: "string & CommerceMinLength<1>",
307
307
  value: input.store
308
308
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
309
309
  method: "typia.createAssertEquals",
310
310
  path: _path + ".store",
311
- expected: "(string & MinLength<1>)",
311
+ expected: "(string & CommerceMinLength<1>)",
312
312
  value: input.store
313
313
  }, _errorFactory)) && ("string" === typeof input.storeSku && (1 <= input.storeSku.length || _assertGuard_1._assertGuard(_exceptionable, {
314
314
  method: "typia.createAssertEquals",
315
315
  path: _path + ".storeSku",
316
- expected: "string & MinLength<1>",
316
+ expected: "string & CommerceMinLength<1>",
317
317
  value: input.storeSku
318
318
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
319
319
  method: "typia.createAssertEquals",
320
320
  path: _path + ".storeSku",
321
- expected: "(string & MinLength<1>)",
321
+ expected: "(string & CommerceMinLength<1>)",
322
322
  value: input.storeSku
323
323
  }, _errorFactory)) && ("consumable" === input.kind || "durable" === input.kind || "subscription" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
324
324
  method: "typia.createAssertEquals",
@@ -386,22 +386,22 @@ export const assertStoreProduct = (() => {
386
386
  }, _errorFactory)) && ("string" === typeof input.currencyCode && (1 <= input.currencyCode.length || _assertGuard_1._assertGuard(_exceptionable, {
387
387
  method: "typia.createAssertEquals",
388
388
  path: _path + ".currencyCode",
389
- expected: "string & MinLength<1>",
389
+ expected: "string & CommerceMinLength<1>",
390
390
  value: input.currencyCode
391
391
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
392
392
  method: "typia.createAssertEquals",
393
393
  path: _path + ".currencyCode",
394
- expected: "(string & MinLength<1>)",
394
+ expected: "(string & CommerceMinLength<1>)",
395
395
  value: input.currencyCode
396
396
  }, _errorFactory)) && (undefined === input.amountMicros || "number" === typeof input.amountMicros && (_isTypeInt64_1._isTypeInt64(input.amountMicros) || _assertGuard_1._assertGuard(_exceptionable, {
397
397
  method: "typia.createAssertEquals",
398
398
  path: _path + ".amountMicros",
399
- expected: "number & Type<\"int64\">",
399
+ expected: "number & CommerceInt64",
400
400
  value: input.amountMicros
401
401
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
402
402
  method: "typia.createAssertEquals",
403
403
  path: _path + ".amountMicros",
404
- expected: "((number & Type<\"int64\">) | undefined)",
404
+ expected: "((number & CommerceInt64) | undefined)",
405
405
  value: input.amountMicros
406
406
  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
407
407
  if (["formatted", "currencyCode", "amountMicros"].some(prop => key === prop))
@@ -419,12 +419,12 @@ export const assertStoreProduct = (() => {
419
419
  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.offerId && (1 <= input.offerId.length || _assertGuard_1._assertGuard(_exceptionable, {
420
420
  method: "typia.createAssertEquals",
421
421
  path: _path + ".offerId",
422
- expected: "string & MinLength<1>",
422
+ expected: "string & CommerceMinLength<1>",
423
423
  value: input.offerId
424
424
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
425
425
  method: "typia.createAssertEquals",
426
426
  path: _path + ".offerId",
427
- expected: "(string & MinLength<1>)",
427
+ expected: "(string & CommerceMinLength<1>)",
428
428
  value: input.offerId
429
429
  }, _errorFactory)) && (("object" === typeof input.price && null !== input.price || _assertGuard_1._assertGuard(_exceptionable, {
430
430
  method: "typia.createAssertEquals",
@@ -534,67 +534,67 @@ export const assertStorePurchase = (() => {
534
534
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
535
535
  method: "typia.createAssertEquals",
536
536
  path: _path + ".store",
537
- expected: "string & MinLength<1>",
537
+ expected: "string & CommerceMinLength<1>",
538
538
  value: input.store
539
539
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
540
540
  method: "typia.createAssertEquals",
541
541
  path: _path + ".store",
542
- expected: "(string & MinLength<1>)",
542
+ expected: "(string & CommerceMinLength<1>)",
543
543
  value: input.store
544
544
  }, _errorFactory)) && ("string" === typeof input.transactionId && (1 <= input.transactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
545
545
  method: "typia.createAssertEquals",
546
546
  path: _path + ".transactionId",
547
- expected: "string & MinLength<1>",
547
+ expected: "string & CommerceMinLength<1>",
548
548
  value: input.transactionId
549
549
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
550
550
  method: "typia.createAssertEquals",
551
551
  path: _path + ".transactionId",
552
- expected: "(string & MinLength<1>)",
552
+ expected: "(string & CommerceMinLength<1>)",
553
553
  value: input.transactionId
554
554
  }, _errorFactory)) && (undefined === input.originalTransactionId || "string" === typeof input.originalTransactionId && (1 <= input.originalTransactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
555
555
  method: "typia.createAssertEquals",
556
556
  path: _path + ".originalTransactionId",
557
- expected: "string & MinLength<1>",
557
+ expected: "string & CommerceMinLength<1>",
558
558
  value: input.originalTransactionId
559
559
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
560
560
  method: "typia.createAssertEquals",
561
561
  path: _path + ".originalTransactionId",
562
- expected: "((string & MinLength<1>) | undefined)",
562
+ expected: "((string & CommerceMinLength<1>) | undefined)",
563
563
  value: input.originalTransactionId
564
564
  }, _errorFactory)) && ("string" === typeof input.storeSku && (1 <= input.storeSku.length || _assertGuard_1._assertGuard(_exceptionable, {
565
565
  method: "typia.createAssertEquals",
566
566
  path: _path + ".storeSku",
567
- expected: "string & MinLength<1>",
567
+ expected: "string & CommerceMinLength<1>",
568
568
  value: input.storeSku
569
569
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
570
570
  method: "typia.createAssertEquals",
571
571
  path: _path + ".storeSku",
572
- expected: "(string & MinLength<1>)",
572
+ expected: "(string & CommerceMinLength<1>)",
573
573
  value: input.storeSku
574
574
  }, _errorFactory)) && (undefined === input.logicalId || "string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
575
575
  method: "typia.createAssertEquals",
576
576
  path: _path + ".logicalId",
577
- expected: "string & MinLength<1>",
577
+ expected: "string & CommerceMinLength<1>",
578
578
  value: input.logicalId
579
579
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
580
580
  method: "typia.createAssertEquals",
581
581
  path: _path + ".logicalId",
582
- expected: "((string & MinLength<1>) | undefined)",
582
+ expected: "((string & CommerceMinLength<1>) | undefined)",
583
583
  value: input.logicalId
584
584
  }, _errorFactory)) && ("number" === typeof input.quantity && (_isTypeUint32_1._isTypeUint32(input.quantity) || _assertGuard_1._assertGuard(_exceptionable, {
585
585
  method: "typia.createAssertEquals",
586
586
  path: _path + ".quantity",
587
- expected: "number & Type<\"uint32\">",
587
+ expected: "number & CommerceUint32",
588
588
  value: input.quantity
589
589
  }, _errorFactory)) && (1 <= input.quantity || _assertGuard_1._assertGuard(_exceptionable, {
590
590
  method: "typia.createAssertEquals",
591
591
  path: _path + ".quantity",
592
- expected: "number & Minimum<1>",
592
+ expected: "number & CommerceMinimum<1>",
593
593
  value: input.quantity
594
594
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
595
595
  method: "typia.createAssertEquals",
596
596
  path: _path + ".quantity",
597
- expected: "(number & Type<\"uint32\"> & Minimum<1>)",
597
+ expected: "(number & CommerceUint32 & CommerceMinimum<1>)",
598
598
  value: input.quantity
599
599
  }, _errorFactory)) && ("pending" === input.state || "purchased" === input.state || "revoked" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
600
600
  method: "typia.createAssertEquals",
@@ -604,22 +604,22 @@ export const assertStorePurchase = (() => {
604
604
  }, _errorFactory)) && (undefined === input.purchasedAt || "string" === typeof input.purchasedAt && (_isFormatDateTime_1._isFormatDateTime(input.purchasedAt) || _assertGuard_1._assertGuard(_exceptionable, {
605
605
  method: "typia.createAssertEquals",
606
606
  path: _path + ".purchasedAt",
607
- expected: "string & Format<\"date-time\">",
607
+ expected: "string & CommerceDateTimeFormat",
608
608
  value: input.purchasedAt
609
609
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
610
610
  method: "typia.createAssertEquals",
611
611
  path: _path + ".purchasedAt",
612
- expected: "((string & Format<\"date-time\">) | undefined)",
612
+ expected: "((string & CommerceDateTimeFormat) | undefined)",
613
613
  value: input.purchasedAt
614
614
  }, _errorFactory)) && ("string" === typeof input.token && (1 <= input.token.length || _assertGuard_1._assertGuard(_exceptionable, {
615
615
  method: "typia.createAssertEquals",
616
616
  path: _path + ".token",
617
- expected: "string & MinLength<1>",
617
+ expected: "string & CommerceMinLength<1>",
618
618
  value: input.token
619
619
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
620
620
  method: "typia.createAssertEquals",
621
621
  path: _path + ".token",
622
- expected: "(string & MinLength<1>)",
622
+ expected: "(string & CommerceMinLength<1>)",
623
623
  value: input.token
624
624
  }, _errorFactory)) && (("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
625
625
  method: "typia.createAssertEquals",
@@ -729,12 +729,12 @@ export const assertStorePurchase = (() => {
729
729
  const _ao4 = (input, _path, _exceptionable = true) => ("string" === typeof input.ledgerEntryId && (1 <= input.ledgerEntryId.length || _assertGuard_1._assertGuard(_exceptionable, {
730
730
  method: "typia.createAssertEquals",
731
731
  path: _path + ".ledgerEntryId",
732
- expected: "string & MinLength<1>",
732
+ expected: "string & CommerceMinLength<1>",
733
733
  value: input.ledgerEntryId
734
734
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
735
735
  method: "typia.createAssertEquals",
736
736
  path: _path + ".ledgerEntryId",
737
- expected: "(string & MinLength<1>)",
737
+ expected: "(string & CommerceMinLength<1>)",
738
738
  value: input.ledgerEntryId
739
739
  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
740
740
  if (["ledgerEntryId"].some(prop => key === prop))
@@ -852,22 +852,22 @@ export const assertRequestPurchaseInput = (() => {
852
852
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
853
853
  method: "typia.createAssertEquals",
854
854
  path: _path + ".logicalId",
855
- expected: "string & MinLength<1>",
855
+ expected: "string & CommerceMinLength<1>",
856
856
  value: input.logicalId
857
857
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
858
858
  method: "typia.createAssertEquals",
859
859
  path: _path + ".logicalId",
860
- expected: "(string & MinLength<1>)",
860
+ expected: "(string & CommerceMinLength<1>)",
861
861
  value: input.logicalId
862
862
  }, _errorFactory)) && ("string" === typeof input.idempotencyKey && (1 <= input.idempotencyKey.length || _assertGuard_1._assertGuard(_exceptionable, {
863
863
  method: "typia.createAssertEquals",
864
864
  path: _path + ".idempotencyKey",
865
- expected: "string & MinLength<1>",
865
+ expected: "string & CommerceMinLength<1>",
866
866
  value: input.idempotencyKey
867
867
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
868
868
  method: "typia.createAssertEquals",
869
869
  path: _path + ".idempotencyKey",
870
- expected: "(string & MinLength<1>)",
870
+ expected: "(string & CommerceMinLength<1>)",
871
871
  value: input.idempotencyKey
872
872
  }, _errorFactory)) && ("event" === input.source || "result" === input.source || "shop" === input.source || "stage_fail" === input.source || _assertGuard_1._assertGuard(_exceptionable, {
873
873
  method: "typia.createAssertEquals",
@@ -877,27 +877,27 @@ export const assertRequestPurchaseInput = (() => {
877
877
  }, _errorFactory)) && (undefined === input.offerId || "string" === typeof input.offerId && (1 <= input.offerId.length || _assertGuard_1._assertGuard(_exceptionable, {
878
878
  method: "typia.createAssertEquals",
879
879
  path: _path + ".offerId",
880
- expected: "string & MinLength<1>",
880
+ expected: "string & CommerceMinLength<1>",
881
881
  value: input.offerId
882
882
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
883
883
  method: "typia.createAssertEquals",
884
884
  path: _path + ".offerId",
885
- expected: "((string & MinLength<1>) | undefined)",
885
+ expected: "((string & CommerceMinLength<1>) | undefined)",
886
886
  value: input.offerId
887
887
  }, _errorFactory)) && (undefined === input.quantity || "number" === typeof input.quantity && (_isTypeUint32_1._isTypeUint32(input.quantity) || _assertGuard_1._assertGuard(_exceptionable, {
888
888
  method: "typia.createAssertEquals",
889
889
  path: _path + ".quantity",
890
- expected: "number & Type<\"uint32\">",
890
+ expected: "number & CommerceUint32",
891
891
  value: input.quantity
892
892
  }, _errorFactory)) && (1 <= input.quantity || _assertGuard_1._assertGuard(_exceptionable, {
893
893
  method: "typia.createAssertEquals",
894
894
  path: _path + ".quantity",
895
- expected: "number & Minimum<1>",
895
+ expected: "number & CommerceMinimum<1>",
896
896
  value: input.quantity
897
897
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
898
898
  method: "typia.createAssertEquals",
899
899
  path: _path + ".quantity",
900
- expected: "((number & Type<\"uint32\"> & Minimum<1>) | undefined)",
900
+ expected: "((number & CommerceUint32 & CommerceMinimum<1>) | undefined)",
901
901
  value: input.quantity
902
902
  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
903
903
  if (["logicalId", "idempotencyKey", "source", "offerId", "quantity"].some(prop => key === prop))
@@ -1006,67 +1006,67 @@ export const assertRequestPurchaseResult = (() => {
1006
1006
  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
1007
1007
  method: "typia.createAssertEquals",
1008
1008
  path: _path + ".store",
1009
- expected: "string & MinLength<1>",
1009
+ expected: "string & CommerceMinLength<1>",
1010
1010
  value: input.store
1011
1011
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1012
1012
  method: "typia.createAssertEquals",
1013
1013
  path: _path + ".store",
1014
- expected: "(string & MinLength<1>)",
1014
+ expected: "(string & CommerceMinLength<1>)",
1015
1015
  value: input.store
1016
1016
  }, _errorFactory)) && ("string" === typeof input.transactionId && (1 <= input.transactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
1017
1017
  method: "typia.createAssertEquals",
1018
1018
  path: _path + ".transactionId",
1019
- expected: "string & MinLength<1>",
1019
+ expected: "string & CommerceMinLength<1>",
1020
1020
  value: input.transactionId
1021
1021
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1022
1022
  method: "typia.createAssertEquals",
1023
1023
  path: _path + ".transactionId",
1024
- expected: "(string & MinLength<1>)",
1024
+ expected: "(string & CommerceMinLength<1>)",
1025
1025
  value: input.transactionId
1026
1026
  }, _errorFactory)) && (undefined === input.originalTransactionId || "string" === typeof input.originalTransactionId && (1 <= input.originalTransactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
1027
1027
  method: "typia.createAssertEquals",
1028
1028
  path: _path + ".originalTransactionId",
1029
- expected: "string & MinLength<1>",
1029
+ expected: "string & CommerceMinLength<1>",
1030
1030
  value: input.originalTransactionId
1031
1031
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1032
1032
  method: "typia.createAssertEquals",
1033
1033
  path: _path + ".originalTransactionId",
1034
- expected: "((string & MinLength<1>) | undefined)",
1034
+ expected: "((string & CommerceMinLength<1>) | undefined)",
1035
1035
  value: input.originalTransactionId
1036
1036
  }, _errorFactory)) && ("string" === typeof input.storeSku && (1 <= input.storeSku.length || _assertGuard_1._assertGuard(_exceptionable, {
1037
1037
  method: "typia.createAssertEquals",
1038
1038
  path: _path + ".storeSku",
1039
- expected: "string & MinLength<1>",
1039
+ expected: "string & CommerceMinLength<1>",
1040
1040
  value: input.storeSku
1041
1041
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1042
1042
  method: "typia.createAssertEquals",
1043
1043
  path: _path + ".storeSku",
1044
- expected: "(string & MinLength<1>)",
1044
+ expected: "(string & CommerceMinLength<1>)",
1045
1045
  value: input.storeSku
1046
1046
  }, _errorFactory)) && (undefined === input.logicalId || "string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
1047
1047
  method: "typia.createAssertEquals",
1048
1048
  path: _path + ".logicalId",
1049
- expected: "string & MinLength<1>",
1049
+ expected: "string & CommerceMinLength<1>",
1050
1050
  value: input.logicalId
1051
1051
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1052
1052
  method: "typia.createAssertEquals",
1053
1053
  path: _path + ".logicalId",
1054
- expected: "((string & MinLength<1>) | undefined)",
1054
+ expected: "((string & CommerceMinLength<1>) | undefined)",
1055
1055
  value: input.logicalId
1056
1056
  }, _errorFactory)) && ("number" === typeof input.quantity && (_isTypeUint32_1._isTypeUint32(input.quantity) || _assertGuard_1._assertGuard(_exceptionable, {
1057
1057
  method: "typia.createAssertEquals",
1058
1058
  path: _path + ".quantity",
1059
- expected: "number & Type<\"uint32\">",
1059
+ expected: "number & CommerceUint32",
1060
1060
  value: input.quantity
1061
1061
  }, _errorFactory)) && (1 <= input.quantity || _assertGuard_1._assertGuard(_exceptionable, {
1062
1062
  method: "typia.createAssertEquals",
1063
1063
  path: _path + ".quantity",
1064
- expected: "number & Minimum<1>",
1064
+ expected: "number & CommerceMinimum<1>",
1065
1065
  value: input.quantity
1066
1066
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1067
1067
  method: "typia.createAssertEquals",
1068
1068
  path: _path + ".quantity",
1069
- expected: "(number & Type<\"uint32\"> & Minimum<1>)",
1069
+ expected: "(number & CommerceUint32 & CommerceMinimum<1>)",
1070
1070
  value: input.quantity
1071
1071
  }, _errorFactory)) && ("pending" === input.state || "purchased" === input.state || "revoked" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
1072
1072
  method: "typia.createAssertEquals",
@@ -1076,22 +1076,22 @@ export const assertRequestPurchaseResult = (() => {
1076
1076
  }, _errorFactory)) && (undefined === input.purchasedAt || "string" === typeof input.purchasedAt && (_isFormatDateTime_1._isFormatDateTime(input.purchasedAt) || _assertGuard_1._assertGuard(_exceptionable, {
1077
1077
  method: "typia.createAssertEquals",
1078
1078
  path: _path + ".purchasedAt",
1079
- expected: "string & Format<\"date-time\">",
1079
+ expected: "string & CommerceDateTimeFormat",
1080
1080
  value: input.purchasedAt
1081
1081
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1082
1082
  method: "typia.createAssertEquals",
1083
1083
  path: _path + ".purchasedAt",
1084
- expected: "((string & Format<\"date-time\">) | undefined)",
1084
+ expected: "((string & CommerceDateTimeFormat) | undefined)",
1085
1085
  value: input.purchasedAt
1086
1086
  }, _errorFactory)) && ("string" === typeof input.token && (1 <= input.token.length || _assertGuard_1._assertGuard(_exceptionable, {
1087
1087
  method: "typia.createAssertEquals",
1088
1088
  path: _path + ".token",
1089
- expected: "string & MinLength<1>",
1089
+ expected: "string & CommerceMinLength<1>",
1090
1090
  value: input.token
1091
1091
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1092
1092
  method: "typia.createAssertEquals",
1093
1093
  path: _path + ".token",
1094
- expected: "(string & MinLength<1>)",
1094
+ expected: "(string & CommerceMinLength<1>)",
1095
1095
  value: input.token
1096
1096
  }, _errorFactory)) && (("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
1097
1097
  method: "typia.createAssertEquals",
@@ -1201,12 +1201,12 @@ export const assertRequestPurchaseResult = (() => {
1201
1201
  const _ao6 = (input, _path, _exceptionable = true) => ("string" === typeof input.ledgerEntryId && (1 <= input.ledgerEntryId.length || _assertGuard_1._assertGuard(_exceptionable, {
1202
1202
  method: "typia.createAssertEquals",
1203
1203
  path: _path + ".ledgerEntryId",
1204
- expected: "string & MinLength<1>",
1204
+ expected: "string & CommerceMinLength<1>",
1205
1205
  value: input.ledgerEntryId
1206
1206
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1207
1207
  method: "typia.createAssertEquals",
1208
1208
  path: _path + ".ledgerEntryId",
1209
- expected: "(string & MinLength<1>)",
1209
+ expected: "(string & CommerceMinLength<1>)",
1210
1210
  value: input.ledgerEntryId
1211
1211
  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
1212
1212
  if (["ledgerEntryId"].some(prop => key === prop))
@@ -1518,67 +1518,67 @@ export const assertCommerceEvent = (() => {
1518
1518
  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
1519
1519
  method: "typia.createAssertEquals",
1520
1520
  path: _path + ".store",
1521
- expected: "string & MinLength<1>",
1521
+ expected: "string & CommerceMinLength<1>",
1522
1522
  value: input.store
1523
1523
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1524
1524
  method: "typia.createAssertEquals",
1525
1525
  path: _path + ".store",
1526
- expected: "(string & MinLength<1>)",
1526
+ expected: "(string & CommerceMinLength<1>)",
1527
1527
  value: input.store
1528
1528
  }, _errorFactory)) && ("string" === typeof input.transactionId && (1 <= input.transactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
1529
1529
  method: "typia.createAssertEquals",
1530
1530
  path: _path + ".transactionId",
1531
- expected: "string & MinLength<1>",
1531
+ expected: "string & CommerceMinLength<1>",
1532
1532
  value: input.transactionId
1533
1533
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1534
1534
  method: "typia.createAssertEquals",
1535
1535
  path: _path + ".transactionId",
1536
- expected: "(string & MinLength<1>)",
1536
+ expected: "(string & CommerceMinLength<1>)",
1537
1537
  value: input.transactionId
1538
1538
  }, _errorFactory)) && (undefined === input.originalTransactionId || "string" === typeof input.originalTransactionId && (1 <= input.originalTransactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
1539
1539
  method: "typia.createAssertEquals",
1540
1540
  path: _path + ".originalTransactionId",
1541
- expected: "string & MinLength<1>",
1541
+ expected: "string & CommerceMinLength<1>",
1542
1542
  value: input.originalTransactionId
1543
1543
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1544
1544
  method: "typia.createAssertEquals",
1545
1545
  path: _path + ".originalTransactionId",
1546
- expected: "((string & MinLength<1>) | undefined)",
1546
+ expected: "((string & CommerceMinLength<1>) | undefined)",
1547
1547
  value: input.originalTransactionId
1548
1548
  }, _errorFactory)) && ("string" === typeof input.storeSku && (1 <= input.storeSku.length || _assertGuard_1._assertGuard(_exceptionable, {
1549
1549
  method: "typia.createAssertEquals",
1550
1550
  path: _path + ".storeSku",
1551
- expected: "string & MinLength<1>",
1551
+ expected: "string & CommerceMinLength<1>",
1552
1552
  value: input.storeSku
1553
1553
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1554
1554
  method: "typia.createAssertEquals",
1555
1555
  path: _path + ".storeSku",
1556
- expected: "(string & MinLength<1>)",
1556
+ expected: "(string & CommerceMinLength<1>)",
1557
1557
  value: input.storeSku
1558
1558
  }, _errorFactory)) && (undefined === input.logicalId || "string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
1559
1559
  method: "typia.createAssertEquals",
1560
1560
  path: _path + ".logicalId",
1561
- expected: "string & MinLength<1>",
1561
+ expected: "string & CommerceMinLength<1>",
1562
1562
  value: input.logicalId
1563
1563
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1564
1564
  method: "typia.createAssertEquals",
1565
1565
  path: _path + ".logicalId",
1566
- expected: "((string & MinLength<1>) | undefined)",
1566
+ expected: "((string & CommerceMinLength<1>) | undefined)",
1567
1567
  value: input.logicalId
1568
1568
  }, _errorFactory)) && ("number" === typeof input.quantity && (_isTypeUint32_1._isTypeUint32(input.quantity) || _assertGuard_1._assertGuard(_exceptionable, {
1569
1569
  method: "typia.createAssertEquals",
1570
1570
  path: _path + ".quantity",
1571
- expected: "number & Type<\"uint32\">",
1571
+ expected: "number & CommerceUint32",
1572
1572
  value: input.quantity
1573
1573
  }, _errorFactory)) && (1 <= input.quantity || _assertGuard_1._assertGuard(_exceptionable, {
1574
1574
  method: "typia.createAssertEquals",
1575
1575
  path: _path + ".quantity",
1576
- expected: "number & Minimum<1>",
1576
+ expected: "number & CommerceMinimum<1>",
1577
1577
  value: input.quantity
1578
1578
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1579
1579
  method: "typia.createAssertEquals",
1580
1580
  path: _path + ".quantity",
1581
- expected: "(number & Type<\"uint32\"> & Minimum<1>)",
1581
+ expected: "(number & CommerceUint32 & CommerceMinimum<1>)",
1582
1582
  value: input.quantity
1583
1583
  }, _errorFactory)) && ("pending" === input.state || "purchased" === input.state || "revoked" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
1584
1584
  method: "typia.createAssertEquals",
@@ -1588,22 +1588,22 @@ export const assertCommerceEvent = (() => {
1588
1588
  }, _errorFactory)) && (undefined === input.purchasedAt || "string" === typeof input.purchasedAt && (_isFormatDateTime_1._isFormatDateTime(input.purchasedAt) || _assertGuard_1._assertGuard(_exceptionable, {
1589
1589
  method: "typia.createAssertEquals",
1590
1590
  path: _path + ".purchasedAt",
1591
- expected: "string & Format<\"date-time\">",
1591
+ expected: "string & CommerceDateTimeFormat",
1592
1592
  value: input.purchasedAt
1593
1593
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1594
1594
  method: "typia.createAssertEquals",
1595
1595
  path: _path + ".purchasedAt",
1596
- expected: "((string & Format<\"date-time\">) | undefined)",
1596
+ expected: "((string & CommerceDateTimeFormat) | undefined)",
1597
1597
  value: input.purchasedAt
1598
1598
  }, _errorFactory)) && ("string" === typeof input.token && (1 <= input.token.length || _assertGuard_1._assertGuard(_exceptionable, {
1599
1599
  method: "typia.createAssertEquals",
1600
1600
  path: _path + ".token",
1601
- expected: "string & MinLength<1>",
1601
+ expected: "string & CommerceMinLength<1>",
1602
1602
  value: input.token
1603
1603
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1604
1604
  method: "typia.createAssertEquals",
1605
1605
  path: _path + ".token",
1606
- expected: "(string & MinLength<1>)",
1606
+ expected: "(string & CommerceMinLength<1>)",
1607
1607
  value: input.token
1608
1608
  }, _errorFactory)) && (("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
1609
1609
  method: "typia.createAssertEquals",
@@ -1713,12 +1713,12 @@ export const assertCommerceEvent = (() => {
1713
1713
  const _ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.ledgerEntryId && (1 <= input.ledgerEntryId.length || _assertGuard_1._assertGuard(_exceptionable, {
1714
1714
  method: "typia.createAssertEquals",
1715
1715
  path: _path + ".ledgerEntryId",
1716
- expected: "string & MinLength<1>",
1716
+ expected: "string & CommerceMinLength<1>",
1717
1717
  value: input.ledgerEntryId
1718
1718
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1719
1719
  method: "typia.createAssertEquals",
1720
1720
  path: _path + ".ledgerEntryId",
1721
- expected: "(string & MinLength<1>)",
1721
+ expected: "(string & CommerceMinLength<1>)",
1722
1722
  value: input.ledgerEntryId
1723
1723
  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
1724
1724
  if (["ledgerEntryId"].some(prop => key === prop))
@@ -1741,12 +1741,12 @@ export const assertCommerceEvent = (() => {
1741
1741
  }, _errorFactory)) && (undefined === input.logicalId || "string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
1742
1742
  method: "typia.createAssertEquals",
1743
1743
  path: _path + ".logicalId",
1744
- expected: "string & MinLength<1>",
1744
+ expected: "string & CommerceMinLength<1>",
1745
1745
  value: input.logicalId
1746
1746
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1747
1747
  method: "typia.createAssertEquals",
1748
1748
  path: _path + ".logicalId",
1749
- expected: "((string & MinLength<1>) | undefined)",
1749
+ expected: "((string & CommerceMinLength<1>) | undefined)",
1750
1750
  value: input.logicalId
1751
1751
  }, _errorFactory)) && (("object" === typeof input.error && null !== input.error || _assertGuard_1._assertGuard(_exceptionable, {
1752
1752
  method: "typia.createAssertEquals",
@@ -1835,42 +1835,42 @@ export const assertCommerceEvent = (() => {
1835
1835
  const _ao9 = (input, _path, _exceptionable = true) => ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
1836
1836
  method: "typia.createAssertEquals",
1837
1837
  path: _path + ".store",
1838
- expected: "string & MinLength<1>",
1838
+ expected: "string & CommerceMinLength<1>",
1839
1839
  value: input.store
1840
1840
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1841
1841
  method: "typia.createAssertEquals",
1842
1842
  path: _path + ".store",
1843
- expected: "(string & MinLength<1>)",
1843
+ expected: "(string & CommerceMinLength<1>)",
1844
1844
  value: input.store
1845
1845
  }, _errorFactory)) && ("string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
1846
1846
  method: "typia.createAssertEquals",
1847
1847
  path: _path + ".logicalId",
1848
- expected: "string & MinLength<1>",
1848
+ expected: "string & CommerceMinLength<1>",
1849
1849
  value: input.logicalId
1850
1850
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1851
1851
  method: "typia.createAssertEquals",
1852
1852
  path: _path + ".logicalId",
1853
- expected: "(string & MinLength<1>)",
1853
+ expected: "(string & CommerceMinLength<1>)",
1854
1854
  value: input.logicalId
1855
1855
  }, _errorFactory)) && ("string" === typeof input.subscriptionId && (1 <= input.subscriptionId.length || _assertGuard_1._assertGuard(_exceptionable, {
1856
1856
  method: "typia.createAssertEquals",
1857
1857
  path: _path + ".subscriptionId",
1858
- expected: "string & MinLength<1>",
1858
+ expected: "string & CommerceMinLength<1>",
1859
1859
  value: input.subscriptionId
1860
1860
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1861
1861
  method: "typia.createAssertEquals",
1862
1862
  path: _path + ".subscriptionId",
1863
- expected: "(string & MinLength<1>)",
1863
+ expected: "(string & CommerceMinLength<1>)",
1864
1864
  value: input.subscriptionId
1865
1865
  }, _errorFactory)) && ("number" === typeof input.periodIndex && (_isTypeUint32_1._isTypeUint32(input.periodIndex) || _assertGuard_1._assertGuard(_exceptionable, {
1866
1866
  method: "typia.createAssertEquals",
1867
1867
  path: _path + ".periodIndex",
1868
- expected: "number & Type<\"uint32\">",
1868
+ expected: "number & CommerceUint32",
1869
1869
  value: input.periodIndex
1870
1870
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1871
1871
  method: "typia.createAssertEquals",
1872
1872
  path: _path + ".periodIndex",
1873
- expected: "(number & Type<\"uint32\">)",
1873
+ expected: "(number & CommerceUint32)",
1874
1874
  value: input.periodIndex
1875
1875
  }, _errorFactory)) && ("active" === input.state || "lapsed" === input.state || "revoked" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
1876
1876
  method: "typia.createAssertEquals",
@@ -1880,22 +1880,22 @@ export const assertCommerceEvent = (() => {
1880
1880
  }, _errorFactory)) && ("string" === typeof input.startedAt && (_isFormatDateTime_1._isFormatDateTime(input.startedAt) || _assertGuard_1._assertGuard(_exceptionable, {
1881
1881
  method: "typia.createAssertEquals",
1882
1882
  path: _path + ".startedAt",
1883
- expected: "string & Format<\"date-time\">",
1883
+ expected: "string & CommerceDateTimeFormat",
1884
1884
  value: input.startedAt
1885
1885
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1886
1886
  method: "typia.createAssertEquals",
1887
1887
  path: _path + ".startedAt",
1888
- expected: "(string & Format<\"date-time\">)",
1888
+ expected: "(string & CommerceDateTimeFormat)",
1889
1889
  value: input.startedAt
1890
1890
  }, _errorFactory)) && ("string" === typeof input.expiresAt && (_isFormatDateTime_1._isFormatDateTime(input.expiresAt) || _assertGuard_1._assertGuard(_exceptionable, {
1891
1891
  method: "typia.createAssertEquals",
1892
1892
  path: _path + ".expiresAt",
1893
- expected: "string & Format<\"date-time\">",
1893
+ expected: "string & CommerceDateTimeFormat",
1894
1894
  value: input.expiresAt
1895
1895
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
1896
1896
  method: "typia.createAssertEquals",
1897
1897
  path: _path + ".expiresAt",
1898
- expected: "(string & Format<\"date-time\">)",
1898
+ expected: "(string & CommerceDateTimeFormat)",
1899
1899
  value: input.expiresAt
1900
1900
  }, _errorFactory)) && ("boolean" === typeof input.autoRenew || _assertGuard_1._assertGuard(_exceptionable, {
1901
1901
  method: "typia.createAssertEquals",
@@ -2144,12 +2144,12 @@ export const assertCommerceEventEnvelope = (() => {
2144
2144
  }, _errorFactory)) && ("number" === typeof input.sequence && (_isTypeUint32_1._isTypeUint32(input.sequence) || _assertGuard_1._assertGuard(_exceptionable, {
2145
2145
  method: "typia.createAssertEquals",
2146
2146
  path: _path + ".sequence",
2147
- expected: "number & Type<\"uint32\">",
2147
+ expected: "number & CommerceUint32",
2148
2148
  value: input.sequence
2149
2149
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2150
2150
  method: "typia.createAssertEquals",
2151
2151
  path: _path + ".sequence",
2152
- expected: "(number & Type<\"uint32\">)",
2152
+ expected: "(number & CommerceUint32)",
2153
2153
  value: input.sequence
2154
2154
  }, _errorFactory)) && (("object" === typeof input.event && null !== input.event || _assertGuard_1._assertGuard(_exceptionable, {
2155
2155
  method: "typia.createAssertEquals",
@@ -2205,42 +2205,42 @@ export const assertCommerceEventEnvelope = (() => {
2205
2205
  const _ao10 = (input, _path, _exceptionable = true) => ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
2206
2206
  method: "typia.createAssertEquals",
2207
2207
  path: _path + ".store",
2208
- expected: "string & MinLength<1>",
2208
+ expected: "string & CommerceMinLength<1>",
2209
2209
  value: input.store
2210
2210
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2211
2211
  method: "typia.createAssertEquals",
2212
2212
  path: _path + ".store",
2213
- expected: "(string & MinLength<1>)",
2213
+ expected: "(string & CommerceMinLength<1>)",
2214
2214
  value: input.store
2215
2215
  }, _errorFactory)) && ("string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
2216
2216
  method: "typia.createAssertEquals",
2217
2217
  path: _path + ".logicalId",
2218
- expected: "string & MinLength<1>",
2218
+ expected: "string & CommerceMinLength<1>",
2219
2219
  value: input.logicalId
2220
2220
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2221
2221
  method: "typia.createAssertEquals",
2222
2222
  path: _path + ".logicalId",
2223
- expected: "(string & MinLength<1>)",
2223
+ expected: "(string & CommerceMinLength<1>)",
2224
2224
  value: input.logicalId
2225
2225
  }, _errorFactory)) && ("string" === typeof input.subscriptionId && (1 <= input.subscriptionId.length || _assertGuard_1._assertGuard(_exceptionable, {
2226
2226
  method: "typia.createAssertEquals",
2227
2227
  path: _path + ".subscriptionId",
2228
- expected: "string & MinLength<1>",
2228
+ expected: "string & CommerceMinLength<1>",
2229
2229
  value: input.subscriptionId
2230
2230
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2231
2231
  method: "typia.createAssertEquals",
2232
2232
  path: _path + ".subscriptionId",
2233
- expected: "(string & MinLength<1>)",
2233
+ expected: "(string & CommerceMinLength<1>)",
2234
2234
  value: input.subscriptionId
2235
2235
  }, _errorFactory)) && ("number" === typeof input.periodIndex && (_isTypeUint32_1._isTypeUint32(input.periodIndex) || _assertGuard_1._assertGuard(_exceptionable, {
2236
2236
  method: "typia.createAssertEquals",
2237
2237
  path: _path + ".periodIndex",
2238
- expected: "number & Type<\"uint32\">",
2238
+ expected: "number & CommerceUint32",
2239
2239
  value: input.periodIndex
2240
2240
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2241
2241
  method: "typia.createAssertEquals",
2242
2242
  path: _path + ".periodIndex",
2243
- expected: "(number & Type<\"uint32\">)",
2243
+ expected: "(number & CommerceUint32)",
2244
2244
  value: input.periodIndex
2245
2245
  }, _errorFactory)) && ("active" === input.state || "lapsed" === input.state || "revoked" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
2246
2246
  method: "typia.createAssertEquals",
@@ -2250,22 +2250,22 @@ export const assertCommerceEventEnvelope = (() => {
2250
2250
  }, _errorFactory)) && ("string" === typeof input.startedAt && (_isFormatDateTime_1._isFormatDateTime(input.startedAt) || _assertGuard_1._assertGuard(_exceptionable, {
2251
2251
  method: "typia.createAssertEquals",
2252
2252
  path: _path + ".startedAt",
2253
- expected: "string & Format<\"date-time\">",
2253
+ expected: "string & CommerceDateTimeFormat",
2254
2254
  value: input.startedAt
2255
2255
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2256
2256
  method: "typia.createAssertEquals",
2257
2257
  path: _path + ".startedAt",
2258
- expected: "(string & Format<\"date-time\">)",
2258
+ expected: "(string & CommerceDateTimeFormat)",
2259
2259
  value: input.startedAt
2260
2260
  }, _errorFactory)) && ("string" === typeof input.expiresAt && (_isFormatDateTime_1._isFormatDateTime(input.expiresAt) || _assertGuard_1._assertGuard(_exceptionable, {
2261
2261
  method: "typia.createAssertEquals",
2262
2262
  path: _path + ".expiresAt",
2263
- expected: "string & Format<\"date-time\">",
2263
+ expected: "string & CommerceDateTimeFormat",
2264
2264
  value: input.expiresAt
2265
2265
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2266
2266
  method: "typia.createAssertEquals",
2267
2267
  path: _path + ".expiresAt",
2268
- expected: "(string & Format<\"date-time\">)",
2268
+ expected: "(string & CommerceDateTimeFormat)",
2269
2269
  value: input.expiresAt
2270
2270
  }, _errorFactory)) && ("boolean" === typeof input.autoRenew || _assertGuard_1._assertGuard(_exceptionable, {
2271
2271
  method: "typia.createAssertEquals",
@@ -2288,67 +2288,67 @@ export const assertCommerceEventEnvelope = (() => {
2288
2288
  const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
2289
2289
  method: "typia.createAssertEquals",
2290
2290
  path: _path + ".store",
2291
- expected: "string & MinLength<1>",
2291
+ expected: "string & CommerceMinLength<1>",
2292
2292
  value: input.store
2293
2293
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2294
2294
  method: "typia.createAssertEquals",
2295
2295
  path: _path + ".store",
2296
- expected: "(string & MinLength<1>)",
2296
+ expected: "(string & CommerceMinLength<1>)",
2297
2297
  value: input.store
2298
2298
  }, _errorFactory)) && ("string" === typeof input.transactionId && (1 <= input.transactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
2299
2299
  method: "typia.createAssertEquals",
2300
2300
  path: _path + ".transactionId",
2301
- expected: "string & MinLength<1>",
2301
+ expected: "string & CommerceMinLength<1>",
2302
2302
  value: input.transactionId
2303
2303
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2304
2304
  method: "typia.createAssertEquals",
2305
2305
  path: _path + ".transactionId",
2306
- expected: "(string & MinLength<1>)",
2306
+ expected: "(string & CommerceMinLength<1>)",
2307
2307
  value: input.transactionId
2308
2308
  }, _errorFactory)) && (undefined === input.originalTransactionId || "string" === typeof input.originalTransactionId && (1 <= input.originalTransactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
2309
2309
  method: "typia.createAssertEquals",
2310
2310
  path: _path + ".originalTransactionId",
2311
- expected: "string & MinLength<1>",
2311
+ expected: "string & CommerceMinLength<1>",
2312
2312
  value: input.originalTransactionId
2313
2313
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2314
2314
  method: "typia.createAssertEquals",
2315
2315
  path: _path + ".originalTransactionId",
2316
- expected: "((string & MinLength<1>) | undefined)",
2316
+ expected: "((string & CommerceMinLength<1>) | undefined)",
2317
2317
  value: input.originalTransactionId
2318
2318
  }, _errorFactory)) && ("string" === typeof input.storeSku && (1 <= input.storeSku.length || _assertGuard_1._assertGuard(_exceptionable, {
2319
2319
  method: "typia.createAssertEquals",
2320
2320
  path: _path + ".storeSku",
2321
- expected: "string & MinLength<1>",
2321
+ expected: "string & CommerceMinLength<1>",
2322
2322
  value: input.storeSku
2323
2323
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2324
2324
  method: "typia.createAssertEquals",
2325
2325
  path: _path + ".storeSku",
2326
- expected: "(string & MinLength<1>)",
2326
+ expected: "(string & CommerceMinLength<1>)",
2327
2327
  value: input.storeSku
2328
2328
  }, _errorFactory)) && (undefined === input.logicalId || "string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
2329
2329
  method: "typia.createAssertEquals",
2330
2330
  path: _path + ".logicalId",
2331
- expected: "string & MinLength<1>",
2331
+ expected: "string & CommerceMinLength<1>",
2332
2332
  value: input.logicalId
2333
2333
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2334
2334
  method: "typia.createAssertEquals",
2335
2335
  path: _path + ".logicalId",
2336
- expected: "((string & MinLength<1>) | undefined)",
2336
+ expected: "((string & CommerceMinLength<1>) | undefined)",
2337
2337
  value: input.logicalId
2338
2338
  }, _errorFactory)) && ("number" === typeof input.quantity && (_isTypeUint32_1._isTypeUint32(input.quantity) || _assertGuard_1._assertGuard(_exceptionable, {
2339
2339
  method: "typia.createAssertEquals",
2340
2340
  path: _path + ".quantity",
2341
- expected: "number & Type<\"uint32\">",
2341
+ expected: "number & CommerceUint32",
2342
2342
  value: input.quantity
2343
2343
  }, _errorFactory)) && (1 <= input.quantity || _assertGuard_1._assertGuard(_exceptionable, {
2344
2344
  method: "typia.createAssertEquals",
2345
2345
  path: _path + ".quantity",
2346
- expected: "number & Minimum<1>",
2346
+ expected: "number & CommerceMinimum<1>",
2347
2347
  value: input.quantity
2348
2348
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2349
2349
  method: "typia.createAssertEquals",
2350
2350
  path: _path + ".quantity",
2351
- expected: "(number & Type<\"uint32\"> & Minimum<1>)",
2351
+ expected: "(number & CommerceUint32 & CommerceMinimum<1>)",
2352
2352
  value: input.quantity
2353
2353
  }, _errorFactory)) && ("pending" === input.state || "purchased" === input.state || "revoked" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
2354
2354
  method: "typia.createAssertEquals",
@@ -2358,22 +2358,22 @@ export const assertCommerceEventEnvelope = (() => {
2358
2358
  }, _errorFactory)) && (undefined === input.purchasedAt || "string" === typeof input.purchasedAt && (_isFormatDateTime_1._isFormatDateTime(input.purchasedAt) || _assertGuard_1._assertGuard(_exceptionable, {
2359
2359
  method: "typia.createAssertEquals",
2360
2360
  path: _path + ".purchasedAt",
2361
- expected: "string & Format<\"date-time\">",
2361
+ expected: "string & CommerceDateTimeFormat",
2362
2362
  value: input.purchasedAt
2363
2363
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2364
2364
  method: "typia.createAssertEquals",
2365
2365
  path: _path + ".purchasedAt",
2366
- expected: "((string & Format<\"date-time\">) | undefined)",
2366
+ expected: "((string & CommerceDateTimeFormat) | undefined)",
2367
2367
  value: input.purchasedAt
2368
2368
  }, _errorFactory)) && ("string" === typeof input.token && (1 <= input.token.length || _assertGuard_1._assertGuard(_exceptionable, {
2369
2369
  method: "typia.createAssertEquals",
2370
2370
  path: _path + ".token",
2371
- expected: "string & MinLength<1>",
2371
+ expected: "string & CommerceMinLength<1>",
2372
2372
  value: input.token
2373
2373
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2374
2374
  method: "typia.createAssertEquals",
2375
2375
  path: _path + ".token",
2376
- expected: "(string & MinLength<1>)",
2376
+ expected: "(string & CommerceMinLength<1>)",
2377
2377
  value: input.token
2378
2378
  }, _errorFactory)) && (("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
2379
2379
  method: "typia.createAssertEquals",
@@ -2483,12 +2483,12 @@ export const assertCommerceEventEnvelope = (() => {
2483
2483
  const _ao6 = (input, _path, _exceptionable = true) => ("string" === typeof input.ledgerEntryId && (1 <= input.ledgerEntryId.length || _assertGuard_1._assertGuard(_exceptionable, {
2484
2484
  method: "typia.createAssertEquals",
2485
2485
  path: _path + ".ledgerEntryId",
2486
- expected: "string & MinLength<1>",
2486
+ expected: "string & CommerceMinLength<1>",
2487
2487
  value: input.ledgerEntryId
2488
2488
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2489
2489
  method: "typia.createAssertEquals",
2490
2490
  path: _path + ".ledgerEntryId",
2491
- expected: "(string & MinLength<1>)",
2491
+ expected: "(string & CommerceMinLength<1>)",
2492
2492
  value: input.ledgerEntryId
2493
2493
  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
2494
2494
  if (["ledgerEntryId"].some(prop => key === prop))
@@ -2511,12 +2511,12 @@ export const assertCommerceEventEnvelope = (() => {
2511
2511
  }, _errorFactory)) && (undefined === input.logicalId || "string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
2512
2512
  method: "typia.createAssertEquals",
2513
2513
  path: _path + ".logicalId",
2514
- expected: "string & MinLength<1>",
2514
+ expected: "string & CommerceMinLength<1>",
2515
2515
  value: input.logicalId
2516
2516
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2517
2517
  method: "typia.createAssertEquals",
2518
2518
  path: _path + ".logicalId",
2519
- expected: "((string & MinLength<1>) | undefined)",
2519
+ expected: "((string & CommerceMinLength<1>) | undefined)",
2520
2520
  value: input.logicalId
2521
2521
  }, _errorFactory)) && (("object" === typeof input.error && null !== input.error || _assertGuard_1._assertGuard(_exceptionable, {
2522
2522
  method: "typia.createAssertEquals",
@@ -2837,42 +2837,42 @@ export const assertActiveSubscription = (() => {
2837
2837
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
2838
2838
  method: "typia.createAssertEquals",
2839
2839
  path: _path + ".store",
2840
- expected: "string & MinLength<1>",
2840
+ expected: "string & CommerceMinLength<1>",
2841
2841
  value: input.store
2842
2842
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2843
2843
  method: "typia.createAssertEquals",
2844
2844
  path: _path + ".store",
2845
- expected: "(string & MinLength<1>)",
2845
+ expected: "(string & CommerceMinLength<1>)",
2846
2846
  value: input.store
2847
2847
  }, _errorFactory)) && ("string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
2848
2848
  method: "typia.createAssertEquals",
2849
2849
  path: _path + ".logicalId",
2850
- expected: "string & MinLength<1>",
2850
+ expected: "string & CommerceMinLength<1>",
2851
2851
  value: input.logicalId
2852
2852
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2853
2853
  method: "typia.createAssertEquals",
2854
2854
  path: _path + ".logicalId",
2855
- expected: "(string & MinLength<1>)",
2855
+ expected: "(string & CommerceMinLength<1>)",
2856
2856
  value: input.logicalId
2857
2857
  }, _errorFactory)) && ("string" === typeof input.subscriptionId && (1 <= input.subscriptionId.length || _assertGuard_1._assertGuard(_exceptionable, {
2858
2858
  method: "typia.createAssertEquals",
2859
2859
  path: _path + ".subscriptionId",
2860
- expected: "string & MinLength<1>",
2860
+ expected: "string & CommerceMinLength<1>",
2861
2861
  value: input.subscriptionId
2862
2862
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2863
2863
  method: "typia.createAssertEquals",
2864
2864
  path: _path + ".subscriptionId",
2865
- expected: "(string & MinLength<1>)",
2865
+ expected: "(string & CommerceMinLength<1>)",
2866
2866
  value: input.subscriptionId
2867
2867
  }, _errorFactory)) && ("number" === typeof input.periodIndex && (_isTypeUint32_1._isTypeUint32(input.periodIndex) || _assertGuard_1._assertGuard(_exceptionable, {
2868
2868
  method: "typia.createAssertEquals",
2869
2869
  path: _path + ".periodIndex",
2870
- expected: "number & Type<\"uint32\">",
2870
+ expected: "number & CommerceUint32",
2871
2871
  value: input.periodIndex
2872
2872
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2873
2873
  method: "typia.createAssertEquals",
2874
2874
  path: _path + ".periodIndex",
2875
- expected: "(number & Type<\"uint32\">)",
2875
+ expected: "(number & CommerceUint32)",
2876
2876
  value: input.periodIndex
2877
2877
  }, _errorFactory)) && ("active" === input.state || "lapsed" === input.state || "revoked" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
2878
2878
  method: "typia.createAssertEquals",
@@ -2882,22 +2882,22 @@ export const assertActiveSubscription = (() => {
2882
2882
  }, _errorFactory)) && ("string" === typeof input.startedAt && (_isFormatDateTime_1._isFormatDateTime(input.startedAt) || _assertGuard_1._assertGuard(_exceptionable, {
2883
2883
  method: "typia.createAssertEquals",
2884
2884
  path: _path + ".startedAt",
2885
- expected: "string & Format<\"date-time\">",
2885
+ expected: "string & CommerceDateTimeFormat",
2886
2886
  value: input.startedAt
2887
2887
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2888
2888
  method: "typia.createAssertEquals",
2889
2889
  path: _path + ".startedAt",
2890
- expected: "(string & Format<\"date-time\">)",
2890
+ expected: "(string & CommerceDateTimeFormat)",
2891
2891
  value: input.startedAt
2892
2892
  }, _errorFactory)) && ("string" === typeof input.expiresAt && (_isFormatDateTime_1._isFormatDateTime(input.expiresAt) || _assertGuard_1._assertGuard(_exceptionable, {
2893
2893
  method: "typia.createAssertEquals",
2894
2894
  path: _path + ".expiresAt",
2895
- expected: "string & Format<\"date-time\">",
2895
+ expected: "string & CommerceDateTimeFormat",
2896
2896
  value: input.expiresAt
2897
2897
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2898
2898
  method: "typia.createAssertEquals",
2899
2899
  path: _path + ".expiresAt",
2900
- expected: "(string & Format<\"date-time\">)",
2900
+ expected: "(string & CommerceDateTimeFormat)",
2901
2901
  value: input.expiresAt
2902
2902
  }, _errorFactory)) && ("boolean" === typeof input.autoRenew || _assertGuard_1._assertGuard(_exceptionable, {
2903
2903
  method: "typia.createAssertEquals",
@@ -2965,12 +2965,12 @@ export const assertFetchProductsInput = (() => {
2965
2965
  }, _errorFactory)) && input.logicalIds.every((elem, _index2) => "string" === typeof elem && (1 <= elem.length || _assertGuard_1._assertGuard(_exceptionable, {
2966
2966
  method: "typia.createAssertEquals",
2967
2967
  path: _path + ".logicalIds[" + _index2 + "]",
2968
- expected: "string & MinLength<1>",
2968
+ expected: "string & CommerceMinLength<1>",
2969
2969
  value: elem
2970
2970
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2971
2971
  method: "typia.createAssertEquals",
2972
2972
  path: _path + ".logicalIds[" + _index2 + "]",
2973
- expected: "(string & MinLength<1>)",
2973
+ expected: "(string & CommerceMinLength<1>)",
2974
2974
  value: elem
2975
2975
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
2976
2976
  method: "typia.createAssertEquals",
@@ -3376,22 +3376,22 @@ export const assertCreditOffer = (() => {
3376
3376
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
3377
3377
  method: "typia.createAssertEquals",
3378
3378
  path: _path + ".logicalId",
3379
- expected: "string & MinLength<1>",
3379
+ expected: "string & CommerceMinLength<1>",
3380
3380
  value: input.logicalId
3381
3381
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3382
3382
  method: "typia.createAssertEquals",
3383
3383
  path: _path + ".logicalId",
3384
- expected: "(string & MinLength<1>)",
3384
+ expected: "(string & CommerceMinLength<1>)",
3385
3385
  value: input.logicalId
3386
3386
  }, _errorFactory)) && ("string" === typeof input.storeSku && (1 <= input.storeSku.length || _assertGuard_1._assertGuard(_exceptionable, {
3387
3387
  method: "typia.createAssertEquals",
3388
3388
  path: _path + ".storeSku",
3389
- expected: "string & MinLength<1>",
3389
+ expected: "string & CommerceMinLength<1>",
3390
3390
  value: input.storeSku
3391
3391
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3392
3392
  method: "typia.createAssertEquals",
3393
3393
  path: _path + ".storeSku",
3394
- expected: "(string & MinLength<1>)",
3394
+ expected: "(string & CommerceMinLength<1>)",
3395
3395
  value: input.storeSku
3396
3396
  }, _errorFactory)) && ("consumable" === input.kind || "durable" === input.kind || "subscription" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
3397
3397
  method: "typia.createAssertEquals",
@@ -3444,12 +3444,12 @@ export const assertCreditOffer = (() => {
3444
3444
  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_1._assertGuard(_exceptionable, {
3445
3445
  method: "typia.createAssertEquals",
3446
3446
  path: _path + ".currency",
3447
- expected: "string & MinLength<1>",
3447
+ expected: "string & CommerceMinLength<1>",
3448
3448
  value: input.currency
3449
3449
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3450
3450
  method: "typia.createAssertEquals",
3451
3451
  path: _path + ".currency",
3452
- expected: "(string & MinLength<1>)",
3452
+ expected: "(string & CommerceMinLength<1>)",
3453
3453
  value: input.currency
3454
3454
  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_1._assertGuard(_exceptionable, {
3455
3455
  method: "typia.createAssertEquals",
@@ -3492,12 +3492,12 @@ export const assertCreditOffer = (() => {
3492
3492
  }, _errorFactory)) && ("string" === typeof input.period && (1 <= input.period.length || _assertGuard_1._assertGuard(_exceptionable, {
3493
3493
  method: "typia.createAssertEquals",
3494
3494
  path: _path + ".period",
3495
- expected: "string & MinLength<1>",
3495
+ expected: "string & CommerceMinLength<1>",
3496
3496
  value: input.period
3497
3497
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3498
3498
  method: "typia.createAssertEquals",
3499
3499
  path: _path + ".period",
3500
- expected: "(string & MinLength<1>)",
3500
+ expected: "(string & CommerceMinLength<1>)",
3501
3501
  value: input.period
3502
3502
  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
3503
3503
  if (["scope", "price", "period"].some(prop => key === prop))
@@ -3560,22 +3560,22 @@ export const assertCreditSpendInput = (() => {
3560
3560
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.titleId && (1 <= input.titleId.length || _assertGuard_1._assertGuard(_exceptionable, {
3561
3561
  method: "typia.createAssertEquals",
3562
3562
  path: _path + ".titleId",
3563
- expected: "string & MinLength<1>",
3563
+ expected: "string & CommerceMinLength<1>",
3564
3564
  value: input.titleId
3565
3565
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3566
3566
  method: "typia.createAssertEquals",
3567
3567
  path: _path + ".titleId",
3568
- expected: "(string & MinLength<1>)",
3568
+ expected: "(string & CommerceMinLength<1>)",
3569
3569
  value: input.titleId
3570
3570
  }, _errorFactory)) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_1._assertGuard(_exceptionable, {
3571
3571
  method: "typia.createAssertEquals",
3572
3572
  path: _path + ".currency",
3573
- expected: "string & MinLength<1>",
3573
+ expected: "string & CommerceMinLength<1>",
3574
3574
  value: input.currency
3575
3575
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3576
3576
  method: "typia.createAssertEquals",
3577
3577
  path: _path + ".currency",
3578
- expected: "(string & MinLength<1>)",
3578
+ expected: "(string & CommerceMinLength<1>)",
3579
3579
  value: input.currency
3580
3580
  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_1._assertGuard(_exceptionable, {
3581
3581
  method: "typia.createAssertEquals",
@@ -3590,22 +3590,22 @@ export const assertCreditSpendInput = (() => {
3590
3590
  }, _errorFactory)) && ("string" === typeof input.idempotencyKey && (1 <= input.idempotencyKey.length || _assertGuard_1._assertGuard(_exceptionable, {
3591
3591
  method: "typia.createAssertEquals",
3592
3592
  path: _path + ".idempotencyKey",
3593
- expected: "string & MinLength<1>",
3593
+ expected: "string & CommerceMinLength<1>",
3594
3594
  value: input.idempotencyKey
3595
3595
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3596
3596
  method: "typia.createAssertEquals",
3597
3597
  path: _path + ".idempotencyKey",
3598
- expected: "(string & MinLength<1>)",
3598
+ expected: "(string & CommerceMinLength<1>)",
3599
3599
  value: input.idempotencyKey
3600
3600
  }, _errorFactory)) && (undefined === input.logicalId || "string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
3601
3601
  method: "typia.createAssertEquals",
3602
3602
  path: _path + ".logicalId",
3603
- expected: "string & MinLength<1>",
3603
+ expected: "string & CommerceMinLength<1>",
3604
3604
  value: input.logicalId
3605
3605
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3606
3606
  method: "typia.createAssertEquals",
3607
3607
  path: _path + ".logicalId",
3608
- expected: "((string & MinLength<1>) | undefined)",
3608
+ expected: "((string & CommerceMinLength<1>) | undefined)",
3609
3609
  value: input.logicalId
3610
3610
  }, _errorFactory)) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
3611
3611
  if (["titleId", "currency", "amount", "idempotencyKey", "logicalId"].some(prop => key === prop))
@@ -3661,12 +3661,12 @@ export const assertCreditSpendResult = (() => {
3661
3661
  }, _errorFactory)) && ("string" === typeof input.entitlementId && (1 <= input.entitlementId.length || _assertGuard_1._assertGuard(_exceptionable, {
3662
3662
  method: "typia.createAssertEquals",
3663
3663
  path: _path + ".entitlementId",
3664
- expected: "string & MinLength<1>",
3664
+ expected: "string & CommerceMinLength<1>",
3665
3665
  value: input.entitlementId
3666
3666
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3667
3667
  method: "typia.createAssertEquals",
3668
3668
  path: _path + ".entitlementId",
3669
- expected: "(string & MinLength<1>)",
3669
+ expected: "(string & CommerceMinLength<1>)",
3670
3670
  value: input.entitlementId
3671
3671
  }, _errorFactory)) && ((Array.isArray(input.debits) || _assertGuard_1._assertGuard(_exceptionable, {
3672
3672
  method: "typia.createAssertEquals",
@@ -3709,12 +3709,12 @@ export const assertCreditSpendResult = (() => {
3709
3709
  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.lotId && (1 <= input.lotId.length || _assertGuard_1._assertGuard(_exceptionable, {
3710
3710
  method: "typia.createAssertEquals",
3711
3711
  path: _path + ".lotId",
3712
- expected: "string & MinLength<1>",
3712
+ expected: "string & CommerceMinLength<1>",
3713
3713
  value: input.lotId
3714
3714
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3715
3715
  method: "typia.createAssertEquals",
3716
3716
  path: _path + ".lotId",
3717
- expected: "(string & MinLength<1>)",
3717
+ expected: "(string & CommerceMinLength<1>)",
3718
3718
  value: input.lotId
3719
3719
  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_1._assertGuard(_exceptionable, {
3720
3720
  method: "typia.createAssertEquals",
@@ -3877,52 +3877,52 @@ export const assertCreditEntitlement = (() => {
3877
3877
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.entitlementId && (1 <= input.entitlementId.length || _assertGuard_1._assertGuard(_exceptionable, {
3878
3878
  method: "typia.createAssertEquals",
3879
3879
  path: _path + ".entitlementId",
3880
- expected: "string & MinLength<1>",
3880
+ expected: "string & CommerceMinLength<1>",
3881
3881
  value: input.entitlementId
3882
3882
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3883
3883
  method: "typia.createAssertEquals",
3884
3884
  path: _path + ".entitlementId",
3885
- expected: "(string & MinLength<1>)",
3885
+ expected: "(string & CommerceMinLength<1>)",
3886
3886
  value: input.entitlementId
3887
3887
  }, _errorFactory)) && ("string" === typeof input.titleId && (1 <= input.titleId.length || _assertGuard_1._assertGuard(_exceptionable, {
3888
3888
  method: "typia.createAssertEquals",
3889
3889
  path: _path + ".titleId",
3890
- expected: "string & MinLength<1>",
3890
+ expected: "string & CommerceMinLength<1>",
3891
3891
  value: input.titleId
3892
3892
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3893
3893
  method: "typia.createAssertEquals",
3894
3894
  path: _path + ".titleId",
3895
- expected: "(string & MinLength<1>)",
3895
+ expected: "(string & CommerceMinLength<1>)",
3896
3896
  value: input.titleId
3897
3897
  }, _errorFactory)) && ("string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
3898
3898
  method: "typia.createAssertEquals",
3899
3899
  path: _path + ".logicalId",
3900
- expected: "string & MinLength<1>",
3900
+ expected: "string & CommerceMinLength<1>",
3901
3901
  value: input.logicalId
3902
3902
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3903
3903
  method: "typia.createAssertEquals",
3904
3904
  path: _path + ".logicalId",
3905
- expected: "(string & MinLength<1>)",
3905
+ expected: "(string & CommerceMinLength<1>)",
3906
3906
  value: input.logicalId
3907
3907
  }, _errorFactory)) && ("string" === typeof input.idempotencyKey && (1 <= input.idempotencyKey.length || _assertGuard_1._assertGuard(_exceptionable, {
3908
3908
  method: "typia.createAssertEquals",
3909
3909
  path: _path + ".idempotencyKey",
3910
- expected: "string & MinLength<1>",
3910
+ expected: "string & CommerceMinLength<1>",
3911
3911
  value: input.idempotencyKey
3912
3912
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3913
3913
  method: "typia.createAssertEquals",
3914
3914
  path: _path + ".idempotencyKey",
3915
- expected: "(string & MinLength<1>)",
3915
+ expected: "(string & CommerceMinLength<1>)",
3916
3916
  value: input.idempotencyKey
3917
3917
  }, _errorFactory)) && ("string" === typeof input.createdAt && (_isFormatDateTime_1._isFormatDateTime(input.createdAt) || _assertGuard_1._assertGuard(_exceptionable, {
3918
3918
  method: "typia.createAssertEquals",
3919
3919
  path: _path + ".createdAt",
3920
- expected: "string & Format<\"date-time\">",
3920
+ expected: "string & CommerceDateTimeFormat",
3921
3921
  value: input.createdAt
3922
3922
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3923
3923
  method: "typia.createAssertEquals",
3924
3924
  path: _path + ".createdAt",
3925
- expected: "(string & Format<\"date-time\">)",
3925
+ expected: "(string & CommerceDateTimeFormat)",
3926
3926
  value: input.createdAt
3927
3927
  }, _errorFactory)) && ((Array.isArray(input.debits) || _assertGuard_1._assertGuard(_exceptionable, {
3928
3928
  method: "typia.createAssertEquals",
@@ -3960,12 +3960,12 @@ export const assertCreditEntitlement = (() => {
3960
3960
  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.lotId && (1 <= input.lotId.length || _assertGuard_1._assertGuard(_exceptionable, {
3961
3961
  method: "typia.createAssertEquals",
3962
3962
  path: _path + ".lotId",
3963
- expected: "string & MinLength<1>",
3963
+ expected: "string & CommerceMinLength<1>",
3964
3964
  value: input.lotId
3965
3965
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3966
3966
  method: "typia.createAssertEquals",
3967
3967
  path: _path + ".lotId",
3968
- expected: "(string & MinLength<1>)",
3968
+ expected: "(string & CommerceMinLength<1>)",
3969
3969
  value: input.lotId
3970
3970
  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_1._assertGuard(_exceptionable, {
3971
3971
  method: "typia.createAssertEquals",
@@ -4030,12 +4030,12 @@ export const assertCreditBalance = (() => {
4030
4030
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.titleId && (1 <= input.titleId.length || _assertGuard_1._assertGuard(_exceptionable, {
4031
4031
  method: "typia.createAssertEquals",
4032
4032
  path: _path + ".titleId",
4033
- expected: "string & MinLength<1>",
4033
+ expected: "string & CommerceMinLength<1>",
4034
4034
  value: input.titleId
4035
4035
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4036
4036
  method: "typia.createAssertEquals",
4037
4037
  path: _path + ".titleId",
4038
- expected: "(string & MinLength<1>)",
4038
+ expected: "(string & CommerceMinLength<1>)",
4039
4039
  value: input.titleId
4040
4040
  }, _errorFactory)) && (("object" === typeof input.balances && null !== input.balances && false === Array.isArray(input.balances) || _assertGuard_1._assertGuard(_exceptionable, {
4041
4041
  method: "typia.createAssertEquals",
@@ -4109,22 +4109,22 @@ export const assertCreditLot = (() => {
4109
4109
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.lotId && (1 <= input.lotId.length || _assertGuard_1._assertGuard(_exceptionable, {
4110
4110
  method: "typia.createAssertEquals",
4111
4111
  path: _path + ".lotId",
4112
- expected: "string & MinLength<1>",
4112
+ expected: "string & CommerceMinLength<1>",
4113
4113
  value: input.lotId
4114
4114
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4115
4115
  method: "typia.createAssertEquals",
4116
4116
  path: _path + ".lotId",
4117
- expected: "(string & MinLength<1>)",
4117
+ expected: "(string & CommerceMinLength<1>)",
4118
4118
  value: input.lotId
4119
4119
  }, _errorFactory)) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_1._assertGuard(_exceptionable, {
4120
4120
  method: "typia.createAssertEquals",
4121
4121
  path: _path + ".currency",
4122
- expected: "string & MinLength<1>",
4122
+ expected: "string & CommerceMinLength<1>",
4123
4123
  value: input.currency
4124
4124
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4125
4125
  method: "typia.createAssertEquals",
4126
4126
  path: _path + ".currency",
4127
- expected: "(string & MinLength<1>)",
4127
+ expected: "(string & CommerceMinLength<1>)",
4128
4128
  value: input.currency
4129
4129
  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_1._assertGuard(_exceptionable, {
4130
4130
  method: "typia.createAssertEquals",
@@ -4149,22 +4149,22 @@ export const assertCreditLot = (() => {
4149
4149
  }, _errorFactory)) && ("string" === typeof input.createdAt && (_isFormatDateTime_1._isFormatDateTime(input.createdAt) || _assertGuard_1._assertGuard(_exceptionable, {
4150
4150
  method: "typia.createAssertEquals",
4151
4151
  path: _path + ".createdAt",
4152
- expected: "string & Format<\"date-time\">",
4152
+ expected: "string & CommerceDateTimeFormat",
4153
4153
  value: input.createdAt
4154
4154
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4155
4155
  method: "typia.createAssertEquals",
4156
4156
  path: _path + ".createdAt",
4157
- expected: "(string & Format<\"date-time\">)",
4157
+ expected: "(string & CommerceDateTimeFormat)",
4158
4158
  value: input.createdAt
4159
4159
  }, _errorFactory)) && (undefined === input.expiresAt || "string" === typeof input.expiresAt && (_isFormatDateTime_1._isFormatDateTime(input.expiresAt) || _assertGuard_1._assertGuard(_exceptionable, {
4160
4160
  method: "typia.createAssertEquals",
4161
4161
  path: _path + ".expiresAt",
4162
- expected: "string & Format<\"date-time\">",
4162
+ expected: "string & CommerceDateTimeFormat",
4163
4163
  value: input.expiresAt
4164
4164
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4165
4165
  method: "typia.createAssertEquals",
4166
4166
  path: _path + ".expiresAt",
4167
- expected: "((string & Format<\"date-time\">) | undefined)",
4167
+ expected: "((string & CommerceDateTimeFormat) | undefined)",
4168
4168
  value: input.expiresAt
4169
4169
  }, _errorFactory)) && (("object" === typeof input.origin && null !== input.origin || _assertGuard_1._assertGuard(_exceptionable, {
4170
4170
  method: "typia.createAssertEquals",
@@ -4207,22 +4207,22 @@ export const assertCreditLot = (() => {
4207
4207
  }, _errorFactory)) && ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
4208
4208
  method: "typia.createAssertEquals",
4209
4209
  path: _path + ".store",
4210
- expected: "string & MinLength<1>",
4210
+ expected: "string & CommerceMinLength<1>",
4211
4211
  value: input.store
4212
4212
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4213
4213
  method: "typia.createAssertEquals",
4214
4214
  path: _path + ".store",
4215
- expected: "(string & MinLength<1>)",
4215
+ expected: "(string & CommerceMinLength<1>)",
4216
4216
  value: input.store
4217
4217
  }, _errorFactory)) && ("string" === typeof input.titleId && (1 <= input.titleId.length || _assertGuard_1._assertGuard(_exceptionable, {
4218
4218
  method: "typia.createAssertEquals",
4219
4219
  path: _path + ".titleId",
4220
- expected: "string & MinLength<1>",
4220
+ expected: "string & CommerceMinLength<1>",
4221
4221
  value: input.titleId
4222
4222
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4223
4223
  method: "typia.createAssertEquals",
4224
4224
  path: _path + ".titleId",
4225
- expected: "(string & MinLength<1>)",
4225
+ expected: "(string & CommerceMinLength<1>)",
4226
4226
  value: input.titleId
4227
4227
  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
4228
4228
  if (["channel", "store", "titleId"].some(prop => key === prop))
@@ -4245,12 +4245,12 @@ export const assertCreditLot = (() => {
4245
4245
  }, _errorFactory)) && ("string" === typeof input.titleId && (1 <= input.titleId.length || _assertGuard_1._assertGuard(_exceptionable, {
4246
4246
  method: "typia.createAssertEquals",
4247
4247
  path: _path + ".titleId",
4248
- expected: "string & MinLength<1>",
4248
+ expected: "string & CommerceMinLength<1>",
4249
4249
  value: input.titleId
4250
4250
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4251
4251
  method: "typia.createAssertEquals",
4252
4252
  path: _path + ".titleId",
4253
- expected: "(string & MinLength<1>)",
4253
+ expected: "(string & CommerceMinLength<1>)",
4254
4254
  value: input.titleId
4255
4255
  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
4256
4256
  if (["kind", "titleId"].some(prop => key === prop))
@@ -4360,22 +4360,22 @@ export const assertFinishTransactionInput = (() => {
4360
4360
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.transactionId && (1 <= input.transactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
4361
4361
  method: "typia.createAssertEquals",
4362
4362
  path: _path + ".transactionId",
4363
- expected: "string & MinLength<1>",
4363
+ expected: "string & CommerceMinLength<1>",
4364
4364
  value: input.transactionId
4365
4365
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4366
4366
  method: "typia.createAssertEquals",
4367
4367
  path: _path + ".transactionId",
4368
- expected: "(string & MinLength<1>)",
4368
+ expected: "(string & CommerceMinLength<1>)",
4369
4369
  value: input.transactionId
4370
4370
  }, _errorFactory)) && ("string" === typeof input.ledgerEntryId && (1 <= input.ledgerEntryId.length || _assertGuard_1._assertGuard(_exceptionable, {
4371
4371
  method: "typia.createAssertEquals",
4372
4372
  path: _path + ".ledgerEntryId",
4373
- expected: "string & MinLength<1>",
4373
+ expected: "string & CommerceMinLength<1>",
4374
4374
  value: input.ledgerEntryId
4375
4375
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4376
4376
  method: "typia.createAssertEquals",
4377
4377
  path: _path + ".ledgerEntryId",
4378
- expected: "(string & MinLength<1>)",
4378
+ expected: "(string & CommerceMinLength<1>)",
4379
4379
  value: input.ledgerEntryId
4380
4380
  }, _errorFactory)) && ("boolean" === typeof input.isConsumable || _assertGuard_1._assertGuard(_exceptionable, {
4381
4381
  method: "typia.createAssertEquals",
@@ -4568,22 +4568,22 @@ export const assertCommerceBridgeGetCapabilitiesResult = (() => {
4568
4568
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.protocolVersion && (1 <= input.protocolVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
4569
4569
  method: "typia.createAssertEquals",
4570
4570
  path: _path + ".protocolVersion",
4571
- expected: "string & MinLength<1>",
4571
+ expected: "string & CommerceMinLength<1>",
4572
4572
  value: input.protocolVersion
4573
4573
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4574
4574
  method: "typia.createAssertEquals",
4575
4575
  path: _path + ".protocolVersion",
4576
- expected: "(string & MinLength<1>)",
4576
+ expected: "(string & CommerceMinLength<1>)",
4577
4577
  value: input.protocolVersion
4578
4578
  }, _errorFactory)) && ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
4579
4579
  method: "typia.createAssertEquals",
4580
4580
  path: _path + ".store",
4581
- expected: "string & MinLength<1>",
4581
+ expected: "string & CommerceMinLength<1>",
4582
4582
  value: input.store
4583
4583
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4584
4584
  method: "typia.createAssertEquals",
4585
4585
  path: _path + ".store",
4586
- expected: "(string & MinLength<1>)",
4586
+ expected: "(string & CommerceMinLength<1>)",
4587
4587
  value: input.store
4588
4588
  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_1._assertGuard(_exceptionable, {
4589
4589
  method: "typia.createAssertEquals",
@@ -4894,32 +4894,32 @@ export const assertCommerceBridgeFetchProductsResult = (() => {
4894
4894
  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
4895
4895
  method: "typia.createAssertEquals",
4896
4896
  path: _path + ".logicalId",
4897
- expected: "string & MinLength<1>",
4897
+ expected: "string & CommerceMinLength<1>",
4898
4898
  value: input.logicalId
4899
4899
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4900
4900
  method: "typia.createAssertEquals",
4901
4901
  path: _path + ".logicalId",
4902
- expected: "(string & MinLength<1>)",
4902
+ expected: "(string & CommerceMinLength<1>)",
4903
4903
  value: input.logicalId
4904
4904
  }, _errorFactory)) && ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
4905
4905
  method: "typia.createAssertEquals",
4906
4906
  path: _path + ".store",
4907
- expected: "string & MinLength<1>",
4907
+ expected: "string & CommerceMinLength<1>",
4908
4908
  value: input.store
4909
4909
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4910
4910
  method: "typia.createAssertEquals",
4911
4911
  path: _path + ".store",
4912
- expected: "(string & MinLength<1>)",
4912
+ expected: "(string & CommerceMinLength<1>)",
4913
4913
  value: input.store
4914
4914
  }, _errorFactory)) && ("string" === typeof input.storeSku && (1 <= input.storeSku.length || _assertGuard_1._assertGuard(_exceptionable, {
4915
4915
  method: "typia.createAssertEquals",
4916
4916
  path: _path + ".storeSku",
4917
- expected: "string & MinLength<1>",
4917
+ expected: "string & CommerceMinLength<1>",
4918
4918
  value: input.storeSku
4919
4919
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4920
4920
  method: "typia.createAssertEquals",
4921
4921
  path: _path + ".storeSku",
4922
- expected: "(string & MinLength<1>)",
4922
+ expected: "(string & CommerceMinLength<1>)",
4923
4923
  value: input.storeSku
4924
4924
  }, _errorFactory)) && ("consumable" === input.kind || "durable" === input.kind || "subscription" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
4925
4925
  method: "typia.createAssertEquals",
@@ -4987,22 +4987,22 @@ export const assertCommerceBridgeFetchProductsResult = (() => {
4987
4987
  }, _errorFactory)) && ("string" === typeof input.currencyCode && (1 <= input.currencyCode.length || _assertGuard_1._assertGuard(_exceptionable, {
4988
4988
  method: "typia.createAssertEquals",
4989
4989
  path: _path + ".currencyCode",
4990
- expected: "string & MinLength<1>",
4990
+ expected: "string & CommerceMinLength<1>",
4991
4991
  value: input.currencyCode
4992
4992
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4993
4993
  method: "typia.createAssertEquals",
4994
4994
  path: _path + ".currencyCode",
4995
- expected: "(string & MinLength<1>)",
4995
+ expected: "(string & CommerceMinLength<1>)",
4996
4996
  value: input.currencyCode
4997
4997
  }, _errorFactory)) && (undefined === input.amountMicros || "number" === typeof input.amountMicros && (_isTypeInt64_1._isTypeInt64(input.amountMicros) || _assertGuard_1._assertGuard(_exceptionable, {
4998
4998
  method: "typia.createAssertEquals",
4999
4999
  path: _path + ".amountMicros",
5000
- expected: "number & Type<\"int64\">",
5000
+ expected: "number & CommerceInt64",
5001
5001
  value: input.amountMicros
5002
5002
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5003
5003
  method: "typia.createAssertEquals",
5004
5004
  path: _path + ".amountMicros",
5005
- expected: "((number & Type<\"int64\">) | undefined)",
5005
+ expected: "((number & CommerceInt64) | undefined)",
5006
5006
  value: input.amountMicros
5007
5007
  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
5008
5008
  if (["formatted", "currencyCode", "amountMicros"].some(prop => key === prop))
@@ -5020,12 +5020,12 @@ export const assertCommerceBridgeFetchProductsResult = (() => {
5020
5020
  const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.offerId && (1 <= input.offerId.length || _assertGuard_1._assertGuard(_exceptionable, {
5021
5021
  method: "typia.createAssertEquals",
5022
5022
  path: _path + ".offerId",
5023
- expected: "string & MinLength<1>",
5023
+ expected: "string & CommerceMinLength<1>",
5024
5024
  value: input.offerId
5025
5025
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5026
5026
  method: "typia.createAssertEquals",
5027
5027
  path: _path + ".offerId",
5028
- expected: "(string & MinLength<1>)",
5028
+ expected: "(string & CommerceMinLength<1>)",
5029
5029
  value: input.offerId
5030
5030
  }, _errorFactory)) && (("object" === typeof input.price && null !== input.price || _assertGuard_1._assertGuard(_exceptionable, {
5031
5031
  method: "typia.createAssertEquals",
@@ -5152,67 +5152,67 @@ export const assertCommerceBridgeGetAvailablePurchasesResult = (() => {
5152
5152
  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
5153
5153
  method: "typia.createAssertEquals",
5154
5154
  path: _path + ".store",
5155
- expected: "string & MinLength<1>",
5155
+ expected: "string & CommerceMinLength<1>",
5156
5156
  value: input.store
5157
5157
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5158
5158
  method: "typia.createAssertEquals",
5159
5159
  path: _path + ".store",
5160
- expected: "(string & MinLength<1>)",
5160
+ expected: "(string & CommerceMinLength<1>)",
5161
5161
  value: input.store
5162
5162
  }, _errorFactory)) && ("string" === typeof input.transactionId && (1 <= input.transactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
5163
5163
  method: "typia.createAssertEquals",
5164
5164
  path: _path + ".transactionId",
5165
- expected: "string & MinLength<1>",
5165
+ expected: "string & CommerceMinLength<1>",
5166
5166
  value: input.transactionId
5167
5167
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5168
5168
  method: "typia.createAssertEquals",
5169
5169
  path: _path + ".transactionId",
5170
- expected: "(string & MinLength<1>)",
5170
+ expected: "(string & CommerceMinLength<1>)",
5171
5171
  value: input.transactionId
5172
5172
  }, _errorFactory)) && (undefined === input.originalTransactionId || "string" === typeof input.originalTransactionId && (1 <= input.originalTransactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
5173
5173
  method: "typia.createAssertEquals",
5174
5174
  path: _path + ".originalTransactionId",
5175
- expected: "string & MinLength<1>",
5175
+ expected: "string & CommerceMinLength<1>",
5176
5176
  value: input.originalTransactionId
5177
5177
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5178
5178
  method: "typia.createAssertEquals",
5179
5179
  path: _path + ".originalTransactionId",
5180
- expected: "((string & MinLength<1>) | undefined)",
5180
+ expected: "((string & CommerceMinLength<1>) | undefined)",
5181
5181
  value: input.originalTransactionId
5182
5182
  }, _errorFactory)) && ("string" === typeof input.storeSku && (1 <= input.storeSku.length || _assertGuard_1._assertGuard(_exceptionable, {
5183
5183
  method: "typia.createAssertEquals",
5184
5184
  path: _path + ".storeSku",
5185
- expected: "string & MinLength<1>",
5185
+ expected: "string & CommerceMinLength<1>",
5186
5186
  value: input.storeSku
5187
5187
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5188
5188
  method: "typia.createAssertEquals",
5189
5189
  path: _path + ".storeSku",
5190
- expected: "(string & MinLength<1>)",
5190
+ expected: "(string & CommerceMinLength<1>)",
5191
5191
  value: input.storeSku
5192
5192
  }, _errorFactory)) && (undefined === input.logicalId || "string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
5193
5193
  method: "typia.createAssertEquals",
5194
5194
  path: _path + ".logicalId",
5195
- expected: "string & MinLength<1>",
5195
+ expected: "string & CommerceMinLength<1>",
5196
5196
  value: input.logicalId
5197
5197
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5198
5198
  method: "typia.createAssertEquals",
5199
5199
  path: _path + ".logicalId",
5200
- expected: "((string & MinLength<1>) | undefined)",
5200
+ expected: "((string & CommerceMinLength<1>) | undefined)",
5201
5201
  value: input.logicalId
5202
5202
  }, _errorFactory)) && ("number" === typeof input.quantity && (_isTypeUint32_1._isTypeUint32(input.quantity) || _assertGuard_1._assertGuard(_exceptionable, {
5203
5203
  method: "typia.createAssertEquals",
5204
5204
  path: _path + ".quantity",
5205
- expected: "number & Type<\"uint32\">",
5205
+ expected: "number & CommerceUint32",
5206
5206
  value: input.quantity
5207
5207
  }, _errorFactory)) && (1 <= input.quantity || _assertGuard_1._assertGuard(_exceptionable, {
5208
5208
  method: "typia.createAssertEquals",
5209
5209
  path: _path + ".quantity",
5210
- expected: "number & Minimum<1>",
5210
+ expected: "number & CommerceMinimum<1>",
5211
5211
  value: input.quantity
5212
5212
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5213
5213
  method: "typia.createAssertEquals",
5214
5214
  path: _path + ".quantity",
5215
- expected: "(number & Type<\"uint32\"> & Minimum<1>)",
5215
+ expected: "(number & CommerceUint32 & CommerceMinimum<1>)",
5216
5216
  value: input.quantity
5217
5217
  }, _errorFactory)) && ("pending" === input.state || "purchased" === input.state || "revoked" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
5218
5218
  method: "typia.createAssertEquals",
@@ -5222,22 +5222,22 @@ export const assertCommerceBridgeGetAvailablePurchasesResult = (() => {
5222
5222
  }, _errorFactory)) && (undefined === input.purchasedAt || "string" === typeof input.purchasedAt && (_isFormatDateTime_1._isFormatDateTime(input.purchasedAt) || _assertGuard_1._assertGuard(_exceptionable, {
5223
5223
  method: "typia.createAssertEquals",
5224
5224
  path: _path + ".purchasedAt",
5225
- expected: "string & Format<\"date-time\">",
5225
+ expected: "string & CommerceDateTimeFormat",
5226
5226
  value: input.purchasedAt
5227
5227
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5228
5228
  method: "typia.createAssertEquals",
5229
5229
  path: _path + ".purchasedAt",
5230
- expected: "((string & Format<\"date-time\">) | undefined)",
5230
+ expected: "((string & CommerceDateTimeFormat) | undefined)",
5231
5231
  value: input.purchasedAt
5232
5232
  }, _errorFactory)) && ("string" === typeof input.token && (1 <= input.token.length || _assertGuard_1._assertGuard(_exceptionable, {
5233
5233
  method: "typia.createAssertEquals",
5234
5234
  path: _path + ".token",
5235
- expected: "string & MinLength<1>",
5235
+ expected: "string & CommerceMinLength<1>",
5236
5236
  value: input.token
5237
5237
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5238
5238
  method: "typia.createAssertEquals",
5239
5239
  path: _path + ".token",
5240
- expected: "(string & MinLength<1>)",
5240
+ expected: "(string & CommerceMinLength<1>)",
5241
5241
  value: input.token
5242
5242
  }, _errorFactory)) && (("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
5243
5243
  method: "typia.createAssertEquals",
@@ -5347,12 +5347,12 @@ export const assertCommerceBridgeGetAvailablePurchasesResult = (() => {
5347
5347
  const _ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.ledgerEntryId && (1 <= input.ledgerEntryId.length || _assertGuard_1._assertGuard(_exceptionable, {
5348
5348
  method: "typia.createAssertEquals",
5349
5349
  path: _path + ".ledgerEntryId",
5350
- expected: "string & MinLength<1>",
5350
+ expected: "string & CommerceMinLength<1>",
5351
5351
  value: input.ledgerEntryId
5352
5352
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5353
5353
  method: "typia.createAssertEquals",
5354
5354
  path: _path + ".ledgerEntryId",
5355
- expected: "(string & MinLength<1>)",
5355
+ expected: "(string & CommerceMinLength<1>)",
5356
5356
  value: input.ledgerEntryId
5357
5357
  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
5358
5358
  if (["ledgerEntryId"].some(prop => key === prop))