@owlmeans/payment 0.1.18-rc.9 → 0.1.18

package/src/entitlement.ts

@@ -1,122 +1,86 @@
-import { gate } from '@owlmeans/entrypoint'
-import type { CommonEntrypointOptions } from '@owlmeans/entrypoint'
 import type { PermissionSet } from '@owlmeans/auth'
+import { CAPABILITY_LIMIT_SCOPE } from './consts.js'
+import type { EntitlementParam } from './types.js'
+import type { EntitlementParamHelper } from './entitlement/types.js'
 
-/**
- * The gate alias a paid capability is asserted under.
- *
- * Distinct from `paymentGate.base` (a ROUTE id) and from the gateway service alias — three
- * different things that would otherwise all be called "payment gate".
- */
-export const ENTITLEMENT_GATE = 'entitlement-gate'
+export const createEntitlementParamHelper = (): EntitlementParamHelper => {
+  const parseEntitlementParam = (param: string): EntitlementParam => {
+    const [scoped, floor] = param.split('>=')
+    const colon = scoped.indexOf(':')
+    const parsed: EntitlementParam = colon >= 0
+      ? { scope: scoped.slice(0, colon), permission: scoped.slice(colon + 1) }
+      : { permission: scoped }
 
-/**
- * The capability scope that carries FEATURE flags.
- *
- * Kept apart from `renewable`, which carries numeric quotas that are consumed or counted. Merging
- * them would make "has one production slot left" and "may remove the platform credit" the same
- * number, and the first purchase that spent the quota would take the feature with it.
- */
-export const CAPABILITY_FEATURE_SCOPE = 'feature'
-
-export interface EntitlementParam {
-  /** Capability scope. Absent means any scope. */
-  scope?: string
-  /** The permission key inside `PermissionSet.permissions`. */
-  permission: string
-  /** Numeric floor: `credits>=100` passes when the held value is a number at least that big. */
-  atLeast?: number
-}
-
-/**
- * Grammar: `[<scope>:]<permission>[>=<n>]`.
- *
- * `feature:branding--whitelabel` · `renewable:credits>=100` · `production--standalone`
- *
- * `@` is deliberately not part of it: that is `@owlmeans/iam`'s resource-selector syntax, and a
- * grammar that reused it would make two different things look the same in a route declaration.
- */
-export const parseEntitlementParam = (param: string): EntitlementParam => {
-  const [scoped, floor] = param.split('>=')
-  const colon = scoped.indexOf(':')
-  const parsed: EntitlementParam = colon >= 0
-    ? { scope: scoped.slice(0, colon), permission: scoped.slice(colon + 1) }
-    : { permission: scoped }
-
-  if (floor != null) {
-    const value = Number.parseFloat(floor)
-    if (!Number.isNaN(value)) {
-      parsed.atLeast = value
+    if (floor != null) {
+      const value = Number.parseFloat(floor)
+      if (!Number.isNaN(value)) {
+        parsed.atLeast = value
+      }
     }
-  }
 
-  return parsed
-}
-
-export const formatEntitlementParam = (parsed: EntitlementParam): string =>
-  `${parsed.scope != null ? `${parsed.scope}:` : ''}${parsed.permission}` +
-  `${parsed.atLeast != null ? `>=${parsed.atLeast}` : ''}`
-
-/**
- * Whether a union of capability sets satisfies one requirement.
- *
- * Pure, and shared by the server gate and the browser: the UI has to know whether to render a
- * control disabled, and a second implementation of the rule for the client would eventually
- * disagree with the one that actually refuses.
- *
- * A malformed parameter answers `false` rather than throwing. A gate that crashed on a typo would
- * take down the endpoint it guards, which is a strictly worse failure than refusing it.
- */
-export const hasEntitlement = (
-  capabilities: PermissionSet[] | undefined, param: string
-): boolean => {
-  if (capabilities == null || capabilities.length < 1) {
-    return false
-  }
-  const { scope, permission, atLeast } = parseEntitlementParam(param)
-  if (permission === '') {
-    return false
+    return parsed
   }
 
-  return capabilities.some(set => {
-    if (scope != null && set.scope !== scope) {
+  const formatEntitlementParam = (parsed: EntitlementParam): string =>
+    `${parsed.scope != null ? `${parsed.scope}:` : ''}${parsed.permission}` +
+    `${parsed.atLeast != null ? `>=${parsed.atLeast}` : ''}`
+
+  const hasEntitlement = (
+    capabilities: PermissionSet[] | undefined, param: string
+  ): boolean => {
+    if (capabilities == null || capabilities.length < 1) {
       return false
     }
-    const held = set.permissions?.[permission]
-    if (held == null || held === false) {
+    if (typeof param !== 'string') {
+      return false
+    }
+    const { scope, permission, atLeast } = parseEntitlementParam(param)
+    // A limit is never a capability: its room is counted, not granted.
+    if (permission === '' || scope === CAPABILITY_LIMIT_SCOPE) {
       return false
     }
 
-    // A floor is a numeric question: a boolean flag, however true, does not answer it.
-    return atLeast != null ? typeof held === 'number' && held >= atLeast : true
-  })
-}
+    return capabilities.some(set => {
+      if (scope != null && set.scope !== scope) {
+        return false
+      }
+      const held = set.permissions?.[permission]
+      if (held == null || held === false) {
+        return false
+      }
+
+      // A floor is a numeric question: a boolean flag, however true, does not answer it.
+      return atLeast != null ? typeof held === 'number' && held >= atLeast : true
+    })
+  }
 
-/** Everything a union grants, formatted back into parameters. The wire shape of a client read. */
-export const entitlementList = (capabilities: PermissionSet[] | undefined): string[] => {
-  const list: string[] = []
-  for (const set of capabilities ?? []) {
-    for (const [permission, value] of Object.entries(set.permissions ?? {})) {
-      if (value == null || value === false) {
-        continue
+  const entitlementList = (capabilities: PermissionSet[] | undefined): string[] => {
+    const list: string[] = []
+    for (const set of capabilities ?? []) {
+      for (const [permission, value] of Object.entries(set.permissions ?? {})) {
+        if (value == null || value === false) {
+          continue
+        }
+        list.push(formatEntitlementParam({ scope: set.scope, permission }))
       }
-      list.push(formatEntitlementParam({ scope: set.scope, permission }))
     }
+
+    return [...new Set(list)]
   }
 
-  return [...new Set(list)]
+  return { parseEntitlementParam, formatEntitlementParam, hasEntitlement, entitlementList }
 }
 
-/**
- * Declare that an entrypoint needs a paid capability.
- *
- * Sugar over `gate(ENTITLEMENT_GATE, params)` so a route reads as what it means. Several
- * parameters are OR'd, matching every other gate in the framework.
- *
- * Putting the requirement HERE rather than in a handler is the point: the framework asserts a gate
- * before the handler is entered, so the route table states what a feature costs and no new
- * endpoint can forget to check.
- */
-export const entitled = (
-  params: string | string[], opts?: CommonEntrypointOptions
-): CommonEntrypointOptions => gate(ENTITLEMENT_GATE, params, opts)
+export const entitlementParamHelper = createEntitlementParamHelper()
+
+/** @deprecated compat:factory-refactor — use `entitlementParamHelper.parseEntitlementParam(…)` */
+export const parseEntitlementParam = (param: string): EntitlementParam =>
+  entitlementParamHelper.parseEntitlementParam(param)
+
+/** @deprecated compat:factory-refactor — use `entitlementParamHelper.formatEntitlementParam(…)` */
+export const formatEntitlementParam = (parsed: EntitlementParam): string =>
+  entitlementParamHelper.formatEntitlementParam(parsed)
+
+/** @deprecated compat:factory-refactor — use `entitlementParamHelper.hasEntitlement(…)` */
+export const hasEntitlement = (capabilities: PermissionSet[] | undefined, param: string): boolean =>
+  entitlementParamHelper.hasEntitlement(capabilities, param)

package/src/errors.ts

@@ -1,5 +1,8 @@
 
 import { ResilientError } from '@owlmeans/error'
+import { AuthForbidden } from '@owlmeans/auth'
+import { BILLING_COUNTRY_LOCKED_MARKER, CANCELLATION_UNAVAILABLE_MARKER, CAPABILITY_REQUIRED_MARKER, CHECKOUT_LIMIT_MARKER, LIMIT_EXHAUSTED_FIELDS, LIMIT_EXHAUSTED_MARKER, PERFORMANCE_CONSENT_MARKER, SUBSCRIPTION_START_MARKER, WITHDRAWAL_UNAVAILABLE_MARKER } from './consts.local.js'
+import type { BillingCountryLockedDetails, CheckoutLimitExceededDetails, LimitExhaustedDetails, PerformanceConsentRequiredDetails } from './types.js'
 
 export class PaymentError extends ResilientError {
   public static override typeName: string = 'PaymentError'
@@ -36,6 +39,22 @@ export class PaygateMappingError extends PaygateError {
   }
 }
 
+/**
+ * A webhook delivery whose signature is missing or verifies against no known secret. The sender is
+ * refused as a client error (400): a forged or unsigned POST at a public hook is not a server fault,
+ * and answering 500 would page operators for it and invite the sender to retry it.
+ */
+export class PaygateSignatureError extends PaygateError {
+  public static override typeName: string = `${PaygateError.typeName}Signature`
+  /** Read by the HTTP boundary (`server-api` `declaredErrorStatus`). */
+  public static httpStatus: number = 400
+
+  constructor() {
+    super('signature')
+    this.type = PaygateSignatureError.typeName
+  }
+}
+
 export class ProductError extends PaymentError {
   public static override typeName: string = `${PaymentError.typeName}Product`
 
@@ -90,13 +109,439 @@ export class UnknownSubscription extends SubscriptionError {
   }
 }
 
+export class LimitUnknown extends ProductError {
+  public static override typeName: string = `${ProductError.typeName}LimitUnknown`
+
+  constructor(message: string = 'error') {
+    super(`limit-unknown:${message}`)
+    this.type = LimitUnknown.typeName
+  }
+}
+
+export class LimitMisdeclared extends ProductError {
+  public static override typeName: string = `${ProductError.typeName}LimitMisdeclared`
+
+  constructor(message: string = 'error') {
+    super(`limit-misdeclared:${message}`)
+    this.type = LimitMisdeclared.typeName
+  }
+}
+
+export class PlanRequired extends ProductError {
+  public static override typeName: string = `${ProductError.typeName}PlanRequired`
+
+  constructor(message: string = 'error') {
+    super(`plan-required:${message}`)
+    this.type = PlanRequired.typeName
+  }
+}
+
+export class PlanRankConflict extends ProductError {
+  public static override typeName: string = `${ProductError.typeName}PlanRankConflict`
+
+  constructor(message: string = 'error') {
+    super(`plan-rank-conflict:${message}`)
+    this.type = PlanRankConflict.typeName
+  }
+}
+
+export class WebhookSetupError extends PaygateError {
+  public static override typeName: string = `${PaygateError.typeName}WebhookSetup`
+
+  constructor(message: string = 'error') {
+    super(`webhook-setup:${message}`)
+    this.type = WebhookSetupError.typeName
+  }
+}
+
+/**
+ * The entity has nothing the requested portal flow can act on — no paygate customer, no entitling
+ * subscription, no plan or item to change to. The entity's own state, not a fault: an HTTP boundary
+ * that honours `httpStatus` (`@owlmeans/server-api`) answers 409 Conflict.
+ */
+export class PortalUnavailable extends PaygateError {
+  public static override typeName: string = `${PaygateError.typeName}PortalUnavailable`
+  public static httpStatus = 409
+
+  constructor(message: string = 'error') {
+    super(`portal-unavailable:${message}`)
+    this.type = PortalUnavailable.typeName
+  }
+}
+
+/**
+ * The entity's plan does not allow the request.
+ *
+ * Extends `AuthForbidden` so an HTTP boundary answers 403, never 500. Only `type` and `message`
+ * survive a marshal round trip, so each subclass packs its fields into the message and rebuilds
+ * them in `finalizeUnmarshal()`.
+ */
+export class EntitlementRefusal extends AuthForbidden {
+  public static override typeName: string = 'EntitlementRefusal'
+
+  constructor(message: string = 'error') {
+    super(`entitlement:${message}`)
+    this.type = EntitlementRefusal.typeName
+  }
+}
+
+/** None of the capability parameters (OR'd) is granted. Message marker `capability-required:<a|b>`. */
+export class CapabilityRequired extends EntitlementRefusal {
+  public static override typeName: string = `${EntitlementRefusal.typeName}CapabilityRequired`
+
+  /** The refused parameters, as the gate took them. */
+  public params: string[] = []
+
+  constructor(params: string | string[] = []) {
+    const list = (Array.isArray(params) ? params : [params]).filter(param => param !== '')
+    super(`${CAPABILITY_REQUIRED_MARKER}${list.join('|')}`)
+    this.type = CapabilityRequired.typeName
+    this.applyFields()
+  }
+
+  private applyFields(): void {
+    const at = this.message.indexOf(CAPABILITY_REQUIRED_MARKER)
+    const packed = at < 0 ? '' : this.message.slice(at + CAPABILITY_REQUIRED_MARKER.length)
+    this.params = packed.split('|').filter(param => param !== '')
+  }
+
+  override finalizeUnmarshal(): void {
+    this.applyFields()
+  }
+}
+
+
+/**
+ * A limit has no room left. Message marker `limit-exhausted:<key>:<used>/<limit>[:<resetsAt ISO>]`.
+ */
+export class LimitExhausted extends EntitlementRefusal {
+  public static override typeName: string = `${EntitlementRefusal.typeName}LimitExhausted`
+
+  public limitKey: string = ''
+  public used: number = 0
+  public limit: number = 0
+  public resetsAt?: Date
+
+  /** The packed marker body of a refusal. */
+  static encode(details: LimitExhaustedDetails): string {
+    const resetsAt = details.resetsAt != null && !Number.isNaN(details.resetsAt.getTime())
+      ? `:${details.resetsAt.toISOString()}` : ''
+    return `${details.key}:${details.used}/${details.limit}${resetsAt}`
+  }
+
+  constructor(details: LimitExhaustedDetails)
+  /** A packed marker body (`LimitExhausted.encode`) or a marshaled message — the error registry's path. */
+  constructor(message: string)
+  constructor(details: LimitExhaustedDetails | string = 'error') {
+    super(`${LIMIT_EXHAUSTED_MARKER}${typeof details === 'string' ? details : LimitExhausted.encode(details)}`)
+    this.type = LimitExhausted.typeName
+    this.applyFields()
+  }
+
+  private applyFields(): void {
+    const at = this.message.indexOf(LIMIT_EXHAUSTED_MARKER)
+    const match = at < 0 ? null
+      : LIMIT_EXHAUSTED_FIELDS.exec(this.message.slice(at + LIMIT_EXHAUSTED_MARKER.length))
+    if (match == null) {
+      return
+    }
+    const [, key, used, limit, resetsAt] = match
+    this.limitKey = key
+    this.used = Number(used) || 0
+    this.limit = Number(limit) || 0
+    const date = resetsAt != null ? new Date(resetsAt) : null
+    this.resetsAt = date != null && !Number.isNaN(date.getTime()) ? date : undefined
+  }
+
+  override finalizeUnmarshal(): void {
+    this.applyFields()
+  }
+}
+
+/**
+ * A consumer-rights fault — a misdeclared policy (`policy:<field>`), a missing usage meter or
+ * mailer, a copy template without a value (`copy:<path>`). Declares no status: 500.
+ */
+export class ConsumerRightsError extends PaymentError {
+  public static override typeName: string = `${PaymentError.typeName}ConsumerRights`
+
+  constructor(message: string = 'error') {
+    super(`consumer-rights:${message}`)
+    this.type = ConsumerRightsError.typeName
+  }
+}
+
+/**
+ * The consumer's own position refuses the request — never a fault. Deliberately NOT an
+ * `AuthForbidden`: an HTTP boundary tests that family first, and a 403 would hide the declared
+ * 428/409 a client acts on.
+ */
+export class ConsumerRightsRefusal extends ConsumerRightsError {
+  public static override typeName: string = `${ConsumerRightsError.typeName}Refusal`
+
+  constructor(message: string = 'error') {
+    super(message)
+    this.type = ConsumerRightsRefusal.typeName
+  }
+}
+
+/** The packed body after the LAST marker occurrence — a registry rebuild doubles the prefix. */
+const packedAfter = (message: string, marker: string): string | null => {
+  const at = message.lastIndexOf(marker)
+
+  return at < 0 ? null : message.slice(at + marker.length)
+}
+
+const dateOf = (value: string | undefined): Date | undefined => {
+  const date = value != null && value !== '' ? new Date(value) : null
+
+  return date != null && !Number.isNaN(date.getTime()) ? date : undefined
+}
+
+const isoOf = (date: Date | undefined): string =>
+  date != null && !Number.isNaN(date.getTime()) ? `:${date.toISOString()}` : ''
+
+const decode = (value: string): string => {
+  try {
+    return decodeURIComponent(value)
+  } catch {
+    return value
+  }
+}
+
+/**
+ * Billed work would spend credits of a purchase still inside its withdrawal window, and the
+ * consumer has not expressly requested performance. HTTP 428. Marker
+ * `performance-consent-required:<pending>[:<deadline ISO>]`.
+ */
+export class PerformanceConsentRequired extends ConsumerRightsRefusal {
+  public static override typeName: string = `${ConsumerRightsRefusal.typeName}PerformanceConsentRequired`
+  public static httpStatus = 428
+
+  public pending: number = 0
+  public deadline?: Date
+
+  static encode(details: PerformanceConsentRequiredDetails): string {
+    return `${Math.max(0, Math.floor(details.pending))}${isoOf(details.deadline)}`
+  }
+
+  constructor(details: PerformanceConsentRequiredDetails)
+  /** A packed marker body (`encode`) or a marshaled message — the error registry's path. */
+  constructor(message: string)
+  constructor(details: PerformanceConsentRequiredDetails | string = 'error') {
+    super(`${PERFORMANCE_CONSENT_MARKER}${typeof details === 'string' ? details : PerformanceConsentRequired.encode(details)}`)
+    this.type = PerformanceConsentRequired.typeName
+    this.applyFields()
+  }
+
+  private applyFields(): void {
+    const match = /^(\d+)(?::(.+))?$/.exec(packedAfter(this.message, PERFORMANCE_CONSENT_MARKER) ?? '')
+    if (match == null) {
+      return
+    }
+    this.pending = Number(match[1])
+    this.deadline = dateOf(match[2])
+  }
+
+  override finalizeUnmarshal(): void {
+    this.applyFields()
+  }
+}
+
+/**
+ * A subscription checkout needs a fresh express start request bound to this plan. HTTP 428.
+ * Marker `subscription-start-required:<encodeURIComponent(planSku)>`.
+ */
+export class SubscriptionStartRequired extends ConsumerRightsRefusal {
+  public static override typeName: string = `${ConsumerRightsRefusal.typeName}SubscriptionStartRequired`
+  public static httpStatus = 428
+
+  public planSku: string = ''
+
+  static encode(planSku: string): string {
+    return encodeURIComponent(planSku)
+  }
+
+  /** `planSku` as is, or a packed marker body / marshaled message (the registry's path). */
+  constructor(planSku: string | { planSku: string } = 'error') {
+    super(`${SUBSCRIPTION_START_MARKER}${typeof planSku === 'string' ? SubscriptionStartRequired.encodeLoose(planSku) : SubscriptionStartRequired.encode(planSku.planSku)}`)
+    this.type = SubscriptionStartRequired.typeName
+    this.applyFields()
+  }
+
+  /** A string that already is a marker (the registry path) passes through unencoded. */
+  private static encodeLoose(value: string): string {
+    return value.includes(SUBSCRIPTION_START_MARKER) ? value : SubscriptionStartRequired.encode(value)
+  }
+
+  private applyFields(): void {
+    const packed = packedAfter(this.message, SUBSCRIPTION_START_MARKER)
+    if (packed != null) {
+      this.planSku = decode(packed)
+    }
+  }
+
+  override finalizeUnmarshal(): void {
+    this.applyFields()
+  }
+}
+
+/**
+ * The entity's billing country is fixed and the request declared another. HTTP 409. Marker
+ * `billing-country-locked:<country>[:<requested>]`.
+ */
+export class BillingCountryLocked extends ConsumerRightsRefusal {
+  public static override typeName: string = `${ConsumerRightsRefusal.typeName}BillingCountryLocked`
+  public static httpStatus = 409
+
+  public country: string = ''
+  public requested?: string
+
+  static encode(details: BillingCountryLockedDetails): string {
+    return details.requested != null && details.requested !== ''
+      ? `${details.country}:${details.requested}` : details.country
+  }
+
+  constructor(details: BillingCountryLockedDetails)
+  constructor(message: string)
+  constructor(details: BillingCountryLockedDetails | string = 'error') {
+    super(`${BILLING_COUNTRY_LOCKED_MARKER}${typeof details === 'string' ? details : BillingCountryLocked.encode(details)}`)
+    this.type = BillingCountryLocked.typeName
+    this.applyFields()
+  }
+
+  private applyFields(): void {
+    const match = /^([A-Za-z]{2})(?::([A-Za-z]{2}))?$/.exec(packedAfter(this.message, BILLING_COUNTRY_LOCKED_MARKER) ?? '')
+    if (match == null) {
+      return
+    }
+    this.country = match[1]
+    this.requested = match[2]
+  }
+
+  override finalizeUnmarshal(): void {
+    this.applyFields()
+  }
+}
+
+/**
+ * The named purchase cannot be withdrawn from (`WithdrawalUnavailableReason`). HTTP 409. Marker
+ * `withdrawal-unavailable:<reason>`. Never raised on the public page, which discloses nothing.
+ */
+export class WithdrawalUnavailable extends ConsumerRightsRefusal {
+  public static override typeName: string = `${ConsumerRightsRefusal.typeName}WithdrawalUnavailable`
+  public static httpStatus = 409
+
+  public reason: string = ''
+
+  constructor(reason: string = 'error') {
+    super(`${WITHDRAWAL_UNAVAILABLE_MARKER}${reason}`)
+    this.type = WithdrawalUnavailable.typeName
+    this.applyFields()
+  }
+
+  private applyFields(): void {
+    this.reason = /^[\w-]*/.exec(packedAfter(this.message, WITHDRAWAL_UNAVAILABLE_MARKER) ?? '')?.[0] ?? ''
+  }
+
+  override finalizeUnmarshal(): void {
+    this.applyFields()
+  }
+}
+
+/**
+ * Nothing to cancel in-app (`CancellationUnavailableReason`). HTTP 409. Marker
+ * `cancellation-unavailable:<reason>`.
+ */
+export class CancellationUnavailable extends ConsumerRightsRefusal {
+  public static override typeName: string = `${ConsumerRightsRefusal.typeName}CancellationUnavailable`
+  public static httpStatus = 409
+
+  public reason: string = ''
+
+  constructor(reason: string = 'error') {
+    super(`${CANCELLATION_UNAVAILABLE_MARKER}${reason}`)
+    this.type = CancellationUnavailable.typeName
+    this.applyFields()
+  }
+
+  private applyFields(): void {
+    this.reason = /^[\w-]*/.exec(packedAfter(this.message, CANCELLATION_UNAVAILABLE_MARKER) ?? '')?.[0] ?? ''
+  }
+
+  override finalizeUnmarshal(): void {
+    this.applyFields()
+  }
+}
+
+/**
+ * The amount is above what this entity may buy now (a narrowing of the plan's policy). HTTP 409.
+ * Marker `checkout-limit-exceeded:<encodeURIComponent(reason)>:<maximumMinor>:<currency>[:<ISO>]`.
+ * A payment refusal, not a consumer-rights one.
+ */
+export class CheckoutLimitExceeded extends PaymentError {
+  public static override typeName: string = `${PaymentError.typeName}CheckoutLimitExceeded`
+  public static httpStatus = 409
+
+  public reason: string = ''
+  public maximumMinor: number = 0
+  public currency: string = ''
+  public resetsAt?: Date
+
+  static encode(details: CheckoutLimitExceededDetails): string {
+    return `${encodeURIComponent(details.reason)}:${Math.max(0, Math.floor(details.maximumMinor))}`
+      + `:${details.currency.toLowerCase()}${isoOf(details.resetsAt)}`
+  }
+
+  constructor(details: CheckoutLimitExceededDetails)
+  constructor(message: string)
+  constructor(details: CheckoutLimitExceededDetails | string = 'error') {
+    super(`${CHECKOUT_LIMIT_MARKER}${typeof details === 'string' ? details : CheckoutLimitExceeded.encode(details)}`)
+    this.type = CheckoutLimitExceeded.typeName
+    this.applyFields()
+  }
+
+  private applyFields(): void {
+    const match = /^([^:]*):(\d+):([a-z]{3})(?::(.+))?$/.exec(packedAfter(this.message, CHECKOUT_LIMIT_MARKER) ?? '')
+    if (match == null) {
+      return
+    }
+    this.reason = decode(match[1])
+    this.maximumMinor = Number(match[2])
+    this.currency = match[3]
+    this.resetsAt = dateOf(match[4])
+  }
+
+  override finalizeUnmarshal(): void {
+    this.applyFields()
+  }
+}
+
 ResilientError.registerErrorClass(PaymentError)
 ResilientError.registerErrorClass(PaygateError)
 ResilientError.registerErrorClass(UnknownPaygate)
 ResilientError.registerErrorClass(PaygateMappingError)
+ResilientError.registerErrorClass(PaygateSignatureError)
 ResilientError.registerErrorClass(ProductError)
 ResilientError.registerErrorClass(UnknownProduct)
 ResilientError.registerErrorClass(UnknownPlan)
 ResilientError.registerErrorClass(PaymentIdentificationError)
 ResilientError.registerErrorClass(SubscriptionError)
 ResilientError.registerErrorClass(UnknownSubscription)
+ResilientError.registerErrorClass(LimitUnknown)
+ResilientError.registerErrorClass(LimitMisdeclared)
+ResilientError.registerErrorClass(PlanRequired)
+ResilientError.registerErrorClass(PlanRankConflict)
+ResilientError.registerErrorClass(WebhookSetupError)
+ResilientError.registerErrorClass(PortalUnavailable)
+ResilientError.registerErrorClass(EntitlementRefusal)
+ResilientError.registerErrorClass(CapabilityRequired)
+ResilientError.registerErrorClass(LimitExhausted)
+ResilientError.registerErrorClass(ConsumerRightsError)
+ResilientError.registerErrorClass(ConsumerRightsRefusal)
+ResilientError.registerErrorClass(PerformanceConsentRequired)
+ResilientError.registerErrorClass(SubscriptionStartRequired)
+ResilientError.registerErrorClass(BillingCountryLocked)
+ResilientError.registerErrorClass(WithdrawalUnavailable)
+ResilientError.registerErrorClass(CancellationUnavailable)
+ResilientError.registerErrorClass(CheckoutLimitExceeded)