@comfyorg/account-core 1.0.0-alpha.0

package/dist/core/billing/challengeDriver.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Drives one embedded challenge through the host's payment-provider port and
+ * reports the verdict back to the lifecycle. The provider object stays on the
+ * host side: the core sees only `handleNextAction`, so no provider SDK is
+ * imported here and a test can hand in a plain function.
+ */
+import type { BillingOperationLifecycle } from './operationLifecycle.js';
+export interface EmbeddedChallengePort {
+    /** Stripe's `handleNextAction` shape: resolve the challenge for one client secret. */
+    handleNextAction: (clientSecret: string) => Promise<{
+        readonly error?: unknown;
+        readonly paymentIntent?: {
+            readonly status: string;
+        };
+    }>;
+}
+export type EmbeddedChallengeOutcome = 'completed' | 'failed'
+/** No required challenge on an embedded, pending operation with that id. */
+ | 'not_required';
+type ChallengeLifecycle = Pick<BillingOperationLifecycle, 'get' | 'reportChallengeStarted' | 'reportChallengeSettled'>;
+export declare function driveEmbeddedChallenge(lifecycle: ChallengeLifecycle, operationId: string, port: EmbeddedChallengePort): Promise<EmbeddedChallengeOutcome>;
+export {};

package/dist/core/billing/challengeDriver.js

@@ -0,0 +1,38 @@
+/**
+ * Statuses that mean the resumed challenge left the intent exactly where it
+ * started, so the attempt needs a fresh start rather than a poll. A denylist
+ * fails toward the server: an unlisted or future status reports optimistically
+ * as completed, and the next poll's own `authentication_state` corrects it.
+ */
+const UNMOVED_INTENT_STATUSES = new Set([
+    'requires_payment_method',
+    'requires_action',
+    'canceled'
+]);
+export async function driveEmbeddedChallenge(lifecycle, operationId, port) {
+    const state = lifecycle.get(operationId);
+    if (state?.phase !== 'pending' ||
+        state.presentation !== 'embedded' ||
+        state.challenge?.status !== 'required') {
+        return 'not_required';
+    }
+    lifecycle.reportChallengeStarted(operationId);
+    const outcome = await settle(port, state.challenge.clientSecret);
+    lifecycle.reportChallengeSettled(operationId, outcome);
+    return outcome;
+}
+async function settle(port, clientSecret) {
+    try {
+        const result = await port.handleNextAction(clientSecret);
+        if (result.error !== undefined)
+            return 'failed';
+        if (result.paymentIntent !== undefined &&
+            UNMOVED_INTENT_STATUSES.has(result.paymentIntent.status)) {
+            return 'failed';
+        }
+        return 'completed';
+    }
+    catch {
+        return 'failed';
+    }
+}

package/dist/core/billing/credentialedTransport.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The billing transport for a host whose credentials it never holds: a BFF
+ * that proxies the cloud API with server-held secrets on its own origin, or a
+ * hosted app the backend has given a session cookie. The request carries
+ * `credentials` and no `Authorization` header, and the scope comes from the
+ * host's scope source rather than from a minted credential.
+ *
+ * There is no 401 retry here, because there is nothing this client can
+ * re-mint. A 401 is returned as an HTTP answer like any other, marked
+ * `authenticationNotRenewable` so that `codeForHttpStatus` reads it as the
+ * host's session ending rather than a refusal: nothing was ever minted or
+ * proved, so it says the credential expired, not that the user lacks access.
+ * `authenticationRetrySkipped` stays unset; it means a replayable retry was
+ * possible and skipped, which is never the case on this transport.
+ *
+ * No CSRF header is sent. What stands in for one is the JSON content type
+ * `exchangeBillingRequest` always sends: it makes every request non-simple,
+ * so a cross-site caller has to clear a preflight it cannot satisfy. That
+ * rests on the cookie's `SameSite` attribute and the backend's CORS
+ * allowlist, neither of which is enforced here — sending a form-encoded or
+ * otherwise CORS-simple request from this transport removes the protection.
+ * A CSRF header is added here when the backend names one.
+ */
+import type { BillingTransport } from './billingContracts.js';
+import type { BillingScopeSource } from './billingScope.js';
+export interface CredentialedBillingTransportOptions {
+    /** Resolves a route to an absolute URL, as the session transport's does. */
+    readonly resolveUrl: (route: string) => string;
+    readonly scopeSource: BillingScopeSource;
+    /** Default `'include'`, so a cookie survives a cross-origin billing host. */
+    readonly credentials?: RequestCredentials;
+    readonly fetchImpl?: typeof fetch;
+    readonly defaultTimeoutMs?: number;
+}
+export declare function createCredentialedBillingTransport(options: CredentialedBillingTransportOptions): BillingTransport;

package/dist/core/billing/credentialedTransport.js

@@ -0,0 +1,53 @@
+import { sameBillingScope } from './billingScope.js';
+import { DEFAULT_BILLING_TIMEOUT_MS, exchangeBillingRequest, startRequestBudget } from './transportExchange.js';
+/**
+ * Any scope other than the captured one supersedes the response, undefined
+ * included. A source has no "still minting" state: undefined means the scope
+ * is gone — a sign-out or a workspace teardown — which is how
+ * `createBillingScopeTracker` reads it, and how the session transport reads a
+ * delivered sign-out. Attributing the response anyway would land it in a
+ * reader that has already dropped that scope.
+ */
+function movedOutOfScope(source, captured) {
+    const current = source.getScope();
+    return current === undefined || !sameBillingScope(captured, current);
+}
+/**
+ * A 401 reaching here means the host's credential is gone, not that access
+ * was refused: this transport never held one to re-prove with.
+ */
+function markSessionEnded(response) {
+    if (response.httpStatus !== 401)
+        return response;
+    return { ...response, authenticationNotRenewable: true };
+}
+export function createCredentialedBillingTransport(options) {
+    const { resolveUrl, scopeSource, credentials = 'include', fetchImpl = fetch, defaultTimeoutMs = DEFAULT_BILLING_TIMEOUT_MS } = options;
+    return async function transport(request) {
+        const captured = scopeSource.getScope();
+        if (captured === undefined) {
+            return { status: 'error', code: 'NOT_AUTHENTICATED' };
+        }
+        const budget = startRequestBudget(request.signal, request.timeoutMs ?? defaultTimeoutMs);
+        try {
+            const response = await exchangeBillingRequest(request, {
+                fetchImpl,
+                url: resolveUrl(request.route),
+                signal: budget.signal,
+                credentials
+            });
+            if (response.status === 'error')
+                return response;
+            if (movedOutOfScope(scopeSource, captured)) {
+                return { status: 'error', code: 'SUPERSEDED' };
+            }
+            return { status: 'ok', value: markSessionEnded(response.value) };
+        }
+        catch {
+            return { status: 'error', code: 'REQUEST_FAILED' };
+        }
+        finally {
+            budget.close();
+        }
+    };
+}

package/dist/core/billing/credits.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The credits read: a workspace's balance, cached per scope.
+ *
+ * Balances are reported in micros and kept that way. Converting to a display
+ * unit here would bake one currency's minor-unit assumption into the core and
+ * lose precision before the host ever sees the number; formatting belongs to
+ * the view layer, which has the locale.
+ */
+import { zBillingBalanceResponse } from '@comfyorg/ingest-types/zod';
+import type { z } from 'zod';
+import type { BillingResult, BillingTransport } from './billingContracts.js';
+import type { BillingScope, BillingScopeSource } from './billingScope.js';
+export declare const CREDITS_ROUTE = "/billing/balance";
+export type BillingBalance = z.infer<typeof zBillingBalanceResponse>;
+export type CreditsScope = BillingScope;
+export interface CreditsSnapshot {
+    readonly balance: BillingBalance;
+    readonly scope: CreditsScope;
+    /** ms since epoch at which this read settled. */
+    readonly readAt: number;
+}
+export interface CreditsReadOptions {
+    readonly signal?: AbortSignal;
+}
+export interface CreditsReader {
+    /**
+     * Always requests. A balance has no server-declared lifetime and moves on
+     * every run, so there is no interval over which serving a cached one is
+     * correct; the cache exists to survive a failure, not to skip a read.
+     * Concurrent callers for one scope still share a single request.
+     */
+    read: (options?: CreditsReadOptions) => Promise<BillingResult<CreditsSnapshot>>;
+    /** The last balance published for the current scope. */
+    getSnapshot: () => CreditsSnapshot | undefined;
+    dispose: () => void;
+}
+export interface CreditsReaderOptions {
+    readonly transport: BillingTransport;
+    /** Where the core learns which user, workspace, and role it runs as. */
+    readonly scopeSource: BillingScopeSource;
+    readonly now?: () => number;
+}
+export declare function createCreditsReader(options: CreditsReaderOptions): CreditsReader;

package/dist/core/billing/credits.js

@@ -0,0 +1,29 @@
+/**
+ * The credits read: a workspace's balance, cached per scope.
+ *
+ * Balances are reported in micros and kept that way. Converting to a display
+ * unit here would bake one currency's minor-unit assumption into the core and
+ * lose precision before the host ever sees the number; formatting belongs to
+ * the view layer, which has the locale.
+ */
+import { zBillingBalanceResponse } from '@comfyorg/ingest-types/zod';
+import { createScopedReader } from './scopedReader.js';
+export const CREDITS_ROUTE = '/billing/balance';
+export function createCreditsReader(options) {
+    const { transport, scopeSource, now = Date.now } = options;
+    const reader = createScopedReader({
+        transport,
+        scopeSource,
+        route: CREDITS_ROUTE,
+        parse: (body) => zBillingBalanceResponse.safeParse(body),
+        project: ({ data }, scope) => ({
+            status: 'ok',
+            value: { balance: data, scope, readAt: now() }
+        })
+    });
+    return {
+        read: reader.read,
+        getSnapshot: reader.getSnapshot,
+        dispose: reader.dispose
+    };
+}

package/dist/core/billing/httpStatus.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The one place a billing HTTP status becomes a code. The transport
+ * deliberately returns an answer of any status as `ok`, so that every typed
+ * operation maps status the same way instead of each inventing its own.
+ */
+import type { BillingErrorCode, BillingHttpResponse } from './billingContracts.js';
+export declare function codeForHttpStatus(response: Pick<BillingHttpResponse, 'httpStatus' | 'authenticationRetrySkipped' | 'authenticationNotRenewable'>): BillingErrorCode;

package/dist/core/billing/httpStatus.js

@@ -0,0 +1,25 @@
+export function codeForHttpStatus(response) {
+    const status = response.httpStatus;
+    // A 401 the transport re-minted and retried is a real refusal. One it had
+    // to leave alone, because the write was not replayable, says only that the
+    // token had gone stale; the caller's next attempt mints a fresh one, so it
+    // joins the transient bucket rather than reading as a permanent denial.
+    if (status === 401 && response.authenticationRetrySkipped) {
+        return 'REQUEST_FAILED';
+    }
+    // A 401 on a transport that never minted anything proves nothing about
+    // permission: the host's credential expired, and signing in again is the
+    // only recovery. ACCESS_DENIED is the one code that tells a user not to try.
+    if (status === 401 && response.authenticationNotRenewable) {
+        return 'NOT_AUTHENTICATED';
+    }
+    if (status === 401 || status === 403)
+        return 'ACCESS_DENIED';
+    if (status === 404)
+        return 'NOT_FOUND';
+    if (status === 409)
+        return 'CONFLICT';
+    // 5xx joins the transient bucket with the network failures the transport
+    // already reports there: one retryable failure for a caller, not several.
+    return 'REQUEST_FAILED';
+}

package/dist/core/billing/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The billing half of the account layer: framework-free by construction, so
+ * the composables and components that present this state live in their own
+ * view package rather than here.
+ *
+ * This entry carries the host ports, the session-backed transport, and the
+ * read path over it. The payment commands and their state machine land on
+ * top of these same contracts.
+ */
+export type { BillingErrorCode, BillingFailure, BillingHttpResponse, BillingRequest, BillingResult, BillingServerCode, BillingSession, BillingTransport } from './billingContracts.js';
+export { matchesServerCode, unwrapServerCode } from './billingContracts.js';
+export type { SessionBillingTransportOptions } from './transport.js';
+export { createSessionBillingTransport } from './transport.js';
+export type { CredentialedBillingTransportOptions } from './credentialedTransport.js';
+export { createCredentialedBillingTransport } from './credentialedTransport.js';
+export type { BillingScope, BillingScopeSource } from './billingScope.js';
+export { sessionBillingScopeSource } from './billingScope.js';
+export type { BillingCapabilities, CapabilitiesReadOptions, CapabilitiesReader, CapabilitiesReaderOptions, CapabilitiesSnapshot, CapabilityRolloutDefaults, CapabilityScope } from './capabilities.js';
+export { CAPABILITIES_ROUTE, CAPABILITY_REVISION_HEADER, createCapabilitiesReader, readCapabilityRevision } from './capabilities.js';
+export type { CapabilityDenialReason, CapabilityDenials } from './capabilityDenials.js';
+export { decodeCapabilityDenials } from './capabilityDenials.js';
+export type { BillingBalance, CreditsReadOptions, CreditsReader, CreditsReaderOptions, CreditsScope, CreditsSnapshot } from './credits.js';
+export { CREDITS_ROUTE, createCreditsReader } from './credits.js';
+export type { BillingPlansData, PlansReadOptions, PlansReader, PlansReaderOptions, PlansScope, PlansSnapshot } from './plans.js';
+export { PLANS_ROUTE, createPlansReader } from './plans.js';
+export type { PaymentMethodsReadOptions, PaymentMethodsReader, PaymentMethodsReaderOptions, PaymentMethodsScope, PaymentMethodsSnapshot, SavedPaymentMethod } from './paymentMethods.js';
+export { PAYMENT_METHODS_ROUTE, createPaymentMethodsReader } from './paymentMethods.js';
+export type { BillingStatusData, BillingStatusReader, BillingStatusReaderOptions, BillingStatusReadOptions, BillingStatusScope, BillingStatusSnapshot } from './status.js';
+export { BILLING_STATUS_ROUTE, createBillingStatusReader } from './status.js';
+export type { BillingAuthenticationState, BillingDeclineReason, BillingOpStatus, BillingOperationEvent, BillingOperationIdentity, BillingOperationKind, BillingOperationPhase, BillingOperationServerPhase, BillingOperationState, BillingPresentation, BillingPresentationState, BillingRecoveryAction, EmbeddedChallenge, FailedBillingOperation, HostedBillingDestination, PendingBillingOperation } from './operationState.js';
+export { isBlockedOnCustomerPhase, isTerminal, reduceBillingOperation, validateActionUrl } from './operationState.js';
+export { OPERATION_POLL_BUDGET, OPERATION_POLL_TIMING, hasExhaustedPollBudget, isParkedOnCustomer, nextPollDelayMs, pollBudgetMs } from './operationPolicy.js';
+export type { BillingOperationPointer, BillingOperationPointerStorage, OperationPointerStore } from './operationPointer.js';
+export { OPERATION_POINTER_MAX_AGE_MS, createOperationPointerStore, operationPointerKey } from './operationPointer.js';
+export type { PresentationRoutingInput } from './presentation.js';
+export { selectBillingPresentation } from './presentation.js';
+export type { BillingOperationFailureCategory, BillingOperationLifecycle, BillingOperationLifecycleOptions, BillingOperationTelemetryEvent, IssuedBillingOperation, PresentationSwitchOutcome } from './operationLifecycle.js';
+export { createBillingOperationLifecycle, operationRoute } from './operationLifecycle.js';
+export { BILLING_OPERATION_TELEMETRY_EVENT } from '../../telemetry.js';
+export type { EmbeddedChallengeOutcome, EmbeddedChallengePort } from './challengeDriver.js';
+export { driveEmbeddedChallenge } from './challengeDriver.js';
+export { readBillingErrorCode } from './billingErrorBody.js';
+export type { BillingCommands, BillingCommandsOptions, PaymentPortalResult, PreviewSubscribeInput, PreviewSubscribeOptions, PreviewSubscribeResult, SubscribeInput, SubscriptionCommandCode, SubscriptionCommandFailure, SubscriptionCommandOutcome, SubscriptionCommandResult, SubscriptionPreview, TerminalBillingOperation } from './subscriptionCommands.js';
+export { CANCEL_SUBSCRIPTION_ROUTE, PAYMENT_PORTAL_ROUTE, PREVIEW_SUBSCRIBE_ROUTE, RESUBSCRIBE_ROUTE, SUBSCRIBE_ROUTE, createBillingCommands } from './subscriptionCommands.js';
+export type { HostPaymentStep, PaymentProjection, PaymentReasonKey, PaymentStep } from './paymentProjection.js';
+export { projectPaymentStep } from './paymentProjection.js';
+export type { PaymentCopyKey, PaymentCopyKeys } from './paymentCopy.js';
+export { DEFAULT_PAYMENT_COPY, createPaymentCopy, paymentCopyKeys } from './paymentCopy.js';
+export type { CreateHostedTopupCheckoutInput, CreateTopupCheckoutInput, HostedTopupCheckout, HostedTopupCheckoutFailure, HostedTopupCheckoutResult, TopupCommand, TopupCommandOptions, TopupDeclined, TopupDenied, TopupFailure, TopupInvalidAmount, TopupInvalidReturnUrl, TopupNoPaymentMethod, TopupNotAvailable, TopupResult, TopupSucceeded, TopupUnsettled } from './topup.js';
+export { TOPUP_CHECKOUT_ROUTE, TOPUP_ROUTE, createTopupCommand } from './topup.js';
+export type { BalanceWatch, BalanceWatchOptions, BalanceWatchOutcome } from './balanceWatch.js';
+export { BALANCE_WATCH_LIFETIME_MS, BALANCE_WATCH_MAX_SCHEDULED_RUNS, BALANCE_WATCH_RETRY_GAPS_MS, createBalanceWatch } from './balanceWatch.js';

package/dist/core/billing/index.js

@@ -0,0 +1,23 @@
+export { matchesServerCode, unwrapServerCode } from './billingContracts.js';
+export { createSessionBillingTransport } from './transport.js';
+export { createCredentialedBillingTransport } from './credentialedTransport.js';
+export { sessionBillingScopeSource } from './billingScope.js';
+export { CAPABILITIES_ROUTE, CAPABILITY_REVISION_HEADER, createCapabilitiesReader, readCapabilityRevision } from './capabilities.js';
+export { decodeCapabilityDenials } from './capabilityDenials.js';
+export { CREDITS_ROUTE, createCreditsReader } from './credits.js';
+export { PLANS_ROUTE, createPlansReader } from './plans.js';
+export { PAYMENT_METHODS_ROUTE, createPaymentMethodsReader } from './paymentMethods.js';
+export { BILLING_STATUS_ROUTE, createBillingStatusReader } from './status.js';
+export { isBlockedOnCustomerPhase, isTerminal, reduceBillingOperation, validateActionUrl } from './operationState.js';
+export { OPERATION_POLL_BUDGET, OPERATION_POLL_TIMING, hasExhaustedPollBudget, isParkedOnCustomer, nextPollDelayMs, pollBudgetMs } from './operationPolicy.js';
+export { OPERATION_POINTER_MAX_AGE_MS, createOperationPointerStore, operationPointerKey } from './operationPointer.js';
+export { selectBillingPresentation } from './presentation.js';
+export { createBillingOperationLifecycle, operationRoute } from './operationLifecycle.js';
+export { BILLING_OPERATION_TELEMETRY_EVENT } from '../../telemetry.js';
+export { driveEmbeddedChallenge } from './challengeDriver.js';
+export { readBillingErrorCode } from './billingErrorBody.js';
+export { CANCEL_SUBSCRIPTION_ROUTE, PAYMENT_PORTAL_ROUTE, PREVIEW_SUBSCRIBE_ROUTE, RESUBSCRIBE_ROUTE, SUBSCRIBE_ROUTE, createBillingCommands } from './subscriptionCommands.js';
+export { projectPaymentStep } from './paymentProjection.js';
+export { DEFAULT_PAYMENT_COPY, createPaymentCopy, paymentCopyKeys } from './paymentCopy.js';
+export { TOPUP_CHECKOUT_ROUTE, TOPUP_ROUTE, createTopupCommand } from './topup.js';
+export { BALANCE_WATCH_LIFETIME_MS, BALANCE_WATCH_MAX_SCHEDULED_RUNS, BALANCE_WATCH_RETRY_GAPS_MS, createBalanceWatch } from './balanceWatch.js';

package/dist/core/billing/operationLifecycle.d.ts

@@ -0,0 +1,77 @@
+import { BILLING_OPERATION_TELEMETRY_EVENT } from '../../telemetry.js';
+import type { BillingResult, BillingTransport } from './billingContracts.js';
+import type { BillingScope, BillingScopeSource } from './billingScope.js';
+import type { BillingOperationPointerStorage } from './operationPointer.js';
+import type { BillingDeclineReason, BillingOperationKind, BillingOperationState, BillingPresentation, HostedBillingDestination } from './operationState.js';
+import type { BillingStatusReader } from './status.js';
+export declare function operationRoute(operationId: string): string;
+/** What a command learned from the backend when it issued the operation. */
+export interface IssuedBillingOperation {
+    readonly operationId: string;
+    /** A hosted continuation the response already carried (`payment_method_url`, `action_url`). */
+    readonly actionUrl?: string;
+    /** An in-page challenge the response already carried. */
+    readonly clientSecret?: string;
+}
+export type BillingOperationFailureCategory = 'provider_decline' | 'api_rejected' | 'poll_timeout' | 'reconciliation_needed' | 'stale_operation';
+export interface BillingOperationTelemetryEvent {
+    readonly name: (typeof BILLING_OPERATION_TELEMETRY_EVENT)[keyof typeof BILLING_OPERATION_TELEMETRY_EVENT];
+    readonly billing_op_id: string;
+    readonly operation_type: BillingOperationKind;
+    readonly presentation: BillingPresentation;
+    /** True when this tab reattached to an operation it did not issue. */
+    readonly resumed: boolean;
+    readonly failure_category?: BillingOperationFailureCategory;
+    readonly decline_reason?: BillingDeclineReason;
+    /** From the attempt's start, so a resumed operation reports its whole life. */
+    readonly duration_ms?: number;
+}
+export type PresentationSwitchOutcome = 'switched' | 'unchanged'
+/** The server has offered no hosted continuation yet. */
+ | 'no_hosted_url'
+/** The host cannot drive a challenge, or none has been issued for this operation. */
+ | 'embedded_unavailable' | 'not_pending' | 'unknown_operation';
+export interface BillingOperationLifecycleOptions {
+    readonly transport: BillingTransport;
+    /** Where the core learns which user, workspace, and role it runs as. */
+    readonly scopeSource: BillingScopeSource;
+    /** The Phase 2 status reader; consulted before every start and recovery. */
+    readonly statusReader: BillingStatusReader;
+    /** Tab-local storage for the operation pointer; absent means nothing survives a reload. */
+    readonly pointerStorage?: BillingOperationPointerStorage;
+    /** Whether the host can drive an in-page challenge right now. Absent routes everything hosted. */
+    readonly embeddedCheckoutAvailable?: () => boolean;
+    /** Which origin serves a hosted page right now. Absent keeps every hosted operation on the provider page. */
+    readonly hostedDestination?: () => HostedBillingDestination;
+    readonly onTelemetry?: (event: BillingOperationTelemetryEvent) => void;
+    readonly now?: () => number;
+}
+export interface BillingOperationLifecycle {
+    /**
+     * Runs a command on the lifecycle: single-flight per kind, the backend's
+     * pending operation adopted instead of a second one issued, and the
+     * issued id observed from the moment it exists. Resolves once the
+     * operation is adopted, not once it settles — see `settled`.
+     */
+    begin: (kind: BillingOperationKind, issue: (scope: BillingScope) => Promise<BillingResult<IssuedBillingOperation>>) => Promise<BillingResult<BillingOperationState>>;
+    /**
+     * Reattaches to whatever this scope is already waiting on: the backend's
+     * pending operation first, then the tab-local pointer. Resolves undefined
+     * when there is nothing to recover.
+     */
+    recover: () => Promise<BillingResult<BillingOperationState | undefined>>;
+    /** The host became visible or focused: poll every pending operation now. */
+    wake: () => void;
+    /** Moves the operation between presentations under the same id. */
+    switchPresentation: (operationId: string, presentation: BillingPresentation) => PresentationSwitchOutcome;
+    /** The host began driving the operation's challenge; polling pauses until it settles. */
+    reportChallengeStarted: (operationId: string) => void;
+    reportChallengeSettled: (operationId: string, outcome: 'completed' | 'failed') => void;
+    get: (operationId: string) => BillingOperationState | undefined;
+    getSnapshot: () => readonly BillingOperationState[];
+    subscribe: (listener: (state: BillingOperationState) => void) => () => void;
+    /** Resolves with the terminal state; undefined for an id this lifecycle never adopted. */
+    settled: (operationId: string) => Promise<BillingOperationState> | undefined;
+    dispose: () => void;
+}
+export declare function createBillingOperationLifecycle(options: BillingOperationLifecycleOptions): BillingOperationLifecycle;