@comfyorg/account-core 1.0.0-alpha.0

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

@@ -0,0 +1,113 @@
+import type { BillingFailure, BillingTransport } from './billingContracts.js';
+import type { CapabilitiesReader } from './capabilities.js';
+import type { CapabilityDenialReason } from './capabilityDenials.js';
+import type { CreditsReader } from './credits.js';
+import type { BillingOperationLifecycle } from './operationLifecycle.js';
+import type { BillingOperationState, FailedBillingOperation } from './operationState.js';
+export declare const TOPUP_ROUTE = "/billing/topup";
+/**
+ * The hosted variant: a provider-hosted Checkout session with no operation to
+ * observe. The purchase happens on the returned page and the credits land
+ * through a webhook, so completion is the host's return plus a balance watch.
+ */
+export declare const TOPUP_CHECKOUT_ROUTE = "/billing/topup/checkout";
+type OperationIn<P extends BillingOperationState['phase']> = Extract<BillingOperationState, {
+    readonly phase: P;
+}>;
+export interface TopupSucceeded {
+    readonly status: 'ok';
+    readonly operation: OperationIn<'succeeded'>;
+    /**
+     * True once the balance read after settlement exceeds the one read before
+     * the command. False is "payment received, credits pending": the purchase
+     * settled and the balance has not caught up, or no baseline was readable.
+     */
+    readonly creditsReconciled: boolean;
+}
+export interface TopupDeclined {
+    readonly status: 'declined';
+    readonly operation: FailedBillingOperation;
+}
+/** The lifecycle stopped observing without a verdict; the id is the host's handle to support. */
+export interface TopupUnsettled {
+    readonly status: 'unsettled';
+    readonly operation: OperationIn<'timed_out' | 'reconciliation_needed'>;
+}
+/** The server resolved `can_top_up` false for this scope; nothing was sent. */
+export interface TopupDenied {
+    readonly status: 'error';
+    readonly code: 'ACCESS_DENIED';
+    readonly denial?: CapabilityDenialReason;
+}
+/** The top-up route is not deployed on this backend. */
+export interface TopupNotAvailable {
+    readonly status: 'error';
+    readonly code: 'NOT_AVAILABLE';
+}
+export interface TopupNoPaymentMethod {
+    readonly status: 'error';
+    readonly code: 'NO_PAYMENT_METHOD';
+    readonly recoveryAction: 'replace_payment_method';
+}
+/** The amount fails the generated request contract; nothing was sent. */
+export interface TopupInvalidAmount {
+    readonly status: 'error';
+    readonly code: 'INVALID_AMOUNT';
+}
+export type TopupFailure = BillingFailure | TopupDenied | TopupNotAvailable | TopupNoPaymentMethod | TopupInvalidAmount;
+export type TopupResult = TopupSucceeded | TopupDeclined | TopupUnsettled | TopupFailure;
+/** The return URL fails the generated request contract; nothing was sent. */
+export interface TopupInvalidReturnUrl {
+    readonly status: 'error';
+    readonly code: 'INVALID_RETURN_URL';
+}
+/**
+ * A hosted Checkout session the host now sends the customer to. There is no
+ * operation and none is invented: the host executes its `OpenUrlMode` on
+ * `url`, and on return arms `createBalanceWatch` with `baselineMicros` to
+ * learn that the credits landed.
+ */
+export interface HostedTopupCheckout {
+    readonly status: 'ok';
+    /** The provider-hosted Checkout page; https only. */
+    readonly url: string;
+    /** The provider's session id, for support and log correlation. */
+    readonly sessionId?: string;
+    /** The balance read before the session was created; absent when that read failed. */
+    readonly baselineMicros?: number;
+}
+export type HostedTopupCheckoutFailure = BillingFailure | TopupDenied | TopupNotAvailable | TopupInvalidAmount | TopupInvalidReturnUrl;
+export type HostedTopupCheckoutResult = HostedTopupCheckout | HostedTopupCheckoutFailure;
+export interface CreateHostedTopupCheckoutInput {
+    readonly amountCents: number;
+    /** Where the provider returns the customer; the backend allowlists its origin. */
+    readonly returnUrl: string;
+    readonly signal?: AbortSignal;
+}
+export interface CreateTopupCheckoutInput {
+    readonly amountCents: number;
+    /**
+     * Releases the capability read and the POST. Once the operation is adopted
+     * the lifecycle owns it, and the wait follows it to a terminal state.
+     */
+    readonly signal?: AbortSignal;
+}
+export interface TopupCommandOptions {
+    readonly transport: BillingTransport;
+    readonly lifecycle: Pick<BillingOperationLifecycle, 'begin' | 'settled'>;
+    readonly capabilities: Pick<CapabilitiesReader, 'read' | 'invalidate'>;
+    readonly credits: Pick<CreditsReader, 'read'>;
+    /** One key per POST attempt: the backend dedupes on it and the transport replays a 401 under it. */
+    readonly idempotencyKey?: () => string;
+}
+export interface TopupCommand {
+    createTopupCheckout: (input: CreateTopupCheckoutInput) => Promise<TopupResult>;
+    /**
+     * The route Workshop and Platform ship on today. Unlike
+     * `createTopupCheckout` it resolves as soon as the session exists, because
+     * nothing about the purchase can be observed until the customer returns.
+     */
+    createHostedTopupCheckout: (input: CreateHostedTopupCheckoutInput) => Promise<HostedTopupCheckoutResult>;
+}
+export declare function createTopupCommand(options: TopupCommandOptions): TopupCommand;
+export {};

package/dist/core/billing/topup.js

@@ -0,0 +1,209 @@
+/**
+ * The top-up command: one credit purchase mapped onto the shared billing
+ * lifecycle. This module owns the request and response shapes and nothing
+ * else — the status-read gate, single-flight, polling, routing, the pointer,
+ * failure meaning, and telemetry all come from the lifecycle it runs on.
+ *
+ * The result is a command-level union rather than an extension of
+ * `BillingErrorCode`: what a top-up can conclude (refused by capability,
+ * declined by the provider, not available on this backend) is the command's
+ * own vocabulary, and the terminal operation is embedded whenever one was
+ * observed so a host reads the coded decline and recovery action from it.
+ */
+import { zCreateTopupCheckoutRequest, zCreateTopupCheckoutResponse, zCreateTopupRequest, zCreateTopupResponse } from '@comfyorg/ingest-types/zod';
+import { matchesServerCode } from './billingContracts.js';
+import { isTerminal, validateActionUrl } from './operationState.js';
+import { readValidatedBillingResponse } from './sharedRead.js';
+export const TOPUP_ROUTE = '/billing/topup';
+/**
+ * The hosted variant: a provider-hosted Checkout session with no operation to
+ * observe. The purchase happens on the returned page and the credits land
+ * through a webhook, so completion is the host's return plus a balance watch.
+ */
+export const TOPUP_CHECKOUT_ROUTE = '/billing/topup/checkout';
+/** The one coded error body this command acts on; every other code stays a `BillingFailure`. */
+const NO_PAYMENT_METHOD_SERVER_CODE = 'NO_PAYMENT_METHOD';
+const INVALID_AMOUNT = {
+    status: 'error',
+    code: 'INVALID_AMOUNT'
+};
+const INVALID_RETURN_URL = {
+    status: 'error',
+    code: 'INVALID_RETURN_URL'
+};
+const NOT_AVAILABLE = {
+    status: 'error',
+    code: 'NOT_AVAILABLE'
+};
+function validateHostedCheckoutInput(input) {
+    const parsed = zCreateTopupCheckoutRequest.safeParse({
+        amount_cents: input.amountCents,
+        return_url: input.returnUrl
+    });
+    if (parsed.success)
+        return undefined;
+    const fields = new Set(parsed.error.issues.map((issue) => issue.path[0]));
+    return fields.has('amount_cents') ? INVALID_AMOUNT : INVALID_RETURN_URL;
+}
+const SUPERSEDED = {
+    status: 'error',
+    code: 'SUPERSEDED'
+};
+function commandFailure(failure) {
+    if (matchesServerCode(failure, NO_PAYMENT_METHOD_SERVER_CODE)) {
+        return {
+            status: 'error',
+            code: 'NO_PAYMENT_METHOD',
+            recoveryAction: 'replace_payment_method'
+        };
+    }
+    if (failure.httpStatus === 404)
+        return NOT_AVAILABLE;
+    return failure;
+}
+export function createTopupCommand(options) {
+    const { transport, lifecycle, capabilities, credits, idempotencyKey = () => crypto.randomUUID() } = options;
+    async function issue(amountCents, signal) {
+        // The schema coerces `amount_cents` to a bigint, which the transport
+        // could not serialize; the validated input is what travels, not the
+        // parsed output.
+        const body = {
+            amount_cents: amountCents,
+            idempotency_key: idempotencyKey()
+        };
+        const response = await readValidatedBillingResponse(transport, {
+            method: 'POST',
+            route: TOPUP_ROUTE,
+            body,
+            idempotencyKey: body.idempotency_key,
+            ...(signal === undefined ? {} : { signal })
+        }, (raw) => zCreateTopupResponse.safeParse(raw));
+        if (response.status === 'error')
+            return response;
+        // Adopted regardless of the response's own `status`: the first poll
+        // settles a synchronous result and carries the decline reason, which the
+        // POST response does not.
+        return {
+            status: 'ok',
+            value: { operationId: response.value.data.billing_op_id }
+        };
+    }
+    async function conclude(operation, baselineMicros) {
+        if (!isTerminal(operation))
+            return SUPERSEDED;
+        switch (operation.phase) {
+            case 'succeeded': {
+                capabilities.invalidate();
+                const after = await credits.read();
+                return {
+                    status: 'ok',
+                    operation,
+                    creditsReconciled: baselineMicros !== undefined &&
+                        after.status === 'ok' &&
+                        after.value.balance.amount_micros > baselineMicros
+                };
+            }
+            case 'failed':
+                return { status: 'declined', operation };
+            case 'timed_out':
+            case 'reconciliation_needed':
+                return { status: 'unsettled', operation };
+            case 'superseded':
+                return SUPERSEDED;
+        }
+    }
+    async function readTopupEligibility(signal) {
+        const allowed = await capabilities.read(signal === undefined ? {} : { signal });
+        if (allowed.status === 'error')
+            return allowed;
+        if (allowed.value.capabilities.can_top_up)
+            return undefined;
+        const denial = allowed.value.denials.can_top_up;
+        return {
+            status: 'error',
+            code: 'ACCESS_DENIED',
+            ...(denial === undefined ? {} : { denial })
+        };
+    }
+    async function createTopupCheckout(input) {
+        const { amountCents, signal } = input;
+        if (!zCreateTopupRequest.safeParse({ amount_cents: amountCents }).success) {
+            return INVALID_AMOUNT;
+        }
+        const refused = await readTopupEligibility(signal);
+        if (refused)
+            return refused;
+        const baseline = await credits.read();
+        const baselineMicros = baseline.status === 'ok'
+            ? baseline.value.balance.amount_micros
+            : undefined;
+        // `begin` reports every failure as a `BillingFailure`; the command-level
+        // meaning of its own POST failure is kept here so a status-read failure
+        // is never mistaken for one.
+        let issueFailure;
+        const began = await lifecycle.begin('topup', async () => {
+            const issued = await issue(amountCents, signal);
+            if (issued.status === 'error')
+                issueFailure = commandFailure(issued);
+            return issued;
+        });
+        if (began.status === 'error')
+            return issueFailure ?? began;
+        const settled = lifecycle.settled(began.value.id);
+        if (settled === undefined)
+            return SUPERSEDED;
+        return conclude(await settled, baselineMicros);
+    }
+    async function issueHostedCheckout(input) {
+        const body = {
+            amount_cents: input.amountCents,
+            return_url: input.returnUrl,
+            idempotency_key: idempotencyKey()
+        };
+        const response = await readValidatedBillingResponse(transport, {
+            method: 'POST',
+            route: TOPUP_CHECKOUT_ROUTE,
+            body,
+            idempotencyKey: body.idempotency_key,
+            ...(input.signal === undefined ? {} : { signal: input.signal })
+        }, (raw) => zCreateTopupCheckoutResponse.safeParse(raw));
+        if (response.status === 'error')
+            return response;
+        // The generated contract only requires a URL; the page a host will open
+        // on the customer's behalf has to be https as well, like every
+        // continuation the lifecycle hands out.
+        const { data, httpStatus } = response.value;
+        const url = validateActionUrl(data.checkout_url);
+        if (url === undefined) {
+            return { status: 'error', code: 'MALFORMED_RESPONSE', httpStatus };
+        }
+        return {
+            status: 'ok',
+            value: {
+                url,
+                ...(data.session_id === undefined ? {} : { sessionId: data.session_id })
+            }
+        };
+    }
+    async function createHostedTopupCheckout(input) {
+        const invalid = validateHostedCheckoutInput(input);
+        if (invalid)
+            return invalid;
+        const refused = await readTopupEligibility(input.signal);
+        if (refused)
+            return refused;
+        const baseline = await credits.read();
+        const session = await issueHostedCheckout(input);
+        if (session.status === 'error') {
+            return session.httpStatus === 404 ? NOT_AVAILABLE : session;
+        }
+        return {
+            status: 'ok',
+            ...session.value,
+            ...(baseline.status === 'ok'
+                ? { baselineMicros: baseline.value.balance.amount_micros }
+                : {})
+        };
+    }
+    return { createTopupCheckout, createHostedTopupCheckout };
+}

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

@@ -0,0 +1,14 @@
+import type { BillingSession, BillingTransport } from './billingContracts.js';
+export interface SessionBillingTransportOptions {
+    readonly session: BillingSession;
+    /**
+     * Resolves a route to an absolute URL. The cloud app's own resolver
+     * (`workspaceApiUrl`) differs per distribution, so the host owns it.
+     */
+    readonly resolveUrl: (route: string) => string;
+    /** The workspace to mint for; absent resolves the personal workspace. */
+    readonly workspaceId?: () => string | undefined;
+    readonly fetchImpl?: typeof fetch;
+    readonly defaultTimeoutMs?: number;
+}
+export declare function createSessionBillingTransport(options: SessionBillingTransportOptions): BillingTransport;

package/dist/core/billing/transport.js

@@ -0,0 +1,106 @@
+import { DEFAULT_BILLING_TIMEOUT_MS, exchangeBillingRequest, startRequestBudget } from './transportExchange.js';
+function codeForSessionFailure(code) {
+    if (code === 'ACCESS_DENIED')
+        return 'ACCESS_DENIED';
+    if (code === 'WORKSPACE_NOT_FOUND')
+        return 'NOT_FOUND';
+    if (code === 'NOT_AUTHENTICATED' || code === 'INVALID_FIREBASE_TOKEN') {
+        return 'NOT_AUTHENTICATED';
+    }
+    return 'REQUEST_FAILED';
+}
+function billingFailureForSession(failure) {
+    return {
+        status: 'error',
+        code: codeForSessionFailure(failure.code),
+        ...(failure.httpStatus === undefined
+            ? {}
+            : { httpStatus: failure.httpStatus })
+    };
+}
+export function createSessionBillingTransport(options) {
+    const { session, resolveUrl, workspaceId, fetchImpl = fetch, defaultTimeoutMs = DEFAULT_BILLING_TIMEOUT_MS } = options;
+    /**
+     * The identity and workspace a response is allowed to be attributed to.
+     * A snapshot still minting or not yet settled is no evidence of a change,
+     * so only a delivered sign-out or a different uid or workspace supersedes.
+     */
+    const superseded = (uid, workspace) => {
+        const snapshot = session.getSnapshot();
+        if (snapshot.phase === 'signed-out')
+            return true;
+        if (snapshot.user !== null && snapshot.user.uid !== uid)
+            return true;
+        return (snapshot.session !== undefined &&
+            snapshot.session.workspace.id !== workspace);
+    };
+    async function ensureBillingSession(mintOptions) {
+        const minted = await session.ensureFresh(undefined, mintOptions);
+        if (minted === undefined) {
+            return { status: 'error', code: 'NOT_AUTHENTICATED' };
+        }
+        if (minted.status === 'error')
+            return billingFailureForSession(minted);
+        return { status: 'ok', value: minted.session };
+    }
+    function send(request, token, signal) {
+        return exchangeBillingRequest(request, {
+            fetchImpl,
+            url: resolveUrl(request.route),
+            signal,
+            headers: { Authorization: `Bearer ${token}` }
+        });
+    }
+    async function retryUnauthorized(request, response, mintOptions, expectedUid, expectedWorkspace) {
+        if (response.httpStatus !== 401)
+            return { status: 'ok', value: response };
+        const replayable = request.method === 'GET' || request.idempotencyKey !== undefined;
+        if (!replayable) {
+            return {
+                status: 'ok',
+                value: { ...response, authenticationRetrySkipped: true }
+            };
+        }
+        const reminted = await session.remint(undefined, mintOptions);
+        if (reminted?.status !== 'ok')
+            return { status: 'ok', value: response };
+        if (reminted.session.uid !== expectedUid ||
+            reminted.session.workspace.id !== expectedWorkspace) {
+            return { status: 'error', code: 'SUPERSEDED' };
+        }
+        return send(request, reminted.session.token, mintOptions.signal);
+    }
+    return async function transport(request) {
+        const timeoutMs = request.timeoutMs ?? defaultTimeoutMs;
+        const budget = startRequestBudget(request.signal, timeoutMs);
+        const target = workspaceId?.();
+        const mintOptions = {
+            signal: budget.signal,
+            timeoutMs,
+            ...(target === undefined ? {} : { workspaceId: target })
+        };
+        try {
+            const minted = await ensureBillingSession(mintOptions);
+            if (minted.status === 'error')
+                return minted;
+            const { uid } = minted.value;
+            const workspace = minted.value.workspace.id;
+            const firstAttempt = await send(request, minted.value.token, budget.signal);
+            if (firstAttempt.status === 'error')
+                return firstAttempt;
+            const finalAttempt = await retryUnauthorized(request, firstAttempt.value, mintOptions, uid, workspace);
+            if (finalAttempt.status === 'error')
+                return finalAttempt;
+            if (superseded(uid, workspace)) {
+                return { status: 'error', code: 'SUPERSEDED' };
+            }
+            return finalAttempt;
+        }
+        catch {
+            return { status: 'error', code: 'REQUEST_FAILED' };
+        }
+        finally {
+            budget.close();
+        }
+    };
+}

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

@@ -0,0 +1,24 @@
+/**
+ * What every billing transport does identically, regardless of how the
+ * request is credentialed: hold one timeout budget over the whole exchange,
+ * send the request, and shape any answer into a `BillingHttpResponse`.
+ *
+ * Only the credential differs between transports, so only the credential
+ * lives in them; keeping the budget and the response shaping here is what
+ * lets a bearer-token host and a cookie host report the same failures.
+ */
+import type { BillingHttpResponse, BillingRequest, BillingResult } from './billingContracts.js';
+export declare const DEFAULT_BILLING_TIMEOUT_MS = 30000;
+export declare function startRequestBudget(callerSignal: AbortSignal | undefined, timeoutMs: number): {
+    signal: AbortSignal;
+    close: () => void;
+};
+export interface BillingExchange {
+    readonly fetchImpl: typeof fetch;
+    readonly url: string;
+    readonly signal: AbortSignal;
+    /** Merged over the headers the request itself implies. */
+    readonly headers?: Record<string, string>;
+    readonly credentials?: RequestCredentials;
+}
+export declare function exchangeBillingRequest(request: BillingRequest, exchange: BillingExchange): Promise<BillingResult<BillingHttpResponse>>;

package/dist/core/billing/transportExchange.js

@@ -0,0 +1,79 @@
+export const DEFAULT_BILLING_TIMEOUT_MS = 30_000;
+export function startRequestBudget(callerSignal, timeoutMs) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    if (callerSignal?.aborted === true) {
+        controller.abort();
+    }
+    else {
+        callerSignal?.addEventListener('abort', abort, { once: true });
+    }
+    const timeout = setTimeout(abort, timeoutMs);
+    return {
+        signal: controller.signal,
+        close: () => {
+            clearTimeout(timeout);
+            callerSignal?.removeEventListener('abort', abort);
+        }
+    };
+}
+export async function exchangeBillingRequest(request, exchange) {
+    // Called detached: the browser's fetch refuses any receiver but its global.
+    const { fetchImpl, url, signal, headers, credentials } = exchange;
+    let response;
+    try {
+        response = await fetchImpl(url, {
+            method: request.method,
+            headers: {
+                'Content-Type': 'application/json',
+                ...(request.idempotencyKey === undefined
+                    ? {}
+                    : { 'Idempotency-Key': request.idempotencyKey }),
+                ...headers
+            },
+            ...(request.method === 'GET' || request.body === undefined
+                ? {}
+                : { body: JSON.stringify(request.body) }),
+            ...(credentials === undefined ? {} : { credentials }),
+            signal
+        });
+    }
+    catch {
+        return { status: 'error', code: 'REQUEST_FAILED' };
+    }
+    return shapeResponse(response, signal);
+}
+async function shapeResponse(response, signal) {
+    const header = (name) => response.headers.get(name);
+    try {
+        return {
+            status: 'ok',
+            value: {
+                httpStatus: response.status,
+                body: await readBody(response),
+                header
+            }
+        };
+    }
+    catch {
+        if (signal.aborted) {
+            return { status: 'error', code: 'REQUEST_FAILED' };
+        }
+        return {
+            status: 'ok',
+            value: { httpStatus: response.status, body: undefined, header }
+        };
+    }
+}
+/** A body that is absent, empty, or not JSON reaches callers as undefined. */
+async function readBody(response) {
+    const text = await response.text();
+    if (text === '')
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/core/boundedOperation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A monotonic owner for work that outlives an await: each `capture()` snapshots
+ * the current generation and returns a handle whose `live()` stays true until
+ * `abandon()` bumps the generation. A flag flip, a reset, or teardown calls
+ * `abandon()`; the in-flight work re-checks `live()` after every await and drops
+ * its result once superseded, so a stale sign-in, mint, or fetch can never
+ * publish for an attempt that no longer owns the outcome.
+ */
+export interface OperationHandle {
+    live: () => boolean;
+}
+export interface BoundedOperation {
+    capture: () => OperationHandle;
+    abandon: () => void;
+}
+export declare function createBoundedOperation(): BoundedOperation;

package/dist/core/boundedOperation.js

@@ -0,0 +1,12 @@
+export function createBoundedOperation() {
+    let generation = 0;
+    return {
+        capture() {
+            const captured = generation;
+            return { live: () => captured === generation };
+        },
+        abandon() {
+            generation += 1;
+        }
+    };
+}

package/dist/core/credentialCache.d.ts

@@ -0,0 +1,41 @@
+import type { AccountCredential } from './sessionContracts.js';
+/**
+ * Raw string storage for the credential cache. Hosts wrap their medium —
+ * per-tab browser storage today, a cookie-backed session tomorrow. Each client
+ * instance sees only its own storage: signing out in one tab leaves another
+ * tab's session live until the server revokes it and the next remint 401s.
+ */
+export interface CredentialStorage {
+    read: () => string | null;
+    write: (value: string) => void;
+    clear: () => void;
+}
+interface CachedCredential {
+    readonly credential: AccountCredential;
+    readonly target: string | undefined;
+}
+export declare function encodeCached(session: AccountCredential, target: string | undefined): string;
+export declare function decodeCached(raw: string, uid: string): CachedCredential | undefined;
+export declare function decodeAdopted(message: unknown): AccountCredential | undefined;
+interface CredentialCache {
+    read: (uid: string) => CachedCredential | undefined;
+    write: (session: AccountCredential, target: string | undefined) => void;
+    clear: () => void;
+}
+export declare const DEFAULT_FRESH_MARGIN_MS: number;
+export declare function isCredentialFresh(session: AccountCredential, now: number, freshMarginMs?: number): boolean;
+interface CredentialCandidate {
+    readonly credential: AccountCredential | undefined;
+    readonly target: string | undefined;
+}
+/**
+ * The live credential is authoritative; storage is recovery state, not a
+ * competing source. Candidates are consulted in the order given (memory
+ * first, then storage) for this exact uid and target, and the first fresh one
+ * wins — expiry must not override this (a rejected token can outlive its
+ * shorter-lived replacement), and a target-less read must never adopt a team
+ * session.
+ */
+export declare function selectFreshCredential(candidates: readonly (() => CredentialCandidate | undefined)[], uid: string, target: string | undefined, now: number, freshMarginMs: number): AccountCredential | undefined;
+export declare function createCredentialCache(storage: CredentialStorage): CredentialCache;
+export {};