@aios-inc/cashier 0.0.0-stage → 1.8.1

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Every merge to `main` with a `feat` or `fix` commit is released automatically, and the notes for each version are generated from its commit messages and published on [GitHub Releases](https://github.com/aios-inc/cashier/releases).
+
+The first release is summarized below.
+
+## [0.1.0]
+
+### Added
+
+- `Cashier` class and a shared `cashier` instance with `use('stripe' | 'recurly', { apiKey })`.
+- Stripe driver built on `stripe` v13 with the API version pinned to `2023-08-16`.
+- Recurly driver built on `recurly` v4.
+- Customers, invoices, products, prices and subscriptions resources with one set of types for both providers.
+- Amounts in minor units and uppercase ISO 4217 currency codes for every provider.
+- Typed errors that extend `CashierError`, mapped from Stripe and Recurly errors.
+- CommonJS and ES module builds with TypeScript declarations.
+
+[0.1.0]: https://github.com/aios-inc/cashier/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AIOS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
+# Cashier
 
-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](https://img.shields.io/npm/v/@aios-inc/cashier.svg)](https://www.npmjs.com/package/@aios-inc/cashier)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/aios-inc/cashier/blob/main/LICENSE)
+
+Unified subscription billing for Node.js and TypeScript. One API for every payment provider, with typed errors. Stripe and Recurly are supported today.
+
+```bash
+npm install @aios-inc/cashier stripe recurly
+```
+
+```ts
+import { CashierProvider, createCashier } from '@aios-inc/cashier';
+
+const cashier = createCashier({
+  default: CashierProvider.Stripe,
+  providers: {
+    stripe: { apiKey: process.env.STRIPE_SECRET_KEY! },
+    recurly: { apiKey: process.env.RECURLY_API_KEY! },
+  },
+});
+
+const billing = cashier.use();
+
+const customer = await billing.customers.create({ email: 'jane@example.com' });
+
+await billing.subscriptions.create({
+  customer: customer.id,
+  price: 'price_123',
+  currency: 'USD',
+});
+```
+
+To switch providers, change `default`. Your billing code stays the same. Use `cashier.use(CashierProvider.Recurly)` to run several providers side by side.
+
+## Why Cashier
+
+- **One interface.** Same methods and the same result shapes on every provider.
+- **Consistent data.** Amounts in cents, uppercase ISO 4217 currencies, `Date` timestamps.
+- **Typed errors.** `NotFoundError`, `PaymentFailedError`, `RateLimitError` and more, with the provider error kept as `cause`.
+- **Framework ready.** NestJS and Express packages included.
+- **No extra dependencies.** Only the provider SDKs you install.
+
+## Providers
+
+[Stripe](https://www.npmjs.com/package/stripe) v13 and [Recurly](https://www.npmjs.com/package/recurly) v4.67 or later. Node.js 20 or later.
+
+## Packages
+
+- [`@aios-inc/cashier`](https://www.npmjs.com/package/@aios-inc/cashier): the core library
+- [`@aios-inc/cashier-nestjs`](https://github.com/aios-inc/cashier/tree/main/packages/nestjs#readme): NestJS module
+- [`@aios-inc/cashier-express`](https://github.com/aios-inc/cashier/tree/main/packages/express#readme): Express middleware
+
+## Documentation
+
+- [API reference](https://github.com/aios-inc/cashier/blob/main/docs/README.md#api-reference): customers, invoices, payments, products, prices and subscriptions
+- [TypeScript](https://github.com/aios-inc/cashier/blob/main/docs/typescript.md), [NestJS](https://github.com/aios-inc/cashier/blob/main/docs/nestjs.md), [Express](https://github.com/aios-inc/cashier/blob/main/docs/express.md)
+- [Drivers and conventions](https://github.com/aios-inc/cashier/blob/main/docs/drivers.md)
+- [Errors](https://github.com/aios-inc/cashier/blob/main/docs/errors.md)
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/aios-inc/cashier/blob/main/CONTRIBUTING.md) and [SECURITY.md](https://github.com/aios-inc/cashier/blob/main/SECURITY.md).
+
+## License
+
+[MIT](https://github.com/aios-inc/cashier/blob/main/LICENSE) © AIOS

package/dist/index.d.mts

@@ -0,0 +1,482 @@
+interface Customer {
+    id: string;
+    code: string | null;
+    email: string | null;
+    name: string | null;
+    metadata: Record<string, string>;
+    createdAt: Date;
+    provider: CashierProvider;
+}
+interface ListCustomersParams {
+    email?: string;
+    limit?: number;
+}
+interface CreateCustomerParams {
+    email: string;
+    code?: string;
+    firstName?: string;
+    lastName?: string;
+    metadata?: Record<string, string>;
+}
+interface UpdateCustomerParams {
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    metadata?: Record<string, string>;
+}
+interface CustomersResource {
+    get(customerId: string): Promise<Customer>;
+    list(params?: ListCustomersParams): Promise<Customer[]>;
+    create(params: CreateCustomerParams): Promise<Customer>;
+    update(customerId: string, params: UpdateCustomerParams): Promise<Customer>;
+}
+
+interface CursorPaginateParams {
+    customer: string;
+    perPage?: number;
+    cursor?: string | null;
+}
+interface CursorPaginator<Item> {
+    data: Item[];
+    perPage: number;
+    hasMorePages: boolean;
+    nextCursor: string | null;
+}
+
+type ProviderRelation<Relations extends Record<CashierProvider, string>, Provider extends CashierProvider> = (Provider extends CashierProvider ? (relation: Relations[Provider]) => void : never) extends (relation: infer Relation) => void ? Relation : never;
+type LoadedRelations<Fields, Relation extends keyof Fields> = (Relation extends keyof Fields ? (fields: Fields[Relation]) => void : never) extends (fields: infer Loaded) => void ? Loaded : never;
+interface WithParams<Relation extends string> {
+    with?: readonly Relation[];
+}
+
+type InvoiceStatus = 'draft' | 'open' | 'paid' | 'past_due' | 'failed' | 'void' | 'uncollectible' | 'closed' | 'unknown';
+interface Invoice {
+    id: string;
+    number: string | null;
+    customerId: string | null;
+    subscriptionIds: string[];
+    billingReason: string | null;
+    status: InvoiceStatus;
+    currency: string;
+    subtotal: number;
+    tax: number;
+    total: number;
+    attemptCount: number;
+    hostedInvoiceUrl: string | null;
+    createdAt: Date;
+    dueDate: Date | null;
+    paidAt: Date | null;
+    provider: CashierProvider;
+}
+interface InvoiceRelationFields {
+    refunds: {
+        amountRefunded: number;
+    };
+}
+type InvoiceRelation = keyof InvoiceRelationFields;
+interface CashierInvoiceRelations {
+    stripe: 'refunds';
+    recurly: 'refunds';
+}
+type ProviderInvoiceRelation<Provider extends CashierProvider> = Extract<ProviderRelation<CashierInvoiceRelations, Provider>, InvoiceRelation>;
+type InvoiceWith<Relation extends InvoiceRelation = never> = Invoice & LoadedRelations<InvoiceRelationFields, Relation>;
+type GetInvoiceParams<Relation extends InvoiceRelation = never> = WithParams<Relation>;
+interface ListInvoicesParams<Relation extends InvoiceRelation = never> extends WithParams<Relation> {
+    customer: string;
+    status?: 'paid';
+    limit?: number;
+}
+interface CursorPaginateInvoicesParams<Relation extends InvoiceRelation = never> extends CursorPaginateParams, WithParams<Relation> {
+    status?: 'paid';
+}
+type InvoiceCollection = 'charge_automatically' | 'send_invoice';
+interface CreateInvoiceLineItem {
+    description: string;
+    amount: number;
+}
+interface CreateInvoiceParams {
+    customer: string;
+    currency: string;
+    lineItems: CreateInvoiceLineItem[];
+    collection: InvoiceCollection;
+    chargeNow?: boolean;
+    description?: string;
+    dueDate?: Date;
+    daysUntilDue?: number;
+    paymentMethod?: string;
+    paymentMethodTypes?: string[];
+    metadata?: Record<string, string>;
+    idempotencyKey?: string;
+}
+interface PayInvoiceParams {
+    paymentMethod?: string;
+}
+interface InvoicesResource<Provider extends CashierProvider = CashierProvider> {
+    get<Relation extends ProviderInvoiceRelation<Provider> = never>(invoiceId: string, params?: GetInvoiceParams<Relation>): Promise<InvoiceWith<Relation>>;
+    list<Relation extends ProviderInvoiceRelation<Provider> = never>(params: ListInvoicesParams<Relation>): Promise<InvoiceWith<Relation>[]>;
+    cursorPaginate<Relation extends ProviderInvoiceRelation<Provider> = never>(params: CursorPaginateInvoicesParams<Relation>): Promise<CursorPaginator<InvoiceWith<Relation>>>;
+    create(params: CreateInvoiceParams): Promise<Invoice>;
+    pay(invoiceId: string, params?: PayInvoiceParams): Promise<Invoice>;
+    void(invoiceId: string): Promise<Invoice>;
+}
+
+type BillingIntervalUnit = 'day' | 'week' | 'month' | 'year';
+interface BillingInterval {
+    unit: BillingIntervalUnit;
+    count: number;
+}
+interface Price {
+    id: string;
+    productId: string;
+    currency: string;
+    unitAmount: number | null;
+    type: 'one_time' | 'recurring';
+    interval: BillingInterval | null;
+    active: boolean;
+    createdAt: Date;
+    provider: CashierProvider;
+}
+interface ListPricesParams {
+    product?: string;
+    active?: boolean;
+    limit?: number;
+}
+interface PricesResource {
+    get(priceId: string): Promise<Price>;
+    list(params?: ListPricesParams): Promise<Price[]>;
+}
+
+type SubscriptionStatus = 'active' | 'trialing' | 'past_due' | 'unpaid' | 'paused' | 'canceled' | 'incomplete' | 'incomplete_expired' | 'future' | 'failed' | 'unknown';
+interface SubscriptionItem {
+    id: string | null;
+    priceId: string;
+    quantity: number;
+    unitAmount: number | null;
+}
+interface Subscription {
+    id: string;
+    customerId: string | null;
+    status: SubscriptionStatus;
+    items: SubscriptionItem[];
+    currency: string;
+    currentPeriodStart: Date | null;
+    currentPeriodEnd: Date | null;
+    cancelAtPeriodEnd: boolean;
+    cancelAt: Date | null;
+    canceledAt: Date | null;
+    trialEnd: Date | null;
+    createdAt: Date;
+    metadata: Record<string, string>;
+    provider: CashierProvider;
+}
+interface SubscriptionProduct {
+    id: string;
+    name: string;
+}
+interface SubscriptionPause {
+    behavior: string | null;
+    resumesAt: Date | null;
+}
+interface SubscriptionDiscount {
+    couponId: string;
+    name: string | null;
+    amountOff: number | null;
+    percentOff: number | null;
+}
+interface SubscriptionRelationFields {
+    product: {
+        product: SubscriptionProduct | null;
+    };
+    interval: {
+        interval: BillingInterval | null;
+    };
+    pause: {
+        pause: SubscriptionPause | null;
+    };
+    discount: {
+        discount: SubscriptionDiscount | null;
+    };
+}
+type SubscriptionRelation = keyof SubscriptionRelationFields;
+interface CashierSubscriptionRelations {
+    stripe: 'product' | 'interval' | 'pause' | 'discount';
+    recurly: 'product' | 'interval' | 'pause' | 'discount';
+}
+type ProviderSubscriptionRelation<Provider extends CashierProvider> = Extract<ProviderRelation<CashierSubscriptionRelations, Provider>, SubscriptionRelation>;
+type SubscriptionWith<Relation extends SubscriptionRelation = never> = Subscription & LoadedRelations<SubscriptionRelationFields, Relation>;
+type SubscriptionStatusFilter = SubscriptionStatus | 'all';
+interface ListSubscriptionsParams<Relation extends SubscriptionRelation = never> extends WithParams<Relation> {
+    customer: string;
+    status?: SubscriptionStatusFilter;
+    limit?: number;
+}
+type SubscriptionScope = {
+    customer: string;
+    price?: string;
+} | {
+    customer?: string;
+    price: string;
+};
+type CursorPaginateSubscriptionsParams<Relation extends SubscriptionRelation = never> = Omit<CursorPaginateParams, 'customer'> & WithParams<Relation> & SubscriptionScope & {
+    status?: SubscriptionStatusFilter;
+};
+interface CreateSubscriptionParams {
+    customer: string;
+    price: string;
+    currency: string;
+    quantity?: number;
+    paymentMethod?: string;
+    couponCode?: string;
+    trialEnd?: Date;
+    metadata?: Record<string, string>;
+}
+interface UpdateSubscriptionParams {
+    price?: string;
+    quantity?: number;
+    metadata?: Record<string, string>;
+}
+interface CancelSubscriptionParams {
+    atPeriodEnd?: boolean;
+    comment?: string;
+}
+interface SubscriptionsResource<Provider extends CashierProvider = CashierProvider> {
+    list<Relation extends ProviderSubscriptionRelation<Provider> = never>(params: ListSubscriptionsParams<Relation>): Promise<SubscriptionWith<Relation>[]>;
+    cursorPaginate<Relation extends ProviderSubscriptionRelation<Provider> = never>(params: CursorPaginateSubscriptionsParams<Relation>): Promise<CursorPaginator<SubscriptionWith<Relation>>>;
+    create(params: CreateSubscriptionParams): Promise<Subscription>;
+    get(subscriptionId: string): Promise<Subscription>;
+    update(subscriptionId: string, params: UpdateSubscriptionParams): Promise<Subscription>;
+    cancel(subscriptionId: string, params?: CancelSubscriptionParams): Promise<Subscription>;
+}
+
+type PaymentStatus = 'succeeded' | 'pending' | 'incomplete' | 'failed' | 'canceled' | 'unknown';
+type PaymentDisputeStatus = 'warning_needs_response' | 'warning_under_review' | 'warning_closed' | 'needs_response' | 'under_review' | 'won' | 'lost' | 'unknown';
+declare enum RefundReason {
+    Duplicate = "duplicate",
+    Fraudulent = "fraudulent",
+    RequestedByCustomer = "requested_by_customer"
+}
+type RefundStatus = 'succeeded' | 'pending' | 'failed' | 'canceled' | 'unknown';
+interface PaymentDispute {
+    id: string;
+    status: PaymentDisputeStatus;
+    reason: string;
+    createdAt: Date;
+    evidenceDueBy: Date | null;
+}
+interface PaymentSubscription {
+    id: string;
+    status: SubscriptionStatus | null;
+    cancelAt: Date | null;
+}
+interface Payment {
+    id: string;
+    customerId: string | null;
+    invoiceId: string | null;
+    status: PaymentStatus;
+    amount: number;
+    currency: string;
+    description: string | null;
+    createdAt: Date;
+    provider: CashierProvider;
+}
+interface Refund {
+    id: string;
+    paymentId: string;
+    status: RefundStatus;
+    amount: number;
+    currency: string;
+    reason: RefundReason | null;
+    createdAt: Date;
+    provider: CashierProvider;
+}
+interface PaymentRelationFields {
+    refunds: {
+        amountRefunded: number;
+    };
+    dispute: {
+        dispute: PaymentDispute | null;
+    };
+    receipt: {
+        receiptUrl: string | null;
+    };
+    reversal: {
+        reversed: boolean;
+    };
+    subscription: {
+        subscription: PaymentSubscription | null;
+    };
+}
+type PaymentRelation = keyof PaymentRelationFields;
+interface CashierPaymentRelations {
+    stripe: 'refunds' | 'dispute' | 'receipt' | 'reversal' | 'subscription';
+    recurly: 'refunds' | 'subscription';
+}
+type ProviderPaymentRelation<Provider extends CashierProvider> = Extract<ProviderRelation<CashierPaymentRelations, Provider>, PaymentRelation>;
+type PaymentWith<Relation extends PaymentRelation = never> = Payment & LoadedRelations<PaymentRelationFields, Relation>;
+interface ListPaymentsParams<Relation extends PaymentRelation = never> extends WithParams<Relation> {
+    customer: string;
+    limit?: number;
+}
+interface CursorPaginatePaymentsParams<Relation extends PaymentRelation = never> extends CursorPaginateParams, WithParams<Relation> {
+}
+interface CreatePaymentParams {
+    customer: string;
+    currency: string;
+    amount: number;
+    paymentMethod: string;
+    description?: string;
+    metadata?: Record<string, string>;
+    idempotencyKey?: string;
+}
+interface RefundPaymentParams {
+    amount?: number;
+    reason?: RefundReason;
+    metadata?: Record<string, string>;
+}
+interface PaymentsResource<Provider extends CashierProvider = CashierProvider> {
+    list<Relation extends ProviderPaymentRelation<Provider> = never>(params: ListPaymentsParams<Relation>): Promise<PaymentWith<Relation>[]>;
+    cursorPaginate<Relation extends ProviderPaymentRelation<Provider> = never>(params: CursorPaginatePaymentsParams<Relation>): Promise<CursorPaginator<PaymentWith<Relation>>>;
+    create(params: CreatePaymentParams): Promise<Payment>;
+    refund(paymentId: string, params?: RefundPaymentParams): Promise<Refund>;
+}
+
+interface Product {
+    id: string;
+    code: string | null;
+    name: string;
+    description: string | null;
+    active: boolean;
+    createdAt: Date;
+    provider: CashierProvider;
+}
+interface ListProductsParams {
+    active?: boolean;
+    limit?: number;
+}
+interface ProductsResource {
+    get(productId: string): Promise<Product>;
+    list(params?: ListProductsParams): Promise<Product[]>;
+}
+
+declare enum CashierProvider {
+    Stripe = "stripe",
+    Recurly = "recurly"
+}
+interface StripeOptions {
+    apiKey: string;
+}
+interface RecurlyOptions {
+    apiKey: string;
+}
+interface CashierProviderOptions {
+    stripe: StripeOptions;
+    recurly: RecurlyOptions;
+}
+type CashierProvidersConfig = {
+    [Provider in CashierProvider]?: CashierProviderOptions[Provider];
+};
+interface CashierConfig {
+    default?: CashierProvider;
+    providers?: CashierProvidersConfig;
+}
+interface CashierDriver<Provider extends CashierProvider = CashierProvider> {
+    readonly provider: Provider;
+    readonly customers: CustomersResource;
+    readonly invoices: InvoicesResource<Provider>;
+    readonly payments: PaymentsResource<Provider>;
+    readonly products: ProductsResource;
+    readonly prices: PricesResource;
+    readonly subscriptions: SubscriptionsResource<Provider>;
+}
+
+declare class Cashier {
+    readonly defaultProvider: CashierProvider | null;
+    private readonly providers;
+    private readonly drivers;
+    constructor(config?: CashierConfig);
+    use(): CashierDriver;
+    use<Provider extends CashierProvider>(provider: Provider): CashierDriver<Provider>;
+    use<Provider extends CashierProvider>(provider: Provider, options: CashierProviderOptions[Provider]): CashierDriver<Provider>;
+}
+declare const createCashier: (config?: CashierConfig) => Cashier;
+declare const cashier: Cashier;
+
+type CashierErrorCode = 'not_found' | 'authentication' | 'authorization' | 'validation' | 'payment_failed' | 'payment_method' | 'subscription' | 'rate_limit' | 'conflict' | 'unsupported_operation' | 'provider';
+
+interface CashierErrorDetails {
+    provider?: CashierProvider;
+    providerStatus?: number;
+    providerCode?: string;
+    cause?: unknown;
+}
+declare abstract class CashierError extends Error {
+    abstract readonly code: CashierErrorCode;
+    readonly provider?: CashierProvider;
+    readonly providerStatus?: number;
+    readonly providerCode?: string;
+    readonly cause?: unknown;
+    constructor(message: string, details?: CashierErrorDetails);
+}
+
+declare class NotFoundError extends CashierError {
+    readonly code: "not_found";
+}
+
+declare class AuthenticationError extends CashierError {
+    readonly code: "authentication";
+}
+
+declare class AuthorizationError extends CashierError {
+    readonly code: "authorization";
+}
+
+declare class ValidationError extends CashierError {
+    readonly code: "validation";
+}
+
+interface PaymentFailedErrorDetails extends CashierErrorDetails {
+    declineCode?: string;
+}
+declare class PaymentFailedError extends CashierError {
+    readonly code: "payment_failed";
+    readonly declineCode?: string;
+    constructor(message: string, details?: PaymentFailedErrorDetails);
+}
+
+declare class PaymentMethodError extends CashierError {
+    readonly code: "payment_method";
+}
+
+declare class SubscriptionError extends CashierError {
+    readonly code: "subscription";
+}
+
+declare class RateLimitError extends CashierError {
+    readonly code: "rate_limit";
+}
+
+declare class ConflictError extends CashierError {
+    readonly code: "conflict";
+}
+
+declare class UnsupportedOperationError extends CashierError {
+    readonly code: "unsupported_operation";
+}
+
+declare class ProviderError extends CashierError {
+    readonly code: "provider";
+}
+
+interface CashierHttpErrorBody {
+    code: CashierErrorCode;
+    message: string;
+    declineCode?: string;
+}
+interface CashierHttpError {
+    status: number;
+    body: CashierHttpErrorBody;
+}
+declare const getHttpStatus: (error: CashierError) => number;
+declare const toHttpError: (error: CashierError) => CashierHttpError;
+
+export { AuthenticationError, AuthorizationError, type BillingInterval, type BillingIntervalUnit, type CancelSubscriptionParams, Cashier, type CashierConfig, type CashierDriver, CashierError, type CashierErrorCode, type CashierErrorDetails, type CashierHttpError, type CashierHttpErrorBody, type CashierInvoiceRelations, type CashierPaymentRelations, CashierProvider, type CashierProviderOptions, type CashierProvidersConfig, type CashierSubscriptionRelations, ConflictError, type CreateCustomerParams, type CreateInvoiceLineItem, type CreateInvoiceParams, type CreatePaymentParams, type CreateSubscriptionParams, type CursorPaginateInvoicesParams, type CursorPaginateParams, type CursorPaginatePaymentsParams, type CursorPaginateSubscriptionsParams, type CursorPaginator, type Customer, type CustomersResource, type GetInvoiceParams, type Invoice, type InvoiceCollection, type InvoiceRelation, type InvoiceRelationFields, type InvoiceStatus, type InvoiceWith, type InvoicesResource, type ListCustomersParams, type ListInvoicesParams, type ListPaymentsParams, type ListPricesParams, type ListProductsParams, type ListSubscriptionsParams, type LoadedRelations, NotFoundError, type PayInvoiceParams, type Payment, type PaymentDispute, type PaymentDisputeStatus, PaymentFailedError, type PaymentFailedErrorDetails, PaymentMethodError, type PaymentRelation, type PaymentRelationFields, type PaymentStatus, type PaymentSubscription, type PaymentWith, type PaymentsResource, type Price, type PricesResource, type Product, type ProductsResource, ProviderError, type ProviderInvoiceRelation, type ProviderPaymentRelation, type ProviderRelation, type ProviderSubscriptionRelation, RateLimitError, type RecurlyOptions, type Refund, type RefundPaymentParams, RefundReason, type RefundStatus, type StripeOptions, type Subscription, type SubscriptionDiscount, SubscriptionError, type SubscriptionItem, type SubscriptionPause, type SubscriptionProduct, type SubscriptionRelation, type SubscriptionRelationFields, type SubscriptionScope, type SubscriptionStatus, type SubscriptionStatusFilter, type SubscriptionWith, type SubscriptionsResource, UnsupportedOperationError, type UpdateCustomerParams, type UpdateSubscriptionParams, ValidationError, type WithParams, cashier, createCashier, getHttpStatus, toHttpError };