@mpgd/platform 0.19.0 → 0.21.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 (12) hide show
  1. package/dist/commerce-conformance.d.ts +160 -53
  2. package/dist/commerce-conformance.js +550 -485
  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-wallet.d.ts +324 -0
  8. package/dist/commerce-wallet.js +2087 -0
  9. package/dist/commerce.d.ts +30 -146
  10. package/dist/commerce.js +260 -235
  11. package/dist/index.d.ts +8 -0
  12. package/package.json +6 -2
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))
@@ -3650,7 +3650,7 @@ export const assertCreditSpendInput = (() => {
3650
3650
  })();
3651
3651
  export const assertCreditSpendResult = (() => {
3652
3652
  const _iv0 = new Set(["ACCOUNT_BINDING_REQUIRED", "ACTION_REQUIRED", "ALREADY_OWNED", "CONFIGURATION_REQUIRED", "INSUFFICIENT_BALANCE", "INVALID_RESPONSE", "IN_PROGRESS", "ITEM_UNAVAILABLE", "NETWORK", "NOT_PREPARED", "OUTCOME_UNKNOWN", "STORE_UNAVAILABLE", "UNKNOWN", "USER_CANCELLED"]);
3653
- const _ae0 = "({ readonly status: \"debited\"; readonly entitlementId: NonEmptyString; readonly debits: readonly CreditDebit[]; readonly alreadyProcessed?: boolean; } | { readonly status: \"rejected\"; readonly error: CommerceErrorInfo; })";
3653
+ const _ae0 = "({ readonly status: \"debited\"; readonly entitlementId: NonEmptyString; readonly debits: readonly CreditDebit[]; readonly createdAt?: IsoTimestamp; readonly alreadyProcessed?: boolean; } | { readonly status: \"rejected\"; readonly error: CommerceErrorInfo; })";
3654
3654
  const _av0 = new Set(["ACCOUNT_BINDING_REQUIRED", "ACTION_REQUIRED", "ALREADY_OWNED", "CONFIGURATION_REQUIRED", "INSUFFICIENT_BALANCE", "INVALID_RESPONSE", "IN_PROGRESS", "ITEM_UNAVAILABLE", "NETWORK", "NOT_PREPARED", "OUTCOME_UNKNOWN", "STORE_UNAVAILABLE", "UNKNOWN", "USER_CANCELLED"]);
3655
3655
  const _ae1 = "(\"ACCOUNT_BINDING_REQUIRED\" | \"ACTION_REQUIRED\" | \"ALREADY_OWNED\" | \"CONFIGURATION_REQUIRED\" | \"INSUFFICIENT_BALANCE\" | \"INVALID_RESPONSE\" | \"IN_PROGRESS\" | \"ITEM_UNAVAILABLE\" | \"NETWORK\" | \"NOT_PREPARED\" | \"OUTCOME_UNKNOWN\" | \"STORE_UNAVAILABLE\" | \"UNKNOWN\" | \"USER_CANCELLED\")";
3656
3656
  const _ao0 = (input, _path, _exceptionable = true) => ("debited" === input.status || _assertGuard_1._assertGuard(_exceptionable, {
@@ -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",
@@ -3688,13 +3688,23 @@ export const assertCreditSpendResult = (() => {
3688
3688
  path: _path + ".debits",
3689
3689
  expected: "ReadonlyArray<CreditDebit>",
3690
3690
  value: input.debits
3691
+ }, _errorFactory)) && (undefined === input.createdAt || "string" === typeof input.createdAt && (_isFormatDateTime_1._isFormatDateTime(input.createdAt) || _assertGuard_1._assertGuard(_exceptionable, {
3692
+ method: "typia.createAssertEquals",
3693
+ path: _path + ".createdAt",
3694
+ expected: "string & CommerceDateTimeFormat",
3695
+ value: input.createdAt
3696
+ }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3697
+ method: "typia.createAssertEquals",
3698
+ path: _path + ".createdAt",
3699
+ expected: "((string & CommerceDateTimeFormat) | undefined)",
3700
+ value: input.createdAt
3691
3701
  }, _errorFactory)) && (undefined === input.alreadyProcessed || "boolean" === typeof input.alreadyProcessed || _assertGuard_1._assertGuard(_exceptionable, {
3692
3702
  method: "typia.createAssertEquals",
3693
3703
  path: _path + ".alreadyProcessed",
3694
3704
  expected: "(boolean | undefined)",
3695
3705
  value: input.alreadyProcessed
3696
3706
  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
3697
- if (["status", "entitlementId", "debits", "alreadyProcessed"].some(prop => key === prop))
3707
+ if (["status", "entitlementId", "debits", "createdAt", "alreadyProcessed"].some(prop => key === prop))
3698
3708
  return true;
3699
3709
  const value = input[key];
3700
3710
  if (undefined === value)
@@ -3709,12 +3719,12 @@ export const assertCreditSpendResult = (() => {
3709
3719
  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.lotId && (1 <= input.lotId.length || _assertGuard_1._assertGuard(_exceptionable, {
3710
3720
  method: "typia.createAssertEquals",
3711
3721
  path: _path + ".lotId",
3712
- expected: "string & MinLength<1>",
3722
+ expected: "string & CommerceMinLength<1>",
3713
3723
  value: input.lotId
3714
3724
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3715
3725
  method: "typia.createAssertEquals",
3716
3726
  path: _path + ".lotId",
3717
- expected: "(string & MinLength<1>)",
3727
+ expected: "(string & CommerceMinLength<1>)",
3718
3728
  value: input.lotId
3719
3729
  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_1._assertGuard(_exceptionable, {
3720
3730
  method: "typia.createAssertEquals",
@@ -3813,8 +3823,8 @@ export const assertCreditSpendResult = (() => {
3813
3823
  value: input
3814
3824
  }, _errorFactory);
3815
3825
  })();
3816
- const _io0 = (input, _exceptionable = true) => "debited" === input.status && ("string" === typeof input.entitlementId && 1 <= input.entitlementId.length) && (Array.isArray(input.debits) && input.debits.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, true && _exceptionable))) && (undefined === input.alreadyProcessed || "boolean" === typeof input.alreadyProcessed) && (3 === Object.keys(input).length || Object.keys(input).every(key => {
3817
- if (["status", "entitlementId", "debits", "alreadyProcessed"].some(prop => key === prop))
3826
+ const _io0 = (input, _exceptionable = true) => "debited" === input.status && ("string" === typeof input.entitlementId && 1 <= input.entitlementId.length) && (Array.isArray(input.debits) && input.debits.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, true && _exceptionable))) && (undefined === input.createdAt || "string" === typeof input.createdAt && _isFormatDateTime_1._isFormatDateTime(input.createdAt)) && (undefined === input.alreadyProcessed || "boolean" === typeof input.alreadyProcessed) && (3 === Object.keys(input).length || Object.keys(input).every(key => {
3827
+ if (["status", "entitlementId", "debits", "createdAt", "alreadyProcessed"].some(prop => key === prop))
3818
3828
  return true;
3819
3829
  const value = input[key];
3820
3830
  if (undefined === value)
@@ -3877,52 +3887,52 @@ export const assertCreditEntitlement = (() => {
3877
3887
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.entitlementId && (1 <= input.entitlementId.length || _assertGuard_1._assertGuard(_exceptionable, {
3878
3888
  method: "typia.createAssertEquals",
3879
3889
  path: _path + ".entitlementId",
3880
- expected: "string & MinLength<1>",
3890
+ expected: "string & CommerceMinLength<1>",
3881
3891
  value: input.entitlementId
3882
3892
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3883
3893
  method: "typia.createAssertEquals",
3884
3894
  path: _path + ".entitlementId",
3885
- expected: "(string & MinLength<1>)",
3895
+ expected: "(string & CommerceMinLength<1>)",
3886
3896
  value: input.entitlementId
3887
3897
  }, _errorFactory)) && ("string" === typeof input.titleId && (1 <= input.titleId.length || _assertGuard_1._assertGuard(_exceptionable, {
3888
3898
  method: "typia.createAssertEquals",
3889
3899
  path: _path + ".titleId",
3890
- expected: "string & MinLength<1>",
3900
+ expected: "string & CommerceMinLength<1>",
3891
3901
  value: input.titleId
3892
3902
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3893
3903
  method: "typia.createAssertEquals",
3894
3904
  path: _path + ".titleId",
3895
- expected: "(string & MinLength<1>)",
3905
+ expected: "(string & CommerceMinLength<1>)",
3896
3906
  value: input.titleId
3897
3907
  }, _errorFactory)) && ("string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
3898
3908
  method: "typia.createAssertEquals",
3899
3909
  path: _path + ".logicalId",
3900
- expected: "string & MinLength<1>",
3910
+ expected: "string & CommerceMinLength<1>",
3901
3911
  value: input.logicalId
3902
3912
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3903
3913
  method: "typia.createAssertEquals",
3904
3914
  path: _path + ".logicalId",
3905
- expected: "(string & MinLength<1>)",
3915
+ expected: "(string & CommerceMinLength<1>)",
3906
3916
  value: input.logicalId
3907
3917
  }, _errorFactory)) && ("string" === typeof input.idempotencyKey && (1 <= input.idempotencyKey.length || _assertGuard_1._assertGuard(_exceptionable, {
3908
3918
  method: "typia.createAssertEquals",
3909
3919
  path: _path + ".idempotencyKey",
3910
- expected: "string & MinLength<1>",
3920
+ expected: "string & CommerceMinLength<1>",
3911
3921
  value: input.idempotencyKey
3912
3922
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3913
3923
  method: "typia.createAssertEquals",
3914
3924
  path: _path + ".idempotencyKey",
3915
- expected: "(string & MinLength<1>)",
3925
+ expected: "(string & CommerceMinLength<1>)",
3916
3926
  value: input.idempotencyKey
3917
3927
  }, _errorFactory)) && ("string" === typeof input.createdAt && (_isFormatDateTime_1._isFormatDateTime(input.createdAt) || _assertGuard_1._assertGuard(_exceptionable, {
3918
3928
  method: "typia.createAssertEquals",
3919
3929
  path: _path + ".createdAt",
3920
- expected: "string & Format<\"date-time\">",
3930
+ expected: "string & CommerceDateTimeFormat",
3921
3931
  value: input.createdAt
3922
3932
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3923
3933
  method: "typia.createAssertEquals",
3924
3934
  path: _path + ".createdAt",
3925
- expected: "(string & Format<\"date-time\">)",
3935
+ expected: "(string & CommerceDateTimeFormat)",
3926
3936
  value: input.createdAt
3927
3937
  }, _errorFactory)) && ((Array.isArray(input.debits) || _assertGuard_1._assertGuard(_exceptionable, {
3928
3938
  method: "typia.createAssertEquals",
@@ -3944,8 +3954,23 @@ export const assertCreditEntitlement = (() => {
3944
3954
  path: _path + ".debits",
3945
3955
  expected: "ReadonlyArray<CreditDebit>",
3946
3956
  value: input.debits
3957
+ }, _errorFactory)) && (undefined === input.quantity || "number" === typeof input.quantity && (_isTypeUint32_1._isTypeUint32(input.quantity) || _assertGuard_1._assertGuard(_exceptionable, {
3958
+ method: "typia.createAssertEquals",
3959
+ path: _path + ".quantity",
3960
+ expected: "number & CommerceUint32",
3961
+ value: input.quantity
3962
+ }, _errorFactory)) && (1 <= input.quantity || _assertGuard_1._assertGuard(_exceptionable, {
3963
+ method: "typia.createAssertEquals",
3964
+ path: _path + ".quantity",
3965
+ expected: "number & CommerceMinimum<1>",
3966
+ value: input.quantity
3967
+ }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3968
+ method: "typia.createAssertEquals",
3969
+ path: _path + ".quantity",
3970
+ expected: "((number & CommerceUint32 & CommerceMinimum<1>) | undefined)",
3971
+ value: input.quantity
3947
3972
  }, _errorFactory)) && (6 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
3948
- if (["entitlementId", "titleId", "logicalId", "idempotencyKey", "createdAt", "debits"].some(prop => key === prop))
3973
+ if (["entitlementId", "titleId", "logicalId", "idempotencyKey", "createdAt", "debits", "quantity"].some(prop => key === prop))
3949
3974
  return true;
3950
3975
  const value = input[key];
3951
3976
  if (undefined === value)
@@ -3960,12 +3985,12 @@ export const assertCreditEntitlement = (() => {
3960
3985
  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.lotId && (1 <= input.lotId.length || _assertGuard_1._assertGuard(_exceptionable, {
3961
3986
  method: "typia.createAssertEquals",
3962
3987
  path: _path + ".lotId",
3963
- expected: "string & MinLength<1>",
3988
+ expected: "string & CommerceMinLength<1>",
3964
3989
  value: input.lotId
3965
3990
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
3966
3991
  method: "typia.createAssertEquals",
3967
3992
  path: _path + ".lotId",
3968
- expected: "(string & MinLength<1>)",
3993
+ expected: "(string & CommerceMinLength<1>)",
3969
3994
  value: input.lotId
3970
3995
  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_1._assertGuard(_exceptionable, {
3971
3996
  method: "typia.createAssertEquals",
@@ -3990,8 +4015,8 @@ export const assertCreditEntitlement = (() => {
3990
4015
  value: value
3991
4016
  }, _errorFactory);
3992
4017
  })));
3993
- const _io0 = (input, _exceptionable = true) => "string" === typeof input.entitlementId && 1 <= input.entitlementId.length && ("string" === typeof input.titleId && 1 <= input.titleId.length) && ("string" === typeof input.logicalId && 1 <= input.logicalId.length) && ("string" === typeof input.idempotencyKey && 1 <= input.idempotencyKey.length) && ("string" === typeof input.createdAt && _isFormatDateTime_1._isFormatDateTime(input.createdAt)) && (Array.isArray(input.debits) && input.debits.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, true && _exceptionable))) && (6 === Object.keys(input).length || Object.keys(input).every(key => {
3994
- if (["entitlementId", "titleId", "logicalId", "idempotencyKey", "createdAt", "debits"].some(prop => key === prop))
4018
+ const _io0 = (input, _exceptionable = true) => "string" === typeof input.entitlementId && 1 <= input.entitlementId.length && ("string" === typeof input.titleId && 1 <= input.titleId.length) && ("string" === typeof input.logicalId && 1 <= input.logicalId.length) && ("string" === typeof input.idempotencyKey && 1 <= input.idempotencyKey.length) && ("string" === typeof input.createdAt && _isFormatDateTime_1._isFormatDateTime(input.createdAt)) && (Array.isArray(input.debits) && input.debits.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, true && _exceptionable))) && (undefined === input.quantity || "number" === typeof input.quantity && (_isTypeUint32_1._isTypeUint32(input.quantity) && 1 <= input.quantity)) && (6 === Object.keys(input).length || Object.keys(input).every(key => {
4019
+ if (["entitlementId", "titleId", "logicalId", "idempotencyKey", "createdAt", "debits", "quantity"].some(prop => key === prop))
3995
4020
  return true;
3996
4021
  const value = input[key];
3997
4022
  if (undefined === value)
@@ -4030,12 +4055,12 @@ export const assertCreditBalance = (() => {
4030
4055
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.titleId && (1 <= input.titleId.length || _assertGuard_1._assertGuard(_exceptionable, {
4031
4056
  method: "typia.createAssertEquals",
4032
4057
  path: _path + ".titleId",
4033
- expected: "string & MinLength<1>",
4058
+ expected: "string & CommerceMinLength<1>",
4034
4059
  value: input.titleId
4035
4060
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4036
4061
  method: "typia.createAssertEquals",
4037
4062
  path: _path + ".titleId",
4038
- expected: "(string & MinLength<1>)",
4063
+ expected: "(string & CommerceMinLength<1>)",
4039
4064
  value: input.titleId
4040
4065
  }, _errorFactory)) && (("object" === typeof input.balances && null !== input.balances && false === Array.isArray(input.balances) || _assertGuard_1._assertGuard(_exceptionable, {
4041
4066
  method: "typia.createAssertEquals",
@@ -4109,22 +4134,22 @@ export const assertCreditLot = (() => {
4109
4134
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.lotId && (1 <= input.lotId.length || _assertGuard_1._assertGuard(_exceptionable, {
4110
4135
  method: "typia.createAssertEquals",
4111
4136
  path: _path + ".lotId",
4112
- expected: "string & MinLength<1>",
4137
+ expected: "string & CommerceMinLength<1>",
4113
4138
  value: input.lotId
4114
4139
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4115
4140
  method: "typia.createAssertEquals",
4116
4141
  path: _path + ".lotId",
4117
- expected: "(string & MinLength<1>)",
4142
+ expected: "(string & CommerceMinLength<1>)",
4118
4143
  value: input.lotId
4119
4144
  }, _errorFactory)) && ("string" === typeof input.currency && (1 <= input.currency.length || _assertGuard_1._assertGuard(_exceptionable, {
4120
4145
  method: "typia.createAssertEquals",
4121
4146
  path: _path + ".currency",
4122
- expected: "string & MinLength<1>",
4147
+ expected: "string & CommerceMinLength<1>",
4123
4148
  value: input.currency
4124
4149
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4125
4150
  method: "typia.createAssertEquals",
4126
4151
  path: _path + ".currency",
4127
- expected: "(string & MinLength<1>)",
4152
+ expected: "(string & CommerceMinLength<1>)",
4128
4153
  value: input.currency
4129
4154
  }, _errorFactory)) && ("number" === typeof input.amount && (0 < input.amount || _assertGuard_1._assertGuard(_exceptionable, {
4130
4155
  method: "typia.createAssertEquals",
@@ -4149,22 +4174,22 @@ export const assertCreditLot = (() => {
4149
4174
  }, _errorFactory)) && ("string" === typeof input.createdAt && (_isFormatDateTime_1._isFormatDateTime(input.createdAt) || _assertGuard_1._assertGuard(_exceptionable, {
4150
4175
  method: "typia.createAssertEquals",
4151
4176
  path: _path + ".createdAt",
4152
- expected: "string & Format<\"date-time\">",
4177
+ expected: "string & CommerceDateTimeFormat",
4153
4178
  value: input.createdAt
4154
4179
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4155
4180
  method: "typia.createAssertEquals",
4156
4181
  path: _path + ".createdAt",
4157
- expected: "(string & Format<\"date-time\">)",
4182
+ expected: "(string & CommerceDateTimeFormat)",
4158
4183
  value: input.createdAt
4159
4184
  }, _errorFactory)) && (undefined === input.expiresAt || "string" === typeof input.expiresAt && (_isFormatDateTime_1._isFormatDateTime(input.expiresAt) || _assertGuard_1._assertGuard(_exceptionable, {
4160
4185
  method: "typia.createAssertEquals",
4161
4186
  path: _path + ".expiresAt",
4162
- expected: "string & Format<\"date-time\">",
4187
+ expected: "string & CommerceDateTimeFormat",
4163
4188
  value: input.expiresAt
4164
4189
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4165
4190
  method: "typia.createAssertEquals",
4166
4191
  path: _path + ".expiresAt",
4167
- expected: "((string & Format<\"date-time\">) | undefined)",
4192
+ expected: "((string & CommerceDateTimeFormat) | undefined)",
4168
4193
  value: input.expiresAt
4169
4194
  }, _errorFactory)) && (("object" === typeof input.origin && null !== input.origin || _assertGuard_1._assertGuard(_exceptionable, {
4170
4195
  method: "typia.createAssertEquals",
@@ -4207,22 +4232,22 @@ export const assertCreditLot = (() => {
4207
4232
  }, _errorFactory)) && ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
4208
4233
  method: "typia.createAssertEquals",
4209
4234
  path: _path + ".store",
4210
- expected: "string & MinLength<1>",
4235
+ expected: "string & CommerceMinLength<1>",
4211
4236
  value: input.store
4212
4237
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4213
4238
  method: "typia.createAssertEquals",
4214
4239
  path: _path + ".store",
4215
- expected: "(string & MinLength<1>)",
4240
+ expected: "(string & CommerceMinLength<1>)",
4216
4241
  value: input.store
4217
4242
  }, _errorFactory)) && ("string" === typeof input.titleId && (1 <= input.titleId.length || _assertGuard_1._assertGuard(_exceptionable, {
4218
4243
  method: "typia.createAssertEquals",
4219
4244
  path: _path + ".titleId",
4220
- expected: "string & MinLength<1>",
4245
+ expected: "string & CommerceMinLength<1>",
4221
4246
  value: input.titleId
4222
4247
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4223
4248
  method: "typia.createAssertEquals",
4224
4249
  path: _path + ".titleId",
4225
- expected: "(string & MinLength<1>)",
4250
+ expected: "(string & CommerceMinLength<1>)",
4226
4251
  value: input.titleId
4227
4252
  }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
4228
4253
  if (["channel", "store", "titleId"].some(prop => key === prop))
@@ -4245,12 +4270,12 @@ export const assertCreditLot = (() => {
4245
4270
  }, _errorFactory)) && ("string" === typeof input.titleId && (1 <= input.titleId.length || _assertGuard_1._assertGuard(_exceptionable, {
4246
4271
  method: "typia.createAssertEquals",
4247
4272
  path: _path + ".titleId",
4248
- expected: "string & MinLength<1>",
4273
+ expected: "string & CommerceMinLength<1>",
4249
4274
  value: input.titleId
4250
4275
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4251
4276
  method: "typia.createAssertEquals",
4252
4277
  path: _path + ".titleId",
4253
- expected: "(string & MinLength<1>)",
4278
+ expected: "(string & CommerceMinLength<1>)",
4254
4279
  value: input.titleId
4255
4280
  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
4256
4281
  if (["kind", "titleId"].some(prop => key === prop))
@@ -4360,22 +4385,22 @@ export const assertFinishTransactionInput = (() => {
4360
4385
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.transactionId && (1 <= input.transactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
4361
4386
  method: "typia.createAssertEquals",
4362
4387
  path: _path + ".transactionId",
4363
- expected: "string & MinLength<1>",
4388
+ expected: "string & CommerceMinLength<1>",
4364
4389
  value: input.transactionId
4365
4390
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4366
4391
  method: "typia.createAssertEquals",
4367
4392
  path: _path + ".transactionId",
4368
- expected: "(string & MinLength<1>)",
4393
+ expected: "(string & CommerceMinLength<1>)",
4369
4394
  value: input.transactionId
4370
4395
  }, _errorFactory)) && ("string" === typeof input.ledgerEntryId && (1 <= input.ledgerEntryId.length || _assertGuard_1._assertGuard(_exceptionable, {
4371
4396
  method: "typia.createAssertEquals",
4372
4397
  path: _path + ".ledgerEntryId",
4373
- expected: "string & MinLength<1>",
4398
+ expected: "string & CommerceMinLength<1>",
4374
4399
  value: input.ledgerEntryId
4375
4400
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4376
4401
  method: "typia.createAssertEquals",
4377
4402
  path: _path + ".ledgerEntryId",
4378
- expected: "(string & MinLength<1>)",
4403
+ expected: "(string & CommerceMinLength<1>)",
4379
4404
  value: input.ledgerEntryId
4380
4405
  }, _errorFactory)) && ("boolean" === typeof input.isConsumable || _assertGuard_1._assertGuard(_exceptionable, {
4381
4406
  method: "typia.createAssertEquals",
@@ -4568,22 +4593,22 @@ export const assertCommerceBridgeGetCapabilitiesResult = (() => {
4568
4593
  const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.protocolVersion && (1 <= input.protocolVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
4569
4594
  method: "typia.createAssertEquals",
4570
4595
  path: _path + ".protocolVersion",
4571
- expected: "string & MinLength<1>",
4596
+ expected: "string & CommerceMinLength<1>",
4572
4597
  value: input.protocolVersion
4573
4598
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4574
4599
  method: "typia.createAssertEquals",
4575
4600
  path: _path + ".protocolVersion",
4576
- expected: "(string & MinLength<1>)",
4601
+ expected: "(string & CommerceMinLength<1>)",
4577
4602
  value: input.protocolVersion
4578
4603
  }, _errorFactory)) && ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
4579
4604
  method: "typia.createAssertEquals",
4580
4605
  path: _path + ".store",
4581
- expected: "string & MinLength<1>",
4606
+ expected: "string & CommerceMinLength<1>",
4582
4607
  value: input.store
4583
4608
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4584
4609
  method: "typia.createAssertEquals",
4585
4610
  path: _path + ".store",
4586
- expected: "(string & MinLength<1>)",
4611
+ expected: "(string & CommerceMinLength<1>)",
4587
4612
  value: input.store
4588
4613
  }, _errorFactory)) && (("object" === typeof input.capabilities && null !== input.capabilities || _assertGuard_1._assertGuard(_exceptionable, {
4589
4614
  method: "typia.createAssertEquals",
@@ -4894,32 +4919,32 @@ export const assertCommerceBridgeFetchProductsResult = (() => {
4894
4919
  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
4895
4920
  method: "typia.createAssertEquals",
4896
4921
  path: _path + ".logicalId",
4897
- expected: "string & MinLength<1>",
4922
+ expected: "string & CommerceMinLength<1>",
4898
4923
  value: input.logicalId
4899
4924
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4900
4925
  method: "typia.createAssertEquals",
4901
4926
  path: _path + ".logicalId",
4902
- expected: "(string & MinLength<1>)",
4927
+ expected: "(string & CommerceMinLength<1>)",
4903
4928
  value: input.logicalId
4904
4929
  }, _errorFactory)) && ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
4905
4930
  method: "typia.createAssertEquals",
4906
4931
  path: _path + ".store",
4907
- expected: "string & MinLength<1>",
4932
+ expected: "string & CommerceMinLength<1>",
4908
4933
  value: input.store
4909
4934
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4910
4935
  method: "typia.createAssertEquals",
4911
4936
  path: _path + ".store",
4912
- expected: "(string & MinLength<1>)",
4937
+ expected: "(string & CommerceMinLength<1>)",
4913
4938
  value: input.store
4914
4939
  }, _errorFactory)) && ("string" === typeof input.storeSku && (1 <= input.storeSku.length || _assertGuard_1._assertGuard(_exceptionable, {
4915
4940
  method: "typia.createAssertEquals",
4916
4941
  path: _path + ".storeSku",
4917
- expected: "string & MinLength<1>",
4942
+ expected: "string & CommerceMinLength<1>",
4918
4943
  value: input.storeSku
4919
4944
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4920
4945
  method: "typia.createAssertEquals",
4921
4946
  path: _path + ".storeSku",
4922
- expected: "(string & MinLength<1>)",
4947
+ expected: "(string & CommerceMinLength<1>)",
4923
4948
  value: input.storeSku
4924
4949
  }, _errorFactory)) && ("consumable" === input.kind || "durable" === input.kind || "subscription" === input.kind || _assertGuard_1._assertGuard(_exceptionable, {
4925
4950
  method: "typia.createAssertEquals",
@@ -4987,22 +5012,22 @@ export const assertCommerceBridgeFetchProductsResult = (() => {
4987
5012
  }, _errorFactory)) && ("string" === typeof input.currencyCode && (1 <= input.currencyCode.length || _assertGuard_1._assertGuard(_exceptionable, {
4988
5013
  method: "typia.createAssertEquals",
4989
5014
  path: _path + ".currencyCode",
4990
- expected: "string & MinLength<1>",
5015
+ expected: "string & CommerceMinLength<1>",
4991
5016
  value: input.currencyCode
4992
5017
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
4993
5018
  method: "typia.createAssertEquals",
4994
5019
  path: _path + ".currencyCode",
4995
- expected: "(string & MinLength<1>)",
5020
+ expected: "(string & CommerceMinLength<1>)",
4996
5021
  value: input.currencyCode
4997
5022
  }, _errorFactory)) && (undefined === input.amountMicros || "number" === typeof input.amountMicros && (_isTypeInt64_1._isTypeInt64(input.amountMicros) || _assertGuard_1._assertGuard(_exceptionable, {
4998
5023
  method: "typia.createAssertEquals",
4999
5024
  path: _path + ".amountMicros",
5000
- expected: "number & Type<\"int64\">",
5025
+ expected: "number & CommerceInt64",
5001
5026
  value: input.amountMicros
5002
5027
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5003
5028
  method: "typia.createAssertEquals",
5004
5029
  path: _path + ".amountMicros",
5005
- expected: "((number & Type<\"int64\">) | undefined)",
5030
+ expected: "((number & CommerceInt64) | undefined)",
5006
5031
  value: input.amountMicros
5007
5032
  }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
5008
5033
  if (["formatted", "currencyCode", "amountMicros"].some(prop => key === prop))
@@ -5020,12 +5045,12 @@ export const assertCommerceBridgeFetchProductsResult = (() => {
5020
5045
  const _ao3 = (input, _path, _exceptionable = true) => ("string" === typeof input.offerId && (1 <= input.offerId.length || _assertGuard_1._assertGuard(_exceptionable, {
5021
5046
  method: "typia.createAssertEquals",
5022
5047
  path: _path + ".offerId",
5023
- expected: "string & MinLength<1>",
5048
+ expected: "string & CommerceMinLength<1>",
5024
5049
  value: input.offerId
5025
5050
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5026
5051
  method: "typia.createAssertEquals",
5027
5052
  path: _path + ".offerId",
5028
- expected: "(string & MinLength<1>)",
5053
+ expected: "(string & CommerceMinLength<1>)",
5029
5054
  value: input.offerId
5030
5055
  }, _errorFactory)) && (("object" === typeof input.price && null !== input.price || _assertGuard_1._assertGuard(_exceptionable, {
5031
5056
  method: "typia.createAssertEquals",
@@ -5152,67 +5177,67 @@ export const assertCommerceBridgeGetAvailablePurchasesResult = (() => {
5152
5177
  const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
5153
5178
  method: "typia.createAssertEquals",
5154
5179
  path: _path + ".store",
5155
- expected: "string & MinLength<1>",
5180
+ expected: "string & CommerceMinLength<1>",
5156
5181
  value: input.store
5157
5182
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5158
5183
  method: "typia.createAssertEquals",
5159
5184
  path: _path + ".store",
5160
- expected: "(string & MinLength<1>)",
5185
+ expected: "(string & CommerceMinLength<1>)",
5161
5186
  value: input.store
5162
5187
  }, _errorFactory)) && ("string" === typeof input.transactionId && (1 <= input.transactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
5163
5188
  method: "typia.createAssertEquals",
5164
5189
  path: _path + ".transactionId",
5165
- expected: "string & MinLength<1>",
5190
+ expected: "string & CommerceMinLength<1>",
5166
5191
  value: input.transactionId
5167
5192
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5168
5193
  method: "typia.createAssertEquals",
5169
5194
  path: _path + ".transactionId",
5170
- expected: "(string & MinLength<1>)",
5195
+ expected: "(string & CommerceMinLength<1>)",
5171
5196
  value: input.transactionId
5172
5197
  }, _errorFactory)) && (undefined === input.originalTransactionId || "string" === typeof input.originalTransactionId && (1 <= input.originalTransactionId.length || _assertGuard_1._assertGuard(_exceptionable, {
5173
5198
  method: "typia.createAssertEquals",
5174
5199
  path: _path + ".originalTransactionId",
5175
- expected: "string & MinLength<1>",
5200
+ expected: "string & CommerceMinLength<1>",
5176
5201
  value: input.originalTransactionId
5177
5202
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5178
5203
  method: "typia.createAssertEquals",
5179
5204
  path: _path + ".originalTransactionId",
5180
- expected: "((string & MinLength<1>) | undefined)",
5205
+ expected: "((string & CommerceMinLength<1>) | undefined)",
5181
5206
  value: input.originalTransactionId
5182
5207
  }, _errorFactory)) && ("string" === typeof input.storeSku && (1 <= input.storeSku.length || _assertGuard_1._assertGuard(_exceptionable, {
5183
5208
  method: "typia.createAssertEquals",
5184
5209
  path: _path + ".storeSku",
5185
- expected: "string & MinLength<1>",
5210
+ expected: "string & CommerceMinLength<1>",
5186
5211
  value: input.storeSku
5187
5212
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5188
5213
  method: "typia.createAssertEquals",
5189
5214
  path: _path + ".storeSku",
5190
- expected: "(string & MinLength<1>)",
5215
+ expected: "(string & CommerceMinLength<1>)",
5191
5216
  value: input.storeSku
5192
5217
  }, _errorFactory)) && (undefined === input.logicalId || "string" === typeof input.logicalId && (1 <= input.logicalId.length || _assertGuard_1._assertGuard(_exceptionable, {
5193
5218
  method: "typia.createAssertEquals",
5194
5219
  path: _path + ".logicalId",
5195
- expected: "string & MinLength<1>",
5220
+ expected: "string & CommerceMinLength<1>",
5196
5221
  value: input.logicalId
5197
5222
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5198
5223
  method: "typia.createAssertEquals",
5199
5224
  path: _path + ".logicalId",
5200
- expected: "((string & MinLength<1>) | undefined)",
5225
+ expected: "((string & CommerceMinLength<1>) | undefined)",
5201
5226
  value: input.logicalId
5202
5227
  }, _errorFactory)) && ("number" === typeof input.quantity && (_isTypeUint32_1._isTypeUint32(input.quantity) || _assertGuard_1._assertGuard(_exceptionable, {
5203
5228
  method: "typia.createAssertEquals",
5204
5229
  path: _path + ".quantity",
5205
- expected: "number & Type<\"uint32\">",
5230
+ expected: "number & CommerceUint32",
5206
5231
  value: input.quantity
5207
5232
  }, _errorFactory)) && (1 <= input.quantity || _assertGuard_1._assertGuard(_exceptionable, {
5208
5233
  method: "typia.createAssertEquals",
5209
5234
  path: _path + ".quantity",
5210
- expected: "number & Minimum<1>",
5235
+ expected: "number & CommerceMinimum<1>",
5211
5236
  value: input.quantity
5212
5237
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5213
5238
  method: "typia.createAssertEquals",
5214
5239
  path: _path + ".quantity",
5215
- expected: "(number & Type<\"uint32\"> & Minimum<1>)",
5240
+ expected: "(number & CommerceUint32 & CommerceMinimum<1>)",
5216
5241
  value: input.quantity
5217
5242
  }, _errorFactory)) && ("pending" === input.state || "purchased" === input.state || "revoked" === input.state || _assertGuard_1._assertGuard(_exceptionable, {
5218
5243
  method: "typia.createAssertEquals",
@@ -5222,22 +5247,22 @@ export const assertCommerceBridgeGetAvailablePurchasesResult = (() => {
5222
5247
  }, _errorFactory)) && (undefined === input.purchasedAt || "string" === typeof input.purchasedAt && (_isFormatDateTime_1._isFormatDateTime(input.purchasedAt) || _assertGuard_1._assertGuard(_exceptionable, {
5223
5248
  method: "typia.createAssertEquals",
5224
5249
  path: _path + ".purchasedAt",
5225
- expected: "string & Format<\"date-time\">",
5250
+ expected: "string & CommerceDateTimeFormat",
5226
5251
  value: input.purchasedAt
5227
5252
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5228
5253
  method: "typia.createAssertEquals",
5229
5254
  path: _path + ".purchasedAt",
5230
- expected: "((string & Format<\"date-time\">) | undefined)",
5255
+ expected: "((string & CommerceDateTimeFormat) | undefined)",
5231
5256
  value: input.purchasedAt
5232
5257
  }, _errorFactory)) && ("string" === typeof input.token && (1 <= input.token.length || _assertGuard_1._assertGuard(_exceptionable, {
5233
5258
  method: "typia.createAssertEquals",
5234
5259
  path: _path + ".token",
5235
- expected: "string & MinLength<1>",
5260
+ expected: "string & CommerceMinLength<1>",
5236
5261
  value: input.token
5237
5262
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5238
5263
  method: "typia.createAssertEquals",
5239
5264
  path: _path + ".token",
5240
- expected: "(string & MinLength<1>)",
5265
+ expected: "(string & CommerceMinLength<1>)",
5241
5266
  value: input.token
5242
5267
  }, _errorFactory)) && (("object" === typeof input.evidence && null !== input.evidence || _assertGuard_1._assertGuard(_exceptionable, {
5243
5268
  method: "typia.createAssertEquals",
@@ -5347,12 +5372,12 @@ export const assertCommerceBridgeGetAvailablePurchasesResult = (() => {
5347
5372
  const _ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.ledgerEntryId && (1 <= input.ledgerEntryId.length || _assertGuard_1._assertGuard(_exceptionable, {
5348
5373
  method: "typia.createAssertEquals",
5349
5374
  path: _path + ".ledgerEntryId",
5350
- expected: "string & MinLength<1>",
5375
+ expected: "string & CommerceMinLength<1>",
5351
5376
  value: input.ledgerEntryId
5352
5377
  }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
5353
5378
  method: "typia.createAssertEquals",
5354
5379
  path: _path + ".ledgerEntryId",
5355
- expected: "(string & MinLength<1>)",
5380
+ expected: "(string & CommerceMinLength<1>)",
5356
5381
  value: input.ledgerEntryId
5357
5382
  }, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
5358
5383
  if (["ledgerEntryId"].some(prop => key === prop))