velirapay 0.1.0 → 0.2.0

package/dist/cjs/services/overview.js

@@ -5,9 +5,10 @@ const overview_ts_1 = require("../resources/overview.js");
 const service_ts_1 = require("./service.js");
 /** The /v1/overview endpoint. Needs overview:read. */
 class OverviewService extends service_ts_1.Service {
-    /** Retrieve the dashboard's figures for the last 30 days, in the API key's mode. */
+    /** Retrieve the dashboard's figures for the last 30 days, in the API key's mode, and what needs attention now. */
     async retrieve() {
-        return new overview_ts_1.Overview(await this.request('GET', '/v1/overview'));
+        const response = await this.respond('GET', '/v1/overview');
+        return new overview_ts_1.Overview((0, service_ts_1.data)(response), (0, service_ts_1.meta)(response));
     }
 }
 exports.OverviewService = OverviewService;

package/dist/cjs/services/payment-links.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaymentLinkService = void 0;
 const payment_link_ts_1 = require("../resources/payment-link.js");
 const service_ts_1 = require("./service.js");
+/** The amounts a payment link takes, which go out as decimal strings. */
+const AMOUNTS = ['amount', 'suggested_amounts', 'min_amount', 'max_amount'];
 /** The /v1/payment-links endpoints. */
 class PaymentLinkService extends service_ts_1.Service {
     /** Create a payment link: one reusable public page, never one per customer. */
     async create(params, options) {
-        return new payment_link_ts_1.PaymentLink(await this.request('POST', '/v1/payment-links', params, options));
+        return new payment_link_ts_1.PaymentLink(await this.request('POST', '/v1/payment-links', (0, service_ts_1.withDecimalAmounts)(params, ...AMOUNTS), options));
     }
     /** Retrieve a payment link by its id. */
     async retrieve(id) {
@@ -15,7 +17,7 @@ class PaymentLinkService extends service_ts_1.Service {
     }
     /** Change any of a payment link's fields. */
     async update(id, params, options) {
-        return new payment_link_ts_1.PaymentLink(await this.request('PATCH', (0, service_ts_1.path)('/v1/payment-links/%s', id), params, options));
+        return new payment_link_ts_1.PaymentLink(await this.request('PATCH', (0, service_ts_1.path)('/v1/payment-links/%s', id), (0, service_ts_1.withDecimalAmounts)(params, ...AMOUNTS), options));
     }
     /** List payment links, newest first. */
     async list(params = {}) {

package/dist/cjs/services/payout-addresses.d.ts

@@ -1,12 +1,17 @@
+import type { AddressNetwork, OrString } from '../enums.ts';
 import type { PayoutAddressUpdateParams, RequestOptions } from '../params.ts';
 import { PayoutAddress } from '../resources/payout.ts';
 import { Service } from './service.ts';
-/** The /v1/payout-addresses endpoints. Reading needs payout_addresses:read; changing needs payout_addresses:write and an owner's switch under Payment settings. */
+/**
+ * The /v1/payout-addresses endpoints, one address per network family: bitcoin, litecoin, dogecoin, bitcoincash, evm (Ethereum),
+ * bsc (BNB Chain), base, arbitrum, polygon, tron, monero, solana or lightning, as the AddressNetwork values name them.
+ * Reading needs payout_addresses:read; changing needs payout_addresses:write and an owner's switch under Payment settings.
+ */
 export declare class PayoutAddressService extends Service {
     /** List where payouts go in the API key's mode: one entry per network with coins on offer, its address null while there is none. */
     list(): Promise<PayoutAddress[]>;
-    /** Point the payouts of one network, such as "bitcoin" or "evm", at an address. */
-    update(network: string, params: PayoutAddressUpdateParams, options?: RequestOptions): Promise<PayoutAddress>;
+    /** Point the payouts of one network, such as AddressNetwork.Bitcoin or "evm", at an address. */
+    update(network: OrString<AddressNetwork>, params: PayoutAddressUpdateParams, options?: RequestOptions): Promise<PayoutAddress>;
     /** Remove the address of one network, so its payouts wait for a new one. */
-    delete(network: string, options?: RequestOptions): Promise<PayoutAddress>;
+    delete(network: OrString<AddressNetwork>, options?: RequestOptions): Promise<PayoutAddress>;
 }

package/dist/cjs/services/payout-addresses.js

@@ -3,13 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PayoutAddressService = void 0;
 const payout_ts_1 = require("../resources/payout.js");
 const service_ts_1 = require("./service.js");
-/** The /v1/payout-addresses endpoints. Reading needs payout_addresses:read; changing needs payout_addresses:write and an owner's switch under Payment settings. */
+/**
+ * The /v1/payout-addresses endpoints, one address per network family: bitcoin, litecoin, dogecoin, bitcoincash, evm (Ethereum),
+ * bsc (BNB Chain), base, arbitrum, polygon, tron, monero, solana or lightning, as the AddressNetwork values name them.
+ * Reading needs payout_addresses:read; changing needs payout_addresses:write and an owner's switch under Payment settings.
+ */
 class PayoutAddressService extends service_ts_1.Service {
     /** List where payouts go in the API key's mode: one entry per network with coins on offer, its address null while there is none. */
     async list() {
         return (0, service_ts_1.list)(await this.respond('GET', '/v1/payout-addresses')).map((address) => new payout_ts_1.PayoutAddress(address));
     }
-    /** Point the payouts of one network, such as "bitcoin" or "evm", at an address. */
+    /** Point the payouts of one network, such as AddressNetwork.Bitcoin or "evm", at an address. */
     async update(network, params, options) {
         return new payout_ts_1.PayoutAddress(await this.request('PUT', (0, service_ts_1.path)('/v1/payout-addresses/%s', network), params, options));
     }

package/dist/cjs/services/service.d.ts

@@ -1,8 +1,10 @@
 import type { ApiResponse } from '../http/api-response.ts';
 import type { HttpTransport } from '../http/transport.ts';
-import { Page } from '../page.ts';
+import { Page, type PagePosition } from '../page.ts';
 import type { RequestOptions } from '../params.ts';
 import { type ApiResource, type Attributes } from '../resources/api-resource.ts';
+/** A class of page, such as Page itself or one that reads more of the list's meta. */
+type PageKind<T extends ApiResource, P extends Page<T>> = new (data: T[], position: PagePosition, fetch: (page: number) => Promise<P>, meta: Attributes) => P;
 /** The requests shared by every group of endpoints. */
 export declare abstract class Service {
     protected readonly transport: HttpTransport;
@@ -11,8 +13,8 @@ export declare abstract class Service {
     protected request(method: string, path: string, body?: object, options?: RequestOptions): Promise<Attributes>;
     /** Send a request and return the whole response, for answers whose meta matters too. */
     protected respond(method: string, path: string, body?: object, options?: RequestOptions): Promise<ApiResponse>;
-    /** Fetch one page of a list. */
-    protected page<T extends ApiResource>(path: string, params: object, hydrate: (attributes: Attributes) => T): Promise<Page<T>>;
+    /** Fetch one page of a list, as a Page unless another kind is given. */
+    protected page<T extends ApiResource, P extends Page<T> = Page<T>>(path: string, params: object, hydrate: (attributes: Attributes) => T, kind?: PageKind<T, P>): Promise<P>;
 }
 /** Read the object under a response's "data" key. */
 export declare function data(response: ApiResponse): Attributes;
@@ -20,5 +22,8 @@ export declare function data(response: ApiResponse): Attributes;
 export declare function meta(response: ApiResponse): Attributes;
 /** Read the objects of the list under a response's "data" key. */
 export declare function list(response: ApiResponse): Attributes[];
+/** A copy of the params with the amounts under the given keys, alone or in a list, written as the API reads them. */
+export declare function withDecimalAmounts<T extends object>(params: T, ...keys: string[]): T;
 /** Build a path with the given ids escaped into its %s placeholders. */
 export declare function path(format: string, ...ids: string[]): string;
+export {};

package/dist/cjs/services/service.js

@@ -4,6 +4,7 @@ exports.Service = void 0;
 exports.data = data;
 exports.meta = meta;
 exports.list = list;
+exports.withDecimalAmounts = withDecimalAmounts;
 exports.path = path;
 const errors_ts_1 = require("../errors.js");
 const page_ts_1 = require("../page.js");
@@ -22,19 +23,18 @@ class Service {
     respond(method, path, body, options) {
         return this.transport.request(method, path, {}, body, options?.idempotencyKey);
     }
-    /** Fetch one page of a list. */
-    async page(path, params, hydrate) {
+    /** Fetch one page of a list, as a Page unless another kind is given. */
+    async page(path, params, hydrate, kind = page_ts_1.Page) {
         const response = await this.transport.request('GET', path, params);
         const data = list(response).map(hydrate);
-        const json = response.json();
-        const meta = (0, api_resource_ts_1.isRecord)(json['meta']) ? json['meta'] : {};
-        const currentPage = integer(meta['current_page'], 1);
-        return new page_ts_1.Page(data, {
+        const metadata = meta(response);
+        const currentPage = integer(metadata['current_page'], 1);
+        return new kind(data, {
             currentPage,
-            lastPage: integer(meta['last_page'], currentPage),
-            perPage: integer(meta['per_page'], data.length),
-            total: integer(meta['total'], data.length),
-        }, (page) => this.page(path, { ...params, page }, hydrate));
+            lastPage: integer(metadata['last_page'], currentPage),
+            perPage: integer(metadata['per_page'], data.length),
+            total: integer(metadata['total'], data.length),
+        }, (page) => this.page(path, { ...params, page }, hydrate, kind), metadata);
     }
 }
 exports.Service = Service;
@@ -59,6 +59,41 @@ function list(response) {
     }
     return value.filter(api_resource_ts_1.isRecord);
 }
+/** A copy of the params with the amounts under the given keys, alone or in a list, written as the API reads them. */
+function withDecimalAmounts(params, ...keys) {
+    const copy = { ...params };
+    for (const key of keys) {
+        if (Object.hasOwn(copy, key)) {
+            const value = copy[key];
+            copy[key] = Array.isArray(value) ? value.map((item) => decimalAmount(item, key)) : decimalAmount(value, key);
+        }
+    }
+    return copy;
+}
+/** An amount as the API reads it: a string as it is, and a number rounded to 14 significant digits, as the API read JSON numbers, and written without an exponent, which the API refuses. */
+function decimalAmount(value, key) {
+    if (typeof value !== 'number') {
+        return value;
+    }
+    if (!Number.isFinite(value)) {
+        throw new errors_ts_1.InvalidArgumentError(`The ${key} must be a finite number, or a string such as "49.90", not ${value}.`);
+    }
+    if (!Number.isInteger(value) && Math.abs(value) >= 1e14) {
+        throw new errors_ts_1.InvalidArgumentError(`The ${key} ${value} has too many digits to be sent as a number: pass it as a string.`);
+    }
+    // Rounding drops the binary noise of a float, so 0.1 + 0.2 goes out as 0.3.
+    const rounded = Number.isInteger(value) ? value : Number(value.toPrecision(14));
+    const [, sign = '', whole = '', fraction = '', exponent] = /^(-?)(\d+)(?:\.(\d+))?e([+-]\d+)$/.exec(String(rounded)) ?? [];
+    if (exponent === undefined) {
+        return String(rounded);
+    }
+    const digits = whole + fraction;
+    const point = whole.length + Number(exponent);
+    if (point <= 0) {
+        return `${sign}0.${'0'.repeat(-point)}${digits}`;
+    }
+    return point >= digits.length ? `${sign}${digits}${'0'.repeat(point - digits.length)}` : `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
 /** Build a path with the given ids escaped into its %s placeholders. */
 function path(format, ...ids) {
     let index = 0;

package/dist/cjs/services/webhook-endpoints.d.ts

@@ -10,7 +10,13 @@ export declare class WebhookEndpointService extends Service {
     iterator(params?: Omit<PageParams, 'page'>): AsyncGenerator<WebhookEndpoint, void, undefined>;
     /** Retrieve one webhook endpoint. */
     retrieve(id: string): Promise<WebhookEndpoint>;
-    /** Add an endpoint and send it its verification challenge. The answer carries its signing secret, shown this once, and verificationError while it has not answered. */
+    /**
+     * Add an endpoint and send it its verification challenge. The answer carries its signing secret, shown this once, and verificationError while it has not answered.
+     *
+     * The answer is never kept for the idempotency key, so when it is lost, the library's retry or a repeat throws a ConflictError whose
+     * wasReplayed() is true: the endpoint was added, but its secret cannot be shown again. Find it with list() and call rotateSecret(),
+     * since nothing relies on its first secret yet, or delete() it and add it again.
+     */
     create(params: WebhookEndpointCreateParams, options?: RequestOptions): Promise<WebhookEndpoint>;
     /** Change an endpoint's url, events, description or active, only those given. A new url is verified again. */
     update(id: string, params: WebhookEndpointUpdateParams, options?: RequestOptions): Promise<WebhookEndpoint>;
@@ -20,7 +26,14 @@ export declare class WebhookEndpointService extends Service {
     verify(id: string, options?: RequestOptions): Promise<WebhookEndpoint>;
     /** Queue a sample charge.paid event, marked as a test, to a verified endpoint. */
     test(id: string, options?: RequestOptions): Promise<WebhookDelivery>;
-    /** Replace the endpoint's signing secret. The answer carries the new one, shown this once; the old one keeps signing for a day, until previousSecretExpiresAt. */
+    /**
+     * Replace the endpoint's signing secret. The answer carries the new one, shown this once; the old one keeps signing for a day, until previousSecretExpiresAt.
+     *
+     * The answer is never kept for the idempotency key, so when it is lost, the library's retry or a repeat throws a ConflictError whose
+     * wasReplayed() is true: the secret was rotated, but the new one cannot be shown again. The secret your receiver holds keeps
+     * verifying for a day as the previous one. Rotating again makes the lost secret the previous one and drops the one you hold at once,
+     * so only rotate again, with a fresh idempotency key, when you can deploy the new secret straight away; deliveries that fail meanwhile are retried.
+     */
     rotateSecret(id: string, options?: RequestOptions): Promise<WebhookEndpoint>;
     /** List what the endpoint was sent, newest first, kept for 30 days. */
     deliveries(id: string, params?: WebhookDeliveryListParams): Promise<Page<WebhookDelivery>>;

package/dist/cjs/services/webhook-endpoints.js

@@ -17,7 +17,13 @@ class WebhookEndpointService extends service_ts_1.Service {
     async retrieve(id) {
         return new webhook_endpoint_ts_1.WebhookEndpoint(await this.request('GET', (0, service_ts_1.path)('/v1/webhook-endpoints/%s', id)));
     }
-    /** Add an endpoint and send it its verification challenge. The answer carries its signing secret, shown this once, and verificationError while it has not answered. */
+    /**
+     * Add an endpoint and send it its verification challenge. The answer carries its signing secret, shown this once, and verificationError while it has not answered.
+     *
+     * The answer is never kept for the idempotency key, so when it is lost, the library's retry or a repeat throws a ConflictError whose
+     * wasReplayed() is true: the endpoint was added, but its secret cannot be shown again. Find it with list() and call rotateSecret(),
+     * since nothing relies on its first secret yet, or delete() it and add it again.
+     */
     async create(params, options) {
         return endpoint(await this.respond('POST', '/v1/webhook-endpoints', params, options));
     }
@@ -37,7 +43,14 @@ class WebhookEndpointService extends service_ts_1.Service {
     async test(id, options) {
         return new webhook_endpoint_ts_1.WebhookDelivery(await this.request('POST', (0, service_ts_1.path)('/v1/webhook-endpoints/%s/test', id), undefined, options));
     }
-    /** Replace the endpoint's signing secret. The answer carries the new one, shown this once; the old one keeps signing for a day, until previousSecretExpiresAt. */
+    /**
+     * Replace the endpoint's signing secret. The answer carries the new one, shown this once; the old one keeps signing for a day, until previousSecretExpiresAt.
+     *
+     * The answer is never kept for the idempotency key, so when it is lost, the library's retry or a repeat throws a ConflictError whose
+     * wasReplayed() is true: the secret was rotated, but the new one cannot be shown again. The secret your receiver holds keeps
+     * verifying for a day as the previous one. Rotating again makes the lost secret the previous one and drops the one you hold at once,
+     * so only rotate again, with a fresh idempotency key, when you can deploy the new secret straight away; deliveries that fail meanwhile are retried.
+     */
     async rotateSecret(id, options) {
         return endpoint(await this.respond('POST', (0, service_ts_1.path)('/v1/webhook-endpoints/%s/secret', id), undefined, options));
     }

package/dist/cjs/version.d.ts

@@ -1,2 +1,2 @@
 /** The version of this library. */
-export declare const VERSION = "0.1.0";
+export declare const VERSION = "0.2.0";

package/dist/cjs/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 /** The version of this library. */
-exports.VERSION = '0.1.0';
+exports.VERSION = '0.2.0';

package/dist/esm/client.d.ts

@@ -36,7 +36,7 @@ export interface ClientOptions {
 export declare class VeliraPayClient {
     #private;
     /** The version of this library. */
-    static readonly VERSION = "0.1.0";
+    static readonly VERSION = "0.2.0";
     /** The address of the VeliraPay API. */
     static readonly DEFAULT_BASE_URL = "https://api.velirapay.com";
     /** The account the API key belongs to. */

package/dist/esm/enums.d.ts

@@ -1,7 +1,7 @@
 /** A value the API defines, or one it adds after this version of the library. */
 export type OrString<T extends string> = T | (string & {});
 /** A coin on one particular network, such as USDT on Ethereum or USDT_TRON on Tron. The account lists the ones it accepts right now. */
-export declare const Asset: {
+export declare const Asset: Readonly<{
     readonly BTC: 'BTC';
     readonly BTC_LIGHTNING: 'BTC_LIGHTNING';
     readonly LTC: 'LTC';
@@ -25,47 +25,47 @@ export declare const Asset: {
     readonly ETH_BASE: 'ETH_BASE';
     readonly ETH_ARBITRUM: 'ETH_ARBITRUM';
     readonly POL: 'POL';
-};
+}>;
 export type Asset = (typeof Asset)[keyof typeof Asset];
 /** The states a charge moves through. */
-export declare const ChargeStatus: {
+export declare const ChargeStatus: Readonly<{
     readonly Pending: 'pending';
     readonly Underpaid: 'underpaid';
     readonly Paid: 'paid';
     readonly Expired: 'expired';
     readonly Canceled: 'canceled';
-};
+}>;
 export type ChargeStatus = (typeof ChargeStatus)[keyof typeof ChargeStatus];
 /** The states an invoice moves through. */
-export declare const InvoiceStatus: {
+export declare const InvoiceStatus: Readonly<{
     readonly Open: 'open';
     readonly Paid: 'paid';
     readonly Void: 'void';
-};
+}>;
 export type InvoiceStatus = (typeof InvoiceStatus)[keyof typeof InvoiceStatus];
 /** Where a payout has got to. */
-export declare const PayoutStatus: {
+export declare const PayoutStatus: Readonly<{
     readonly Pending: 'pending';
     readonly Sending: 'sending';
     readonly Sent: 'sent';
     readonly Failed: 'failed';
     readonly Manual: 'manual';
-};
+}>;
 export type PayoutStatus = (typeof PayoutStatus)[keyof typeof PayoutStatus];
 /** Whether a payment link takes payments. */
-export declare const PaymentLinkStatus: {
+export declare const PaymentLinkStatus: Readonly<{
     readonly Active: 'active';
     readonly Archived: 'archived';
-};
+}>;
 export type PaymentLinkStatus = (typeof PaymentLinkStatus)[keyof typeof PaymentLinkStatus];
 /** How a payment link is priced: at a set amount, or at one the customer names. */
-export declare const PricingType: {
+export declare const PricingType: Readonly<{
     readonly Fixed: 'fixed';
     readonly Open: 'open';
-};
+}>;
 export type PricingType = (typeof PricingType)[keyof typeof PricingType];
 /** The events a charge, an invoice or a payout reports, through webhooks and the events API. */
-export declare const EventType: {
+export declare const EventType: Readonly<{
     readonly ChargeCreated: 'charge.created';
     readonly ChargePaymentDetected: 'charge.payment_detected';
     readonly ChargePaid: 'charge.paid';
@@ -81,23 +81,23 @@ export declare const EventType: {
     readonly InvoiceVoided: 'invoice.voided';
     readonly PayoutSent: 'payout.sent';
     readonly PayoutConfirmed: 'payout.confirmed';
-};
+}>;
 export type EventType = (typeof EventType)[keyof typeof EventType];
 /** The mode an API key, object or webhook belongs to. */
-export declare const Mode: {
+export declare const Mode: Readonly<{
     readonly Live: 'live';
     readonly Test: 'test';
-};
+}>;
 export type Mode = (typeof Mode)[keyof typeof Mode];
 /** What kind of legal entity runs an account. */
-export declare const BusinessType: {
+export declare const BusinessType: Readonly<{
     readonly Individual: 'individual';
     readonly Company: 'company';
     readonly NonProfit: 'non_profit';
-};
+}>;
 export type BusinessType = (typeof BusinessType)[keyof typeof BusinessType];
 /** What an account sells, broadly. */
-export declare const Industry: {
+export declare const Industry: Readonly<{
     readonly DigitalProducts: 'digital_products';
     readonly Software: 'software';
     readonly Hosting: 'hosting';
@@ -110,19 +110,19 @@ export declare const Industry: {
     readonly Travel: 'travel';
     readonly Donations: 'donations';
     readonly Other: 'other';
-};
+}>;
 export type Industry = (typeof Industry)[keyof typeof Industry];
 /** How much an account expects to take in a month, in US dollars. */
-export declare const MonthlyVolume: {
+export declare const MonthlyVolume: Readonly<{
     readonly Under1k: 'under_1k';
     readonly Under10k: '1k_10k';
     readonly Under50k: '10k_50k';
     readonly Under250k: '50k_250k';
     readonly Over250k: 'over_250k';
-};
+}>;
 export type MonthlyVolume = (typeof MonthlyVolume)[keyof typeof MonthlyVolume];
 /** What a restricted API key may do. Full access gives every permission but the sensitive ones, which have to be ticked. */
-export declare const ApiKeyPermission: {
+export declare const ApiKeyPermission: Readonly<{
     readonly ChargesRead: 'charges:read';
     readonly ChargesWrite: 'charges:write';
     readonly ChargesAccept: 'charges:accept';
@@ -148,9 +148,141 @@ export declare const ApiKeyPermission: {
     readonly MembersRead: 'members:read';
     readonly MembersWrite: 'members:write';
     readonly BillingWrite: 'billing:write';
-};
+}>;
 export type ApiKeyPermission = (typeof ApiKeyPermission)[keyof typeof ApiKeyPermission];
 /** The fiat currencies prices can be set in. */
-export type Currency = 'USD' | 'EUR' | 'GBP' | 'CAD' | 'AUD' | 'CHF' | 'TRY';
-/** The roles a member can be given; an owner is never made through the API. */
-export type MemberRole = 'admin' | 'finance' | 'support' | 'viewer';
+export declare const Currency: Readonly<{
+    readonly USD: 'USD';
+    readonly EUR: 'EUR';
+    readonly GBP: 'GBP';
+    readonly CAD: 'CAD';
+    readonly AUD: 'AUD';
+    readonly CHF: 'CHF';
+    readonly TRY: 'TRY';
+}>;
+export type Currency = (typeof Currency)[keyof typeof Currency];
+/** The roles people have in an account. Owner only appears in answers: invitations and role changes take the others. */
+export declare const MemberRole: Readonly<{
+    readonly Owner: 'owner';
+    readonly Admin: 'admin';
+    readonly Finance: 'finance';
+    readonly Support: 'support';
+    readonly Viewer: 'viewer';
+}>;
+export type MemberRole = (typeof MemberRole)[keyof typeof MemberRole];
+/** The roles an invitation or a role change can give: every one but owner, which is never given through the API. */
+export type AssignableMemberRole = Exclude<MemberRole, typeof MemberRole.Owner>;
+/** The network families that each have one payout address, as payoutAddresses.update() and delete() name them. */
+export declare const AddressNetwork: Readonly<{
+    readonly Bitcoin: 'bitcoin';
+    readonly Litecoin: 'litecoin';
+    readonly Dogecoin: 'dogecoin';
+    readonly BitcoinCash: 'bitcoincash';
+    readonly Evm: 'evm';
+    readonly Bsc: 'bsc';
+    readonly Base: 'base';
+    readonly Arbitrum: 'arbitrum';
+    readonly Polygon: 'polygon';
+    readonly Tron: 'tron';
+    readonly Monero: 'monero';
+    readonly Solana: 'solana';
+    readonly Lightning: 'lightning';
+}>;
+export type AddressNetwork = (typeof AddressNetwork)[keyof typeof AddressNetwork];
+/** How the checkout looks: following the customer's device, or always light or dark. */
+export declare const CheckoutAppearance: Readonly<{
+    readonly Auto: 'auto';
+    readonly Light: 'light';
+    readonly Dark: 'dark';
+}>;
+export type CheckoutAppearance = (typeof CheckoutAppearance)[keyof typeof CheckoutAppearance];
+/** Where a webhook delivery has got to. */
+export declare const WebhookDeliveryStatus: Readonly<{
+    readonly Pending: 'pending';
+    readonly Succeeded: 'succeeded';
+    readonly Failed: 'failed';
+}>;
+export type WebhookDeliveryStatus = (typeof WebhookDeliveryStatus)[keyof typeof WebhookDeliveryStatus];
+/** The plans an account can be on: Free keeps a fee of every payment, Pro keeps none. */
+export declare const PlanName: Readonly<{
+    readonly Free: 'free';
+    readonly Pro: 'pro';
+}>;
+export type PlanName = (typeof PlanName)[keyof typeof PlanName];
+/** Whether an account is one person's or an organization's. */
+export declare const AccountType: Readonly<{
+    readonly Personal: 'personal';
+    readonly Organization: 'organization';
+}>;
+export type AccountType = (typeof AccountType)[keyof typeof AccountType];
+/** The languages the checkout can fall back on when the customer's browser asks for none of them. */
+export declare const CheckoutLocale: Readonly<{
+    readonly English: 'en';
+    readonly French: 'fr';
+    readonly German: 'de';
+    readonly Spanish: 'es';
+    readonly Turkish: 'tr';
+    readonly Portuguese: 'pt';
+    readonly Russian: 'ru';
+    readonly Arabic: 'ar';
+}>;
+export type CheckoutLocale = (typeof CheckoutLocale)[keyof typeof CheckoutLocale];
+/** What the activity log records. The API adds actions from time to time, so expect others too. */
+export declare const ActivityAction: Readonly<{
+    readonly WalletsChanged: 'wallets.changed';
+    readonly PayoutAddressAccessChanged: 'wallets.api_access_changed';
+    readonly SecondFactorRequirementChanged: 'team.second_factor_requirement_changed';
+    readonly PaymentSettingsUpdated: 'payment_settings.updated';
+    readonly ProfileUpdated: 'profile.updated';
+    readonly BusinessDetailsUpdated: 'business_details.updated';
+    readonly ApiKeyCreated: 'api_key.created';
+    readonly ApiKeyUpdated: 'api_key.updated';
+    readonly ApiKeyRevoked: 'api_key.revoked';
+    readonly WebhookCreated: 'webhook.created';
+    readonly WebhookUpdated: 'webhook.updated';
+    readonly WebhookDeleted: 'webhook.deleted';
+    readonly WebhookSecretRotated: 'webhook.secret_rotated';
+    readonly MemberInvited: 'member.invited';
+    readonly MemberJoined: 'member.joined';
+    readonly MemberRoleChanged: 'member.role_changed';
+    readonly MemberRemoved: 'member.removed';
+    readonly PaymentLinkCreated: 'payment_link.created';
+    readonly PaymentLinkUpdated: 'payment_link.updated';
+    readonly PaymentLinkArchived: 'payment_link.archived';
+    readonly PaymentLinkRestored: 'payment_link.restored';
+    readonly InvitationCanceled: 'member.invitation_canceled';
+    readonly ChargePaymentRequested: 'charge.payment_requested';
+    readonly WebhookDisabled: 'webhook.disabled';
+    readonly ChargeCanceled: 'charge.canceled';
+    readonly ChargeAccepted: 'charge.accepted';
+    readonly RefundRecorded: 'refund.recorded';
+    readonly InvoiceVoided: 'invoice.voided';
+    readonly PlanPaymentStarted: 'plan.payment_started';
+    readonly SubscriptionCanceled: 'plan.subscription_canceled';
+    readonly SubscriptionResumed: 'plan.subscription_resumed';
+    readonly SignedIn: 'auth.signed_in';
+    readonly SignInFailed: 'auth.sign_in_failed';
+    readonly PasswordChanged: 'auth.password_changed';
+    readonly TwoFactorEnabled: 'auth.two_factor_enabled';
+    readonly TwoFactorDisabled: 'auth.two_factor_disabled';
+    readonly SignedOutElsewhere: 'auth.signed_out_elsewhere';
+    readonly TwoFactorFailed: 'auth.two_factor_failed';
+    readonly EmailChanged: 'auth.email_changed';
+    readonly PasskeyAdded: 'auth.passkey_added';
+    readonly PasskeyRemoved: 'auth.passkey_removed';
+    readonly CouponCreated: 'coupon.created';
+    readonly CouponUpdated: 'coupon.updated';
+    readonly CouponDeleted: 'coupon.deleted';
+    readonly AppConnected: 'auth.app_connected';
+    readonly AppDisconnected: 'auth.app_disconnected';
+    readonly ChatConnected: 'chat.connected';
+    readonly ChatUpdated: 'chat.updated';
+    readonly ChatRemoved: 'chat.removed';
+    readonly ChatDisabled: 'chat.disabled';
+    readonly SanctionsMatched: 'sanctions.matched';
+    readonly SanctionsAccepted: 'sanctions.accepted';
+    readonly SanctionsReturnRequested: 'sanctions.return_requested';
+    readonly SocialAccountConnected: 'auth.social_connected';
+    readonly SocialAccountDisconnected: 'auth.social_disconnected';
+}>;
+export type ActivityAction = (typeof ActivityAction)[keyof typeof ActivityAction];