@chipmobilesdk/rn-payment 0.0.0-stage → 0.1.0

package/src/adapter/iap-adapter.ts

@@ -0,0 +1,516 @@
+/**
+ * Android adapter over `react-native-iap` (Play Billing).
+ *
+ * **The only file in this package that touches the billing library.** Everything
+ * above it talks to `ProviderPort`, which is what keeps the binding replaceable
+ * and lets an iOS adapter be added without changing a consumer call (FR-002,
+ * FR-007). ESLint enforces that boundary.
+ *
+ * ## Verification status
+ *
+ * The binding is **not yet installed** — the root `react-native-nitro-modules`
+ * bump it requires is held pending approval (see specs/013-rn-payment-sdk/plan.md,
+ * Post-Implementation Notes). So the call shapes below are written against
+ * `react-native-iap` 16.x as documented, and **every one must be verified against
+ * the installed package** before this adapter is trusted on a device. The module
+ * is required lazily and the surface it needs is declared explicitly in
+ * `IapModule`, so a mismatch surfaces here rather than deep in the engine.
+ *
+ * No test exercises this file: the whole suite runs against the fake store, and
+ * the IAP test double throws on every call precisely so that reaching this code in
+ * a test fails loudly instead of passing against a stub.
+ *
+ * ## Known upstream defect this guards against
+ *
+ * openiap#408: the Android bridge did not clear its internal `isInitialized` flag
+ * on disconnect, so `connected` stayed true, later calls failed with
+ * `E_NOT_PREPARED`, and `reconnect()` reported success without rebuilding
+ * anything. This adapter therefore (a) tracks connection state itself rather than
+ * trusting the binding's flag, and (b) always performs a full
+ * `endConnection` + `initConnection` cycle instead of calling any reconnect
+ * shortcut.
+ */
+
+import type { ProductType, Unsubscribe } from '../config/types';
+import type {
+	ProviderCapabilities,
+	ProviderConnectOutcome,
+	ProviderFailureReason,
+	ProviderPort,
+	ProviderPriceChangeOutcome,
+	ProviderProduct,
+	ProviderPurchase,
+	ProviderPurchaseOutcome,
+	ProviderPurchaseRequest,
+	ProviderToken,
+	StoreProductId,
+} from './port';
+
+/**
+ * Exactly what this adapter needs from the binding.
+ *
+ * Declared narrowly on purpose: it documents the coupling, and it means a binding
+ * upgrade that changes one of these shapes fails to typecheck here instead of
+ * failing silently at runtime on a user's device.
+ */
+interface IapModule {
+	initConnection(): Promise<boolean>;
+	endConnection(): Promise<void>;
+	fetchProducts(params: {
+		skus: string[];
+		type: 'in-app' | 'subs';
+	}): Promise<RawProduct[]>;
+	getAvailablePurchases(): Promise<RawPurchase[]>;
+	requestPurchase(params: unknown): Promise<unknown>;
+	finishTransaction(params: {
+		purchase: unknown;
+		isConsumable?: boolean;
+	}): Promise<unknown>;
+	purchaseUpdatedListener(
+		listener: (purchase: RawPurchase) => void,
+	): { remove(): void };
+	purchaseErrorListener(
+		listener: (error: { code?: string; message?: string }) => void,
+	): { remove(): void };
+	deepLinkToSubscriptions?(params: { skuAndroid?: string }): Promise<void>;
+}
+
+interface RawProduct {
+	id?: string;
+	productId?: string;
+	title?: string;
+	name?: string;
+	description?: string;
+	displayPrice?: string;
+	localizedPrice?: string;
+	currency?: string;
+	currencyCode?: string;
+	price?: string | number;
+	oneTimePurchaseOfferDetails?: {
+		formattedPrice?: string;
+		priceAmountMicros?: string | number;
+		priceCurrencyCode?: string;
+	};
+	subscriptionOfferDetails?: RawSubscriptionOffer[];
+}
+
+interface RawSubscriptionOffer {
+	offerToken?: string;
+	offerId?: string;
+	basePlanId?: string;
+	pricingPhases?: {
+		pricingPhaseList?: Array<{
+			formattedPrice?: string;
+			priceAmountMicros?: string | number;
+			priceCurrencyCode?: string;
+			billingPeriod?: string;
+			recurrenceMode?: number;
+			billingCycleCount?: number;
+		}>;
+	};
+}
+
+interface RawPurchase {
+	id?: string;
+	transactionId?: string;
+	productId?: string;
+	ids?: string[];
+	purchaseToken?: string;
+	purchaseStateAndroid?: number;
+	purchaseState?: number | string;
+	transactionDate?: number;
+	isAcknowledgedAndroid?: boolean;
+	isAcknowledged?: boolean;
+	autoRenewingAndroid?: boolean;
+	isAutoRenewing?: boolean;
+	expirationDateAndroid?: number;
+	transactionReceipt?: string;
+	dataAndroid?: string;
+}
+
+/** Play's `PurchaseState`: 0 unspecified, 1 purchased, 2 pending. */
+const PLAY_STATE_PURCHASED = 1;
+const PLAY_STATE_PENDING = 2;
+
+function loadModule(): IapModule {
+	// Required lazily so importing the package does not require the native module.
+	const mod = require('react-native-iap') as IapModule;
+	return mod;
+}
+
+function toMicros(value: string | number | undefined): number {
+	if (typeof value === 'number') {
+		return value;
+	}
+	if (typeof value === 'string') {
+		const parsed = Number.parseInt(value, 10);
+		return Number.isFinite(parsed) ? parsed : 0;
+	}
+	return 0;
+}
+
+function normalizeProduct(
+	raw: RawProduct,
+	productType: ProductType,
+): ProviderProduct {
+	const oneTime = raw.oneTimePurchaseOfferDetails;
+	const currencyCode =
+		oneTime?.priceCurrencyCode ?? raw.currencyCode ?? raw.currency ?? '';
+
+	return {
+		storeProductId: raw.id ?? raw.productId ?? '',
+		productType,
+		title: raw.title ?? raw.name ?? '',
+		description: raw.description ?? '',
+		// Store-formatted, never built here: only the store knows the right currency
+		// symbol, separator, and placement for the user's locale (FR-028).
+		formattedPrice:
+			oneTime?.formattedPrice ?? raw.displayPrice ?? raw.localizedPrice ?? '',
+		currencyCode,
+		priceAmountMicros: toMicros(oneTime?.priceAmountMicros ?? raw.price),
+		offers: (raw.subscriptionOfferDetails ?? []).map(offer =>
+			normalizeOffer(offer, currencyCode),
+		),
+	};
+}
+
+function normalizeOffer(
+	offer: RawSubscriptionOffer,
+	fallbackCurrency: string,
+): ProviderProduct['offers'][number] {
+	const phases = offer.pricingPhases?.pricingPhaseList ?? [];
+	// The last phase is the recurring price; earlier ones are trial or
+	// introductory. Play orders them that way.
+	const recurring = phases[phases.length - 1];
+	const intro = phases.length > 1 ? phases[0] : undefined;
+	const isFreeTrial = intro !== undefined && toMicros(intro.priceAmountMicros) === 0;
+
+	return {
+		offerKey: offer.offerToken ?? offer.offerId ?? offer.basePlanId ?? '',
+		billingPeriod: recurring?.billingPeriod ?? '',
+		formattedPrice: recurring?.formattedPrice ?? '',
+		priceAmountMicros: toMicros(recurring?.priceAmountMicros),
+		currencyCode: recurring?.priceCurrencyCode ?? fallbackCurrency,
+		trialPeriod: isFreeTrial ? intro?.billingPeriod : undefined,
+		introductoryPrice:
+			intro && !isFreeTrial
+				? {
+						formattedPrice: intro.formattedPrice ?? '',
+						period: intro.billingPeriod ?? '',
+						cycles: intro.billingCycleCount ?? 1,
+					}
+				: undefined,
+		// Play decides eligibility by only returning offers the user qualifies for,
+		// so forwarding `true` reports the store's determination rather than
+		// computing our own (FR-026).
+		isEligible: true,
+	};
+}
+
+function normalizePurchase(raw: RawPurchase): ProviderPurchase {
+	const state = raw.purchaseStateAndroid ?? raw.purchaseState;
+	const numericState = typeof state === 'number' ? state : PLAY_STATE_PURCHASED;
+
+	return {
+		storeProductId: raw.productId ?? raw.ids?.[0] ?? '',
+		transactionId: raw.id ?? raw.transactionId ?? raw.purchaseToken ?? '',
+		token: raw.purchaseToken ?? '',
+		// Pending is preserved, never flattened to purchased: that distinction is
+		// what stops an entitlement being granted for money that has not arrived
+		// (FR-037).
+		state:
+			numericState === PLAY_STATE_PENDING
+				? 'pending'
+				: numericState === PLAY_STATE_PURCHASED
+					? 'purchased'
+					: 'unspecified',
+		purchasedAt: raw.transactionDate ?? Date.now(),
+		isAcknowledged: raw.isAcknowledgedAndroid ?? raw.isAcknowledged ?? false,
+		expiresAt: raw.expirationDateAndroid,
+		willAutoRenew: raw.autoRenewingAndroid ?? raw.isAutoRenewing,
+		// Opaque material for the app's backend. Carried here and handed to the
+		// validation hook only — never logged or put in an event (FR-074).
+		verificationPayload: raw.transactionReceipt ?? raw.dataAndroid,
+	};
+}
+
+/** Maps a binding error code onto the port's vocabulary, so no store code escapes. */
+function mapErrorCode(code: string | undefined): ProviderFailureReason {
+	switch (code) {
+		case 'E_USER_CANCELLED':
+		case 'user-cancelled':
+			return 'user_cancelled';
+		case 'E_ALREADY_OWNED':
+		case 'item-already-owned':
+			return 'already_owned';
+		case 'E_ITEM_UNAVAILABLE':
+		case 'item-unavailable':
+			return 'unknown_product';
+		case 'E_NOT_PREPARED':
+		case 'not-prepared':
+			return 'not_ready';
+		case 'E_NETWORK_ERROR':
+		case 'network-error':
+			return 'network_error';
+		case 'E_DEFERRED_PAYMENT':
+			// Not a failure — a pending purchase. The caller resolves it from the
+			// purchase update rather than from this error.
+			return 'store_error';
+		default:
+			return 'store_error';
+	}
+}
+
+const ANDROID_CAPABILITIES: ProviderCapabilities = {
+	supportsSubscriptions: true,
+	supportsPlanChange: true,
+	supportsPriceChangeConfirmation: false,
+	/**
+	 * False, and this is a platform fact rather than a gap in this adapter.
+	 *
+	 * Client-side Play Billing cannot separate grace period from account hold: a
+	 * grace-period subscription is still returned as active, and one in account
+	 * hold stops being returned at all — indistinguishable from expired, cancelled,
+	 * or refunded. The entitlement layer reads this flag and reports
+	 * `indeterminate` rather than inventing a distinction (research.md R5).
+	 */
+	reportsGraceAndHoldDistinctly: false,
+	supportsExternalTransactions: false,
+	/** This one really does move money, which is what arms the environment guard. */
+	createsRealTransactions: true,
+};
+
+export interface IapAdapterOptions {
+	/** Injected in tests that need to drive the mapping without the native module. */
+	module?: IapModule;
+}
+
+export function createIapAdapter(options: IapAdapterOptions = {}): ProviderPort {
+	let iap: IapModule | undefined = options.module;
+
+	/** Tracked here, never read from the binding — see the openiap#408 note above. */
+	let connected = false;
+
+	const connectionListeners = new Set<
+		(connected: boolean, reason?: string) => void
+	>();
+	const purchaseListeners = new Set<(purchase: ProviderPurchase) => void>();
+	let updateSub: { remove(): void } | undefined;
+	let errorSub: { remove(): void } | undefined;
+
+	const module = (): IapModule => {
+		if (!iap) {
+			iap = loadModule();
+		}
+		return iap;
+	};
+
+	const notifyConnection = (next: boolean, reason?: string): void => {
+		if (connected === next) {
+			return;
+		}
+		connected = next;
+		for (const listener of connectionListeners) {
+			listener(next, reason);
+		}
+	};
+
+	const attachListeners = (): void => {
+		const mod = module();
+		updateSub = mod.purchaseUpdatedListener(raw => {
+			const purchase = normalizePurchase(raw);
+			for (const listener of purchaseListeners) {
+				listener(purchase);
+			}
+		});
+		errorSub = mod.purchaseErrorListener(error => {
+			// A `not-prepared` error is the one signal the binding gives that the
+			// service went away underneath us, so it is treated as a disconnect
+			// rather than as a purchase failure.
+			if (mapErrorCode(error.code) === 'not_ready') {
+				notifyConnection(false, 'not_prepared');
+			}
+		});
+	};
+
+	const detachListeners = (): void => {
+		updateSub?.remove();
+		updateSub = undefined;
+		errorSub?.remove();
+		errorSub = undefined;
+	};
+
+	return {
+		async connect(): Promise<ProviderConnectOutcome> {
+			try {
+				const mod = module();
+				// Always a full cycle. The binding's own reconnect has reported success
+				// without rebuilding anything, so we never rely on it (openiap#408).
+				if (connected) {
+					await mod.endConnection().catch(() => undefined);
+					connected = false;
+				}
+				const ok = await mod.initConnection();
+				if (!ok) {
+					return {
+						ok: false,
+						reason: 'no_billing_service',
+						retryable: true,
+					};
+				}
+				attachListeners();
+				notifyConnection(true);
+				return { ok: true };
+			} catch (error) {
+				const code = (error as { code?: string }).code;
+				// A missing or too-old Play Services install is not the same as a
+				// transient error, and the app shows different things for each (FR-021).
+				if (code === 'E_IAP_NOT_AVAILABLE' || code === 'iap-not-available') {
+					return { ok: false, reason: 'no_billing_service', retryable: false };
+				}
+				if (code === 'E_SERVICE_ERROR') {
+					return {
+						ok: false,
+						reason: 'billing_service_outdated',
+						retryable: true,
+					};
+				}
+				return { ok: false, reason: 'store_error', retryable: true };
+			}
+		},
+
+		async disconnect(): Promise<void> {
+			detachListeners();
+			try {
+				await module().endConnection();
+			} catch {
+				// Already down; nothing to tear down.
+			}
+			notifyConnection(false, 'disconnect');
+		},
+
+		observeConnection(listener): Unsubscribe {
+			connectionListeners.add(listener);
+			let removed = false;
+			return () => {
+				if (removed) {
+					return;
+				}
+				removed = true;
+				connectionListeners.delete(listener);
+			};
+		},
+
+		async queryProducts(
+			storeProductIds: StoreProductId[],
+			productType: ProductType,
+		): Promise<ProviderProduct[]> {
+			const raw = await module().fetchProducts({
+				skus: storeProductIds,
+				type: productType === 'subscription' ? 'subs' : 'in-app',
+			});
+			return raw.map(product => normalizeProduct(product, productType));
+		},
+
+		async queryOwned(): Promise<ProviderPurchase[]> {
+			const raw = await module().getAvailablePurchases();
+			// Pending purchases are mapped through, flagged rather than filtered: the
+			// engine needs to see them to raise the pending signal (FR-038).
+			return raw.map(normalizePurchase);
+		},
+
+		async launchPurchase(
+			request: ProviderPurchaseRequest,
+		): Promise<ProviderPurchaseOutcome> {
+			try {
+				const isSubscription = request.productType === 'subscription';
+				const result = await module().requestPurchase({
+					request: {
+						android: {
+							skus: [request.storeProductId],
+							obfuscatedAccountIdAndroid: request.obfuscatedAccountId,
+							...(isSubscription && request.offerKey
+								? {
+										subscriptionOffers: [
+											{
+												sku: request.storeProductId,
+												offerToken: request.offerKey,
+											},
+										],
+									}
+								: {}),
+							...(request.replaceStoreProductId
+								? {
+										purchaseTokenAndroid: request.replaceStoreProductId,
+										replacementModeAndroid: request.prorationMode,
+									}
+								: {}),
+						},
+					},
+					type: isSubscription ? 'subs' : 'in-app',
+				});
+
+				// The binding may resolve with the purchase, or resolve empty and deliver
+				// it through the update listener. Both are handled: the engine also
+				// ingests listener-delivered purchases, so neither path loses one.
+				const raw = Array.isArray(result) ? result[0] : result;
+				if (!raw) {
+					return { ok: false, reason: 'store_error', detail: 'no purchase returned' };
+				}
+				return { ok: true, purchase: normalizePurchase(raw as RawPurchase) };
+			} catch (error) {
+				const code = (error as { code?: string }).code;
+				return { ok: false, reason: mapErrorCode(code), detail: code };
+			}
+		},
+
+		observePurchases(listener): Unsubscribe {
+			purchaseListeners.add(listener);
+			let removed = false;
+			return () => {
+				if (removed) {
+					return;
+				}
+				removed = true;
+				purchaseListeners.delete(listener);
+			};
+		},
+
+		async acknowledge(token: ProviderToken): Promise<void> {
+			// Idempotent at the store: acknowledging an already-acknowledged purchase
+			// is accepted, which is what FR-044 relies on.
+			await module().finishTransaction({
+				purchase: { purchaseToken: token },
+				isConsumable: false,
+			});
+		},
+
+		async consume(token: ProviderToken): Promise<void> {
+			await module().finishTransaction({
+				purchase: { purchaseToken: token },
+				isConsumable: true,
+			});
+		},
+
+		async openSubscriptionManagement(
+			storeProductId?: StoreProductId,
+		): Promise<void> {
+			// The store's own screen. Platforms forbid a self-built cancellation
+			// screen, so there is deliberately no alternative path here (FR-066).
+			const mod = module();
+			if (!mod.deepLinkToSubscriptions) {
+				return;
+			}
+			await mod.deepLinkToSubscriptions({ skuAndroid: storeProductId });
+		},
+
+		async confirmPriceChange(): Promise<ProviderPriceChangeOutcome> {
+			// Play has no client-side price-change confirmation flow; it notifies the
+			// user itself. Reported as unsupported rather than faked, matching
+			// `supportsPriceChangeConfirmation: false` (FR-067).
+			return { ok: false, reason: 'store_error' };
+		},
+
+		capabilities: () => ANDROID_CAPABILITIES,
+	};
+}

package/src/adapter/port.ts

@@ -0,0 +1,186 @@
+/**
+ * The provider port — **private**, never exported from `src/index.ts`.
+ *
+ * This is the boundary between the platform-neutral engine and a store-specific
+ * adapter. It exists to make three things true:
+ *
+ * 1. No store type reaches the public surface, because only the adapter ever
+ *    sees one (FR-002).
+ * 2. An iOS adapter can be added by implementing this interface, changing no
+ *    consumer call (FR-007).
+ * 3. The fake store is a drop-in replacement, so every outcome and ordering is
+ *    testable with no device, network, or store account (NFR-007).
+ *
+ * `Provider*` types are the port's **own** normalized shapes, not the binding's.
+ * The adapter translates; nothing above it sees a `react-native-iap` value.
+ */
+
+import type { ProductType, Unsubscribe } from '../config/types';
+
+/** A store's own product identifier. Confined to configuration and this layer. */
+export type StoreProductId = string;
+
+/** Opaque handle the store uses to identify a transaction for finalization. */
+export type ProviderToken = string;
+
+export type ProviderPurchaseState = 'purchased' | 'pending' | 'unspecified';
+
+export interface ProviderOffer {
+	offerKey: string;
+	billingPeriod: string;
+	formattedPrice: string;
+	priceAmountMicros: number;
+	currencyCode: string;
+	trialPeriod?: string;
+	introductoryPrice?: {
+		formattedPrice: string;
+		period: string;
+		cycles: number;
+	};
+	/** As the **store** determined it. Never computed locally (FR-026). */
+	isEligible: boolean;
+}
+
+export interface ProviderProduct {
+	storeProductId: StoreProductId;
+	productType: ProductType;
+	title: string;
+	description: string;
+	formattedPrice: string;
+	currencyCode: string;
+	priceAmountMicros: number;
+	offers: ProviderOffer[];
+}
+
+export interface ProviderPurchase {
+	storeProductId: StoreProductId;
+	transactionId: string;
+	token: ProviderToken;
+	state: ProviderPurchaseState;
+	purchasedAt: number;
+	isAcknowledged: boolean;
+	/** Subscription-only, and only where the platform supplies it. */
+	expiresAt?: number;
+	willAutoRenew?: boolean;
+	/**
+	 * Opaque material for the app's backend. Passed to the validation hook and
+	 * **never** logged or put in an event (FR-074).
+	 */
+	verificationPayload?: string;
+}
+
+export type ProviderFailureReason =
+	| 'user_cancelled'
+	| 'already_owned'
+	| 'ineligible'
+	| 'unknown_product'
+	| 'product_unavailable_in_region'
+	| 'not_ready'
+	| 'network_error'
+	| 'timeout'
+	| 'store_error';
+
+export type ProviderConnectOutcome =
+	| { ok: true }
+	| {
+			ok: false;
+			reason: 'no_billing_service' | 'billing_service_outdated' | 'platform_unsupported' | 'store_error';
+			retryable: boolean;
+	  };
+
+export type ProviderPurchaseOutcome =
+	| { ok: true; purchase: ProviderPurchase }
+	| { ok: false; reason: ProviderFailureReason; detail?: string };
+
+export type ProviderPriceChangeOutcome =
+	| { ok: true; confirmed: boolean }
+	| { ok: false; reason: ProviderFailureReason };
+
+export interface ProviderPurchaseRequest {
+	storeProductId: StoreProductId;
+	productType: ProductType;
+	offerKey?: string;
+	/** App-supplied, passed straight through. Never generated or stored (FR-034). */
+	obfuscatedAccountId?: string;
+	/** Plan change: the currently-active subscription being replaced. */
+	replaceStoreProductId?: StoreProductId;
+	prorationMode?: string;
+}
+
+/**
+ * What the platform can actually do.
+ *
+ * This is how honest degradation is enforced rather than left to good intentions.
+ * `reportsGraceAndHoldDistinctly` is `false` on Android, because client-side Play
+ * Billing genuinely cannot separate the two: a grace-period subscription is still
+ * returned as active, and one in account hold stops being returned at all, making
+ * it indistinguishable from expired, cancelled, or refunded.
+ *
+ * The entitlement layer reads this flag and reports `indeterminate` instead of
+ * fabricating a distinction from `willAutoRenew` — which cannot separate grace
+ * from cancelled-but-valid either. Claiming otherwise would breach FR-058.
+ */
+export interface ProviderCapabilities {
+	supportsSubscriptions: boolean;
+	supportsPlanChange: boolean;
+	supportsPriceChangeConfirmation: boolean;
+	reportsGraceAndHoldDistinctly: boolean;
+	/** Externally-initiated purchases: false on Android, true for a future iOS adapter. */
+	supportsExternalTransactions: boolean;
+	/**
+	 * Whether this adapter can move real money.
+	 *
+	 * `true` for the store adapter, `false` for the fake store. This is what lets
+	 * FR-014's block be precise: the engine refuses a purchase when the
+	 * environment may not create a production transaction **and** the provider is
+	 * one that actually would. Without it the guard would either block the test
+	 * suite — which must be able to buy things — or wave real purchases through in
+	 * a development build.
+	 */
+	createsRealTransactions: boolean;
+}
+
+export interface ProviderPort {
+	connect(): Promise<ProviderConnectOutcome>;
+	disconnect(): Promise<void>;
+
+	/**
+	 * Reports a **real** disconnect.
+	 *
+	 * The engine must never infer connectivity from an unrelated call failing.
+	 * The upstream binding historically left its `connected` flag true after a
+	 * disconnect and had a `reconnect()` that could report success without
+	 * rebuilding anything (openiap#408), so detection belongs here, behind a
+	 * contract test.
+	 */
+	observeConnection(
+		listener: (connected: boolean, reason?: string) => void,
+	): Unsubscribe;
+
+	queryProducts(
+		storeProductIds: StoreProductId[],
+		productType: ProductType,
+	): Promise<ProviderProduct[]>;
+
+	/** Owned and pending purchases. Pending ones are **flagged, never filtered** (FR-037). */
+	queryOwned(): Promise<ProviderPurchase[]>;
+
+	launchPurchase(
+		request: ProviderPurchaseRequest,
+	): Promise<ProviderPurchaseOutcome>;
+
+	/** Store-initiated updates, including a pending purchase settling later (FR-039). */
+	observePurchases(listener: (purchase: ProviderPurchase) => void): Unsubscribe;
+
+	/** Must be safe to call for an already-finalized transaction (FR-044). */
+	acknowledge(token: ProviderToken): Promise<void>;
+	/** Must be safe to call twice; the item is granted once (FR-044). */
+	consume(token: ProviderToken): Promise<void>;
+
+	openSubscriptionManagement(storeProductId?: StoreProductId): Promise<void>;
+	confirmPriceChange(
+		storeProductId: StoreProductId,
+	): Promise<ProviderPriceChangeOutcome>;
+
+	capabilities(): ProviderCapabilities;
+}