@antelopejs/interface-subscriptions 0.0.0-stage → 0.0.2

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright (c) 2025-present - AntelopeJS Team
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,216 @@
-# Temporary Holding Version
+# @antelopejs/interface-subscriptions
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/@antelopejs/interface-subscriptions.svg)](https://www.npmjs.com/package/@antelopejs/interface-subscriptions)
+[![license](https://img.shields.io/npm/l/@antelopejs/interface-subscriptions.svg)](./LICENSE)
+
+Provider-agnostic subscriptions for AntelopeJS. Bill a saved payment method
+every period — with trials, a billing anchor, cancellation now or at period end,
+and `past_due` reporting — without naming a provider, and without every
+consumer rebuilding a billing cycle of its own.
+
+## Installation
+
+```bash
+pnpm add @antelopejs/interface-subscriptions
+```
+
+This package declares the contract and ships no billing logic. Wire a module
+that implements it:
+
+- a provider that fires renewals itself implements it natively (Stripe, PayPal,
+  Mollie);
+- for any other `@antelopejs/interface-payment` provider, wire
+  `@antelopejs/payment-subscriptions`, which runs the renewal clock itself on
+  saved methods and off-session charges.
+
+A payment module that cannot do subscriptions simply does not implement this
+interface. There is no half-honoured contract and no `UnsupportedOperationError`
+here.
+
+For Stripe, native subscriptions in `@antelopejs/stripe` are recommended.
+`@antelopejs/payment-subscriptions` is an explicit alternative, not an automatic
+fallback. Wire one renewal owner per subscription, never both.
+
+## Choose a task
+
+- Start or cancel recurring access: [subscriptions](./docs/2.subscriptions.md).
+- Synchronize access after billing: [events](./docs/3.events.md).
+- Implement a billing provider: [implementation guide](./docs/4.implementing.md).
+- Choose native or generic billing: [provider capabilities](./docs/5.provider-capability-matrix.md).
+
+Replay protection lasts only for the provider-defined replay window. Persist
+operation keys, subscription IDs and payment IDs. After expiration, applications
+must reconcile uncertain payments with provider records before retrying; reusing
+a key is not indefinite duplicate-charge protection.
+
+## What it covers
+
+| Area      | Functions                                                       |
+| --------- | --------------------------------------------------------------- |
+| Lifecycle | `CreateSubscription`, `CancelSubscription`                      |
+| Reading   | `GetSubscription`, `ListSubscriptions`                          |
+| Recovery  | `UpdateSubscriptionPaymentMethod`                               |
+| Events    | `SubscriptionEvents` (a registering proxy, not a webhook route) |
+
+The portable core is small on purpose: amount, interval and interval count,
+billing anchor, trial end, status including `past_due`, cancel now or at period
+end, and the current period. Proration, dunning schedules, tax, coupons, metered
+billing and multiple items per subscription are out, because the generic
+fallback cannot honour them and a contract that only some implementations keep
+is a lie. For those, use the provider's own interface.
+
+## Quick start
+
+```ts docs-check
+import {
+  CreatePayment,
+  GetPayment,
+  ListPaymentMethods,
+} from "@antelopejs/interface-payment";
+import { CreateSubscription } from "@antelopejs/interface-subscriptions";
+
+// 1. Take the mandate with a separate €1 on-session payment.
+export async function startSignup(
+  customer: string,
+  token: string,
+  signupId: string,
+) {
+  const payment = await CreatePayment(
+    {
+      amount: { value: 100, currency: "EUR" },
+      reference: signupId,
+      customer,
+      paymentMethod: token,
+      savePaymentMethod: true,
+      returnUrl: "https://shop.example/billing/return",
+    },
+    `save-${signupId}`,
+  );
+
+  // The route must redirect the payer when this URL is returned.
+  return {
+    paymentId: payment.id,
+    status: payment.status,
+    redirectUrl:
+      payment.status === "requires_action" ? payment.redirectUrl : undefined,
+  };
+}
+
+// 2. Resume from trusted server state, not the browser's claimed outcome.
+export async function finishSignup(paymentId: string, accountId: string) {
+  const payment = await GetPayment(paymentId);
+  if (payment.status !== "succeeded" && payment.status !== "authorized") {
+    return undefined; // Still pending/action required, or failed/canceled: do not subscribe.
+  }
+  if (!payment.customer) throw new Error("Signup payment has no customer");
+
+  const methods = await ListPaymentMethods(payment.customer);
+  const method = methods.find((saved) => saved.id === payment.paymentMethod);
+  if (!method) throw new Error("Signup payment has no saved method");
+
+  return CreateSubscription(
+    {
+      reference: accountId,
+      customer: payment.customer,
+      paymentMethod: method.id,
+      amount: { value: 1900, currency: "EUR" },
+      interval: "month",
+    },
+    `subscribe-${payment.id}`,
+  );
+}
+```
+
+Use an existing payment-interface customer and a provider-issued method token.
+Persist a unique `signupId` and the returned `paymentId` against the authenticated
+account. Replace the return URL with your own route and send the payer to
+`redirectUrl` when action is required. If the payment is pending, wait for a
+verified `payment.succeeded` or `payment.authorized` webhook before retrying
+`finishSignup`; failed or canceled payments must not create subscriptions.
+
+Call `finishSignup` with the saved payment ID and account ID, using the same
+provider account throughout. The saved-method payment and the first subscription
+period are separate charges (€1 then €19 here); the first period is charged
+off-session before `CreateSubscription` resolves. Adapt those amounts to your
+billing policy. Register an idempotent handler for subsequent lifecycle events:
+
+```ts
+import { SubscriptionEvents } from "@antelopejs/interface-subscriptions";
+
+SubscriptionEvents.register("billing", async (event) => {
+  await grantOrRevokeAccess(event.subscription);
+});
+```
+
+`grantOrRevokeAccess` stands for your application's access policy. Deduplicate
+events by `event.id` as described in [Events](./docs/3.events.md).
+
+## Compatibility
+
+<!-- docs-compat: ./package.json#peerDependencies -->
+
+| Package                         | Range            |
+| ------------------------------- | ---------------- |
+| `@antelopejs/interface-core`    | `>=0.0.5 <1.0.0` |
+| `@antelopejs/interface-payment` | `>=0.0.2 <1.0.0` |
+
+These are the peer requirements in `package.json`. Development uses the same
+payment-interface semver range. Check your implementing module's requirements
+too. `@antelopejs/core` 1.16.0 is a development test runner, not a runtime peer.
+
+## Conventions
+
+- **Built on the payment interface's portable pair**: one on-session payment that
+  saves a method, then off-session charges. Customers, methods and payments are
+  `@antelopejs/interface-payment` identifiers from the same account.
+- **An idempotency key on every mutating call**, positionally.
+- **A declined renewal is a status, not an exception.** Only a declined _first_
+  period rejects, with `SubscriptionPaymentError`, and creates nothing.
+- **`past_due` is portable to report; the retry policy is not.**
+- **`vendorData` is a read-only echo.** No request accepts it.
+- **An optional trailing `provider`** selects the payment account, as in the
+  payment interface.
+
+## Documentation
+
+| Document                                                             | Contents                                                        |
+| -------------------------------------------------------------------- | --------------------------------------------------------------- |
+| [Introduction](./docs/1.introduction.md)                             | Why a second interface, the portable core, who fires renewals   |
+| [Subscriptions](./docs/2.subscriptions.md)                           | Creating, periods, trials and anchors, statuses, cancelling     |
+| [Events](./docs/3.events.md)                                         | The event set, delivery, and how it relates to payment webhooks |
+| [Implementing](./docs/4.implementing.md)                             | Native and fallback implementations, the conformance suite      |
+| [Provider capability matrix](./docs/5.provider-capability-matrix.md) | Which providers fire renewals themselves, and what that means   |
+
+## Development
+
+Install the published payment interface from npm using the frozen lockfile:
+
+```bash
+pnpm install --frozen-lockfile
+pnpm test
+pnpm lint
+pnpm format:check
+pnpm knip
+```
+
+CI runs the same checks against the published dependency without Git submodules or workspace overrides.
+
+## Conformance suite
+
+`src/tests/` ships in the package as `dist/tests` and runs against whichever
+module implements the interface. It is much weaker than the payment suite, and
+on purpose: a test cannot wait a month for a renewal, so for a native provider it
+covers creation, reading, cancellation, method changes and request validation —
+not renewals. The generic fallback's own suite drives an injected clock through
+every renewal path and is the executable specification for the rest.
+
+| Variable                                            | Purpose                                                                                                       |
+| --------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| `ANTELOPE_PAYMENT_TEST_METHOD`                      | A token that saves on-session and charges off-session. Without it, everything but the unknown-id tests skips. |
+| `ANTELOPE_SUBSCRIPTIONS_TEST_METHOD_DECLINES_LATER` | A token that saves on-session and is declined off-session. Without it, the declined-first-period tests skip.  |
+| `ANTELOPE_SUBSCRIPTIONS_TEST_EVENTS`                | Set when events can reach the test process. A native provider delivers them by webhook, which usually cannot. |
+| `ANTELOPE_PAYMENT_TEST_CURRENCY`                    | ISO-4217 code to run against. Defaults to `EUR`.                                                              |
+
+## License
+
+Apache-2.0

package/dist/antelope.test.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@antelopejs/interface-core/config").ConfigInput;
+export default _default;

package/dist/antelope.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("@antelopejs/interface-core/config");
+exports.default = (0, config_1.defineConfig)({
+    name: "interface-subscriptions-test",
+    cacheFolder: ".antelope/cache",
+    modules: {},
+    test: { folder: "test" },
+});
+//# sourceMappingURL=antelope.test.js.map

package/dist/antelope.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"antelope.test.js","sourceRoot":"","sources":["../src/antelope.test.ts"],"names":[],"mappings":";;AAAA,8DAAiE;AAEjE,kBAAe,IAAA,qBAAY,EAAC;IAC1B,IAAI,EAAE,8BAA8B;IACpC,WAAW,EAAE,iBAAiB;IAC9B,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE;CACzB,CAAC,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,68 @@
+import type { Payment } from "@antelopejs/interface-payment";
+import type { SubscriptionStatus } from "./types";
+/**
+ * Base class for every error this interface raises.
+ *
+ * A failed *renewal* is not an error: it is reported as a `past_due` status
+ * and a `subscription.payment_failed` event. These errors mean the call itself
+ * did not happen.
+ */
+export declare class SubscriptionError extends Error {
+    /** The provider's own error code, verbatim and opaque. */
+    readonly providerCode?: string | undefined;
+    constructor(message: string, 
+    /** The provider's own error code, verbatim and opaque. */
+    providerCode?: string | undefined);
+}
+/**
+ * No subscription exists under that identifier, for that provider.
+ *
+ * Also raised for an identifier that cannot be parsed at all.
+ */
+export declare class SubscriptionNotFoundError extends SubscriptionError {
+    constructor(id: string, providerCode?: string);
+}
+/**
+ * The request is malformed, or asks for something outside the portable core:
+ * a non-positive amount, an interval count below 1, a trial end in the past,
+ * both a trial and a billing anchor, a period longer than the provider allows.
+ */
+export declare class InvalidSubscriptionRequestError extends SubscriptionError {
+    constructor(message: string, providerCode?: string);
+}
+/**
+ * The request was well-formed but does not apply to the subscription's current
+ * state: cancelling one that has already ended, changing the payment method of
+ * one that has ended.
+ */
+export declare class InvalidSubscriptionStateError extends SubscriptionError {
+    /** The status the subscription was actually in. */
+    readonly status?: SubscriptionStatus | undefined;
+    constructor(message: string, 
+    /** The status the subscription was actually in. */
+    status?: SubscriptionStatus | undefined, providerCode?: string);
+}
+/**
+ * The first period could not be charged, so no subscription was created.
+ *
+ * Only {@link CreateSubscription} raises this, and only when it charges at
+ * once — no trial, no future billing anchor. Later charges that fail are a
+ * `past_due` status, not an error.
+ */
+export declare class SubscriptionPaymentError extends SubscriptionError {
+    /**
+     * The declined payment, as the payment interface reports it: `failed`, or
+     * `canceled` where the provider voids the declined attempt when it refuses
+     * the subscription (Stripe does). `GetPayment` on its id agrees. The
+     * decline reason is in `failure` when `failed`, and in `providerCode`.
+     */
+    readonly payment: Payment;
+    constructor(
+    /**
+     * The declined payment, as the payment interface reports it: `failed`, or
+     * `canceled` where the provider voids the declined attempt when it refuses
+     * the subscription (Stripe does). `GetPayment` on its id agrees. The
+     * decline reason is in `failure` when `failed`, and in `providerCode`.
+     */
+    payment: Payment, providerCode?: string);
+}

package/dist/errors.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionPaymentError = exports.InvalidSubscriptionStateError = exports.InvalidSubscriptionRequestError = exports.SubscriptionNotFoundError = exports.SubscriptionError = void 0;
+/**
+ * Base class for every error this interface raises.
+ *
+ * A failed *renewal* is not an error: it is reported as a `past_due` status
+ * and a `subscription.payment_failed` event. These errors mean the call itself
+ * did not happen.
+ */
+class SubscriptionError extends Error {
+    providerCode;
+    constructor(message, 
+    /** The provider's own error code, verbatim and opaque. */
+    providerCode) {
+        super(message);
+        this.providerCode = providerCode;
+        this.name = "SubscriptionError";
+    }
+}
+exports.SubscriptionError = SubscriptionError;
+/**
+ * No subscription exists under that identifier, for that provider.
+ *
+ * Also raised for an identifier that cannot be parsed at all.
+ */
+class SubscriptionNotFoundError extends SubscriptionError {
+    constructor(id, providerCode) {
+        super(`No such subscription: ${id}`, providerCode);
+        this.name = "SubscriptionNotFoundError";
+    }
+}
+exports.SubscriptionNotFoundError = SubscriptionNotFoundError;
+/**
+ * The request is malformed, or asks for something outside the portable core:
+ * a non-positive amount, an interval count below 1, a trial end in the past,
+ * both a trial and a billing anchor, a period longer than the provider allows.
+ */
+class InvalidSubscriptionRequestError extends SubscriptionError {
+    constructor(message, providerCode) {
+        super(message, providerCode);
+        this.name = "InvalidSubscriptionRequestError";
+    }
+}
+exports.InvalidSubscriptionRequestError = InvalidSubscriptionRequestError;
+/**
+ * The request was well-formed but does not apply to the subscription's current
+ * state: cancelling one that has already ended, changing the payment method of
+ * one that has ended.
+ */
+class InvalidSubscriptionStateError extends SubscriptionError {
+    status;
+    constructor(message, 
+    /** The status the subscription was actually in. */
+    status, providerCode) {
+        super(message, providerCode);
+        this.status = status;
+        this.name = "InvalidSubscriptionStateError";
+    }
+}
+exports.InvalidSubscriptionStateError = InvalidSubscriptionStateError;
+/**
+ * The first period could not be charged, so no subscription was created.
+ *
+ * Only {@link CreateSubscription} raises this, and only when it charges at
+ * once — no trial, no future billing anchor. Later charges that fail are a
+ * `past_due` status, not an error.
+ */
+class SubscriptionPaymentError extends SubscriptionError {
+    payment;
+    constructor(
+    /**
+     * The declined payment, as the payment interface reports it: `failed`, or
+     * `canceled` where the provider voids the declined attempt when it refuses
+     * the subscription (Stripe does). `GetPayment` on its id agrees. The
+     * decline reason is in `failure` when `failed`, and in `providerCode`.
+     */
+    payment, providerCode) {
+        super(`The first period could not be charged: payment ${payment.id} is ${payment.status}`, providerCode);
+        this.payment = payment;
+        this.name = "SubscriptionPaymentError";
+    }
+}
+exports.SubscriptionPaymentError = SubscriptionPaymentError;
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAIA;;;;;;GAMG;AACH,MAAa,iBAAkB,SAAQ,KAAK;IAIxB;IAHlB,YACE,OAAe;IACf,0DAA0D;IAC1C,YAAqB;QAErC,KAAK,CAAC,OAAO,CAAC,CAAC;QAFC,iBAAY,GAAZ,YAAY,CAAS;QAGrC,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AATD,8CASC;AAED;;;;GAIG;AACH,MAAa,yBAA0B,SAAQ,iBAAiB;IAC9D,YAAY,EAAU,EAAE,YAAqB;QAC3C,KAAK,CAAC,yBAAyB,EAAE,EAAE,EAAE,YAAY,CAAC,CAAC;QACnD,IAAI,CAAC,IAAI,GAAG,2BAA2B,CAAC;IAC1C,CAAC;CACF;AALD,8DAKC;AAED;;;;GAIG;AACH,MAAa,+BAAgC,SAAQ,iBAAiB;IACpE,YAAY,OAAe,EAAE,YAAqB;QAChD,KAAK,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QAC7B,IAAI,CAAC,IAAI,GAAG,iCAAiC,CAAC;IAChD,CAAC;CACF;AALD,0EAKC;AAED;;;;GAIG;AACH,MAAa,6BAA8B,SAAQ,iBAAiB;IAIhD;IAHlB,YACE,OAAe;IACf,mDAAmD;IACnC,MAA2B,EAC3C,YAAqB;QAErB,KAAK,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QAHb,WAAM,GAAN,MAAM,CAAqB;QAI3C,IAAI,CAAC,IAAI,GAAG,+BAA+B,CAAC;IAC9C,CAAC;CACF;AAVD,sEAUC;AAED;;;;;;GAMG;AACH,MAAa,wBAAyB,SAAQ,iBAAiB;IAQ3C;IAPlB;IACE;;;;;OAKG;IACa,OAAgB,EAChC,YAAqB;QAErB,KAAK,CACH,kDAAkD,OAAO,CAAC,EAAE,OAAO,OAAO,CAAC,MAAM,EAAE,EACnF,YAAY,CACb,CAAC;QANc,YAAO,GAAP,OAAO,CAAS;QAOhC,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF;AAjBD,4DAiBC"}