@schematichq/schematic-vue 1.5.0 → 1.7.0

package/dist/schematic-vue.d.ts

@@ -1,9 +1,246 @@
 import { App } from 'vue';
 import { ComputedRef } from 'vue';
+import { MaybeRefOrGetter } from 'vue';
 import { Ref } from 'vue';
 
+declare type AccessToken = string | AccessTokenProvider;
+
+/**
+ * The machinery every temporary-access-token surface shares: which session is
+ * being read, the credential for it, and the request that carries it. It
+ * knows nothing about invoices, subscriptions, or checkout — a domain client
+ * (see `SchematicBillingClient`) is constructed over it, and several may
+ * share one session rather than each minting tokens of its own.
+ */
+/** Called once per session, and again when a request comes back 401. */
+declare type AccessTokenProvider = () => Promise<string | AccessTokenResult>;
+
+/**
+ * A bare token, or one that says when it expires and who it was minted for.
+ * `company`/`user` are the host restating the pair it asked for; stated, they
+ * are checked against the session the resolution was started for.
+ */
+declare interface AccessTokenResult {
+    token: string;
+    expiresAt?: Date | string | null;
+    company?: string;
+    user?: string;
+}
+
 declare type BaseSchematicPluginOptions = Omit<SchematicJS.SchematicOptions, "client" | "publishableKey">;
 
+declare namespace billingApi {
+    export {
+        instanceOfApiError,
+        ApiErrorFromJSON,
+        ApiErrorFromJSONTyped,
+        ApiErrorToJSON,
+        ApiErrorToJSONTyped,
+        ApiError,
+        instanceOfBillingProviderType,
+        BillingProviderTypeFromJSON,
+        BillingProviderTypeFromJSONTyped,
+        BillingProviderTypeToJSON,
+        BillingProviderTypeToJSONTyped,
+        BillingProviderType,
+        instanceOfCompanyDiscountResponseData,
+        CompanyDiscountResponseDataFromJSON,
+        CompanyDiscountResponseDataFromJSONTyped,
+        CompanyDiscountResponseDataToJSON,
+        CompanyDiscountResponseDataToJSONTyped,
+        CompanyDiscountResponseData,
+        instanceOfCompanyInvoiceResponseData,
+        CompanyInvoiceResponseDataFromJSON,
+        CompanyInvoiceResponseDataFromJSONTyped,
+        CompanyInvoiceResponseDataToJSON,
+        CompanyInvoiceResponseDataToJSONTyped,
+        CompanyInvoiceResponseData,
+        instanceOfCompanyInvoicesResponseData,
+        CompanyInvoicesResponseDataFromJSON,
+        CompanyInvoicesResponseDataFromJSONTyped,
+        CompanyInvoicesResponseDataToJSON,
+        CompanyInvoicesResponseDataToJSONTyped,
+        CompanyInvoicesResponseData,
+        instanceOfCompanyPaymentMethodResponseData,
+        CompanyPaymentMethodResponseDataFromJSON,
+        CompanyPaymentMethodResponseDataFromJSONTyped,
+        CompanyPaymentMethodResponseDataToJSON,
+        CompanyPaymentMethodResponseDataToJSONTyped,
+        CompanyPaymentMethodResponseData,
+        instanceOfCompanyPaymentMethodsResponseData,
+        CompanyPaymentMethodsResponseDataFromJSON,
+        CompanyPaymentMethodsResponseDataFromJSONTyped,
+        CompanyPaymentMethodsResponseDataToJSON,
+        CompanyPaymentMethodsResponseDataToJSONTyped,
+        CompanyPaymentMethodsResponseData,
+        instanceOfCompanyUpcomingInvoiceResponseData,
+        CompanyUpcomingInvoiceResponseDataFromJSON,
+        CompanyUpcomingInvoiceResponseDataFromJSONTyped,
+        CompanyUpcomingInvoiceResponseDataToJSON,
+        CompanyUpcomingInvoiceResponseDataToJSONTyped,
+        CompanyUpcomingInvoiceResponseData,
+        instanceOfCreateSetupIntentResponse,
+        CreateSetupIntentResponseFromJSON,
+        CreateSetupIntentResponseFromJSONTyped,
+        CreateSetupIntentResponseToJSON,
+        CreateSetupIntentResponseToJSONTyped,
+        CreateSetupIntentResponse,
+        instanceOfDeletePaymentMethodResponse,
+        DeletePaymentMethodResponseFromJSON,
+        DeletePaymentMethodResponseFromJSONTyped,
+        DeletePaymentMethodResponseToJSON,
+        DeletePaymentMethodResponseToJSONTyped,
+        DeletePaymentMethodResponse,
+        instanceOfDeleteResponse,
+        DeleteResponseFromJSON,
+        DeleteResponseFromJSONTyped,
+        DeleteResponseToJSON,
+        DeleteResponseToJSONTyped,
+        DeleteResponse,
+        instanceOfGetCompanyInvoicesParams,
+        GetCompanyInvoicesParamsFromJSON,
+        GetCompanyInvoicesParamsFromJSONTyped,
+        GetCompanyInvoicesParamsToJSON,
+        GetCompanyInvoicesParamsToJSONTyped,
+        GetCompanyInvoicesParams,
+        instanceOfGetCompanyInvoicesResponse,
+        GetCompanyInvoicesResponseFromJSON,
+        GetCompanyInvoicesResponseFromJSONTyped,
+        GetCompanyInvoicesResponseToJSON,
+        GetCompanyInvoicesResponseToJSONTyped,
+        GetCompanyInvoicesResponse,
+        instanceOfGetCompanyPaymentMethodsResponse,
+        GetCompanyPaymentMethodsResponseFromJSON,
+        GetCompanyPaymentMethodsResponseFromJSONTyped,
+        GetCompanyPaymentMethodsResponseToJSON,
+        GetCompanyPaymentMethodsResponseToJSONTyped,
+        GetCompanyPaymentMethodsResponse,
+        instanceOfGetCompanyUpcomingInvoiceResponse,
+        GetCompanyUpcomingInvoiceResponseFromJSON,
+        GetCompanyUpcomingInvoiceResponseFromJSONTyped,
+        GetCompanyUpcomingInvoiceResponseToJSON,
+        GetCompanyUpcomingInvoiceResponseToJSONTyped,
+        GetCompanyUpcomingInvoiceResponse,
+        instanceOfInvoiceStatus,
+        InvoiceStatusFromJSON,
+        InvoiceStatusFromJSONTyped,
+        InvoiceStatusToJSON,
+        InvoiceStatusToJSONTyped,
+        InvoiceStatus,
+        instanceOfPaymentMethodResponseData,
+        PaymentMethodResponseDataFromJSON,
+        PaymentMethodResponseDataFromJSONTyped,
+        PaymentMethodResponseDataToJSON,
+        PaymentMethodResponseDataToJSONTyped,
+        PaymentMethodResponseData,
+        instanceOfSetupIntentResponseData,
+        SetupIntentResponseDataFromJSON,
+        SetupIntentResponseDataFromJSONTyped,
+        SetupIntentResponseDataToJSON,
+        SetupIntentResponseDataToJSONTyped,
+        SetupIntentResponseData,
+        instanceOfUpdatePaymentMethodRequestBody,
+        UpdatePaymentMethodRequestBodyFromJSON,
+        UpdatePaymentMethodRequestBodyFromJSONTyped,
+        UpdatePaymentMethodRequestBodyToJSON,
+        UpdatePaymentMethodRequestBodyToJSONTyped,
+        UpdatePaymentMethodRequestBody,
+        instanceOfUpdatePaymentMethodResponse,
+        UpdatePaymentMethodResponseFromJSON,
+        UpdatePaymentMethodResponseFromJSONTyped,
+        UpdatePaymentMethodResponseToJSON,
+        UpdatePaymentMethodResponseToJSONTyped,
+        UpdatePaymentMethodResponse
+    }
+}
+
+/**
+ * What a reader of billing data can ask for, and the few writes beside it.
+ * Subscription and usage — the rest of what `hydrate` serves — and the
+ * checkout calls that change them join this interface as their endpoints
+ * ship.
+ */
+declare interface BillingClient {
+    fetchInvoices(params: InvoicesRequest): Promise<InvoicesResult>;
+    /** `null` when the company has no next bill. */
+    fetchUpcomingInvoice(): Promise<UpcomingInvoice | null>;
+    /** Empty when the company has no method on file. */
+    fetchPaymentMethods(): Promise<PaymentMethod[]>;
+    /** What a provider's card form is mounted with to add a method. */
+    createSetupIntent(): Promise<SetupIntent>;
+    /** Makes the method the default, by the provider's id (`externalId`). */
+    updatePaymentMethod(externalId: string): Promise<void>;
+    /** Removes the method, by Schematic's id (`id`). */
+    deletePaymentMethod(id: string): Promise<void>;
+    readonly sessionStatus: SessionStatus;
+    readonly sessionKey: string | undefined;
+    setSession(session: SessionInput): void;
+    onSessionChange(listener: (event: SessionEvent) => void): () => void;
+}
+
+declare type BillingClientOptions = SessionOptions;
+
+/**
+ * A prefetch or fixture. An omitted key reports as pending; a keyed resource
+ * seeds under `params`, or its defaults when absent, so a prefetch for a
+ * non-default query is claimed rather than refetched by the element.
+ */
+declare type BillingData = {
+    [K in BillingResourceName]?: BillingResources[K];
+} & {
+    params?: Partial<BillingResourceParams>;
+    /**
+     * A prefetch outlives the render that made it — a cached page, a session
+     * resolving to somebody else — so a store adopts it only for the session
+     * it names. `fetchBillingData` fills it in; a fixture need not.
+     */
+    sessionKey?: string;
+};
+
+declare interface BillingPrefetchOptions {
+    /**
+     * The resources the page renders, and no default: each one is a request
+     * on the server — the upcoming invoice is a live provider preview — and
+     * the list grows with every element, so a page names what it needs rather
+     * than paying for everything.
+     */
+    names: BillingResourceName[];
+    /** The invoice query to prefetch for; the element must ask the same one. */
+    invoices?: InvoiceQuery;
+}
+
+declare type BillingResourceName = keyof BillingResources;
+
+/** `Record<string, never>` marks a singleton; anything else is keyed. */
+declare interface BillingResourceParams {
+    invoices: InvoiceQuery;
+    upcomingInvoice: Record<string, never>;
+    paymentMethods: Record<string, never>;
+}
+
+/**
+ * Nothing in the store, the hooks, or the resource keys may be addressed by
+ * company or user id: users and companies are many-to-many, and a token names
+ * the pair. What is loaded belongs to the session it was read under — the
+ * pair, as `sessionKey` writes it — and a store that keeps more than one
+ * session's data keys it by that and serves only the active one.
+ */
+declare interface BillingResources {
+    /** `GET /company/invoices?limit&offset&include_pending`. */
+    invoices: InvoicePage;
+    /**
+     * `GET /company/upcoming-invoice`. `null` is a loaded value — the company
+     * has no next bill, which the endpoint reports as a 204 — so only
+     * `undefined` means the resource has not loaded.
+     */
+    upcomingInvoice: UpcomingInvoice | null;
+    /**
+     * `GET /company/payment-methods`. Empty is a loaded value — the company
+     * has no method on file — so only `undefined` means not loaded.
+     */
+    paymentMethods: PaymentMethod[];
+}
+
 declare type BooleanListenerFn = (value: boolean) => void;
 
 /**
@@ -172,6 +409,8 @@ export declare type CheckFlagReturn = {
     userId?: string;
     /** A boolean flag check result; for feature entitlements, this represents whether further consumption of the feature is permitted */
     value: boolean;
+    /** Customer-defined usage warning thresholds configured on this entitlement */
+    warningTiers?: WarningTier[];
 };
 
 declare const CheckFlagReturnFromJSON: (json: any) => CheckFlagReturn;
@@ -212,6 +451,12 @@ declare interface CheckFlagsResponseData {
     creditBalances?: {
         [key: string]: CompanyCreditBalance;
     };
+    /**
+     * Credit spend policies binding the evaluated company and user; empty when none bind. Each response carries the whole set, so replace any previously received set with it. Advisory: the flag values do not reflect them, since a check names no draw amount
+     * @type {Array<CreditSpendPolicy>}
+     * @memberof CheckFlagsResponseData
+     */
+    creditSpendPolicies: Array<CreditSpendPolicy_2>;
     /**
      *
      * @type {Array<CheckFlagResponseData>}
@@ -282,6 +527,270 @@ export declare interface CompanyCreditBalance {
     settled: number;
 }
 
+/**
+ * Schematic API
+ * Schematic API
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface CompanyDiscountResponseData
+ */
+declare interface CompanyDiscountResponseData {
+    /**
+     *
+     * @type {number}
+     * @memberof CompanyDiscountResponseData
+     */
+    amountOff?: number | null;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyDiscountResponseData
+     */
+    couponName: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyDiscountResponseData
+     */
+    currency?: string | null;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyDiscountResponseData
+     */
+    customerFacingCode?: string | null;
+    /**
+     * Provider vocabulary: once, repeating, or forever.
+     * @type {string}
+     * @memberof CompanyDiscountResponseData
+     */
+    duration: string;
+    /**
+     *
+     * @type {number}
+     * @memberof CompanyDiscountResponseData
+     */
+    durationInMonths?: number | null;
+    /**
+     *
+     * @type {number}
+     * @memberof CompanyDiscountResponseData
+     */
+    percentOff?: number | null;
+}
+
+/**
+ *
+ * @export
+ * @interface CompanyInvoiceResponseData
+ */
+declare interface CompanyInvoiceResponseData {
+    /**
+     *
+     * @type {number}
+     * @memberof CompanyInvoiceResponseData
+     */
+    amountDue: number;
+    /**
+     *
+     * @type {Date}
+     * @memberof CompanyInvoiceResponseData
+     */
+    createdAt: Date;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyInvoiceResponseData
+     */
+    currency: string;
+    /**
+     *
+     * @type {Date}
+     * @memberof CompanyInvoiceResponseData
+     */
+    dueDate?: Date | null;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyInvoiceResponseData
+     */
+    id: string;
+    /**
+     *
+     * @type {InvoiceStatus}
+     * @memberof CompanyInvoiceResponseData
+     */
+    status?: InvoiceStatus | null;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyInvoiceResponseData
+     */
+    url?: string | null;
+}
+
+/**
+ * Schematic API
+ * Schematic API
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface CompanyPaymentMethodResponseData
+ */
+declare interface CompanyPaymentMethodResponseData {
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    accountLast4?: string | null;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    accountName?: string | null;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    bankName?: string | null;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    billingEmail?: string | null;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    billingName?: string | null;
+    /**
+     * Whether DELETE /checkout/paymentmethod/:id would succeed. False only for the sole method while an active paid subscription needs it; the default can be removed like any other.
+     * @type {boolean}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    canRemove: boolean;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    cardBrand?: string | null;
+    /**
+     *
+     * @type {number}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    cardExpMonth?: number | null;
+    /**
+     *
+     * @type {number}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    cardExpYear?: number | null;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    cardLast4?: string | null;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    externalId: string;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    id: string;
+    /**
+     * Whether this is the method the company is billed with: the subscription's own when it has one, else the customer default. At most one method is the default.
+     * @type {boolean}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    isDefault: boolean;
+    /**
+     * The Stripe payment method type, such as card or us_bank_account.
+     * @type {string}
+     * @memberof CompanyPaymentMethodResponseData
+     */
+    type: string;
+}
+
+/**
+ *
+ * @export
+ * @interface CompanyUpcomingInvoiceResponseData
+ */
+declare interface CompanyUpcomingInvoiceResponseData {
+    /**
+     *
+     * @type {number}
+     * @memberof CompanyUpcomingInvoiceResponseData
+     */
+    amountDue: number;
+    /**
+     *
+     * @type {string}
+     * @memberof CompanyUpcomingInvoiceResponseData
+     */
+    currency: string;
+    /**
+     * How much of the company's existing balance this invoice consumes.
+     * @type {number}
+     * @memberof CompanyUpcomingInvoiceResponseData
+     */
+    customerBalanceApplied: number;
+    /**
+     * Balance left over after this invoice.
+     * @type {number}
+     * @memberof CompanyUpcomingInvoiceResponseData
+     */
+    customerBalanceRemaining: number;
+    /**
+     * The subscription's active discounts, to show beside the bill. Informational: the amounts come from the provider's preview and already reflect whatever it applied, so subtotal less these need not equal amount_due.
+     * @type {Array<CompanyDiscountResponseData>}
+     * @memberof CompanyUpcomingInvoiceResponseData
+     */
+    discounts: Array<CompanyDiscountResponseData>;
+    /**
+     *
+     * @type {Date}
+     * @memberof CompanyUpcomingInvoiceResponseData
+     */
+    dueDate?: Date | null;
+    /**
+     * Amount before discounts and tax.
+     * @type {number}
+     * @memberof CompanyUpcomingInvoiceResponseData
+     */
+    subtotal: number;
+}
+
 /** A company's lease-aware balance for a single credit type */
 export declare type CreditBalance = {
     /** Spendable balance including any open lease hold (remaining + reserved); the number to display to end users */
@@ -301,6 +810,153 @@ declare const CreditBalancesFromJSON: (json: any) => CreditBalances;
 
 declare type CreditBalancesListenerFn = (value: CreditBalances) => void;
 
+/** Every spend policy binding the current context, company-scope first */
+export declare type CreditSpendPolicies = CreditSpendPolicy[];
+
+/** Compare two policy sets by value, so an unchanged restream skips the notify. */
+declare const creditSpendPoliciesEqual: (a: CreditSpendPolicies, b: CreditSpendPolicies) => boolean;
+
+declare const CreditSpendPoliciesFromJSON: (json: any) => CreditSpendPolicies;
+
+declare type CreditSpendPoliciesListenerFn = (value: CreditSpendPolicies) => void;
+
+/** One limit on spending a credit */
+export declare type CreditSpendPolicy = {
+    id: string;
+    creditId: string;
+    kind: CreditSpendPolicyKind;
+    scope: CreditSpendPolicyScope;
+    label?: string;
+    /** The ceiling, in credits */
+    limit: number;
+    /** How much of the limit is already spent in the current period; 0 for per_draw */
+    consumed: number;
+    /** For windowed kinds, when the current period ends and consumed no longer applies */
+    resetsAt?: Date;
+    /** Set for windowed kinds only */
+    window?: CreditSpendWindow;
+};
+
+/**
+ *
+ * @export
+ * @interface CreditSpendPolicy
+ */
+declare interface CreditSpendPolicy_2 {
+    /**
+     * How much of the limit is already spent in the current period
+     * @type {number}
+     * @memberof CreditSpendPolicy
+     */
+    consumed?: number;
+    /**
+     * The credit the policy limits
+     * @type {string}
+     * @memberof CreditSpendPolicy
+     */
+    creditId: string;
+    /**
+     * The ID of the policy
+     * @type {string}
+     * @memberof CreditSpendPolicy
+     */
+    id: string;
+    /**
+     * How the limit is applied
+     * @type {string}
+     * @memberof CreditSpendPolicy
+     */
+    kind: string;
+    /**
+     * The name the account gave the policy
+     * @type {string}
+     * @memberof CreditSpendPolicy
+     */
+    label?: string | null;
+    /**
+     * The ceiling, in credits
+     * @type {number}
+     * @memberof CreditSpendPolicy
+     */
+    limit: number;
+    /**
+     * For a windowed limit, when the current period ends and consumed no longer applies
+     * @type {Date}
+     * @memberof CreditSpendPolicy
+     */
+    resetsAt?: Date | null;
+    /**
+     * Whether the policy limits the company or one user
+     * @type {CreditSpendPolicyScope}
+     * @memberof CreditSpendPolicy
+     */
+    scope: CreditSpendPolicyScope_2;
+    /**
+     * For a windowed limit, the period it accumulates over
+     * @type {CreditSpendWindow}
+     * @memberof CreditSpendPolicy
+     */
+    window?: CreditSpendWindow_2;
+}
+
+/** How a spend policy applies its limit. Unknown kinds are carried, not dropped:
+ * the server may ship a kind this SDK version predates. */
+export declare type CreditSpendPolicyKind = "per_draw" | "window" | (string & {});
+
+declare type CreditSpendPolicyListenerFn = CreditSpendPoliciesListenerFn | EmptyListenerFn;
+
+/** Whether a spend policy limits the company or one user */
+export declare type CreditSpendPolicyScope = "company" | "user" | (string & {});
+
+/**
+ *
+ * @export
+ */
+declare const CreditSpendPolicyScope_2: {
+    readonly Company: "company";
+    readonly User: "user";
+    readonly Group: "group";
+};
+
+declare type CreditSpendPolicyScope_2 = (typeof CreditSpendPolicyScope_2)[keyof typeof CreditSpendPolicyScope_2];
+
+/** The period a windowed spend policy accumulates over */
+export declare type CreditSpendWindow = {
+    unit: string;
+    count: number;
+};
+
+/**
+ * Schematic API
+ * Schematic API
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface CreditSpendWindow
+ */
+declare interface CreditSpendWindow_2 {
+    /**
+     * How many units make up one period
+     * @type {number}
+     * @memberof CreditSpendWindow
+     */
+    count: number;
+    /**
+     * The period the limit accumulates over
+     * @type {string}
+     * @memberof CreditSpendWindow
+     */
+    unit: string;
+}
+
 /**
  *
  * @export
@@ -335,6 +991,10 @@ declare interface DatastreamCompanyPlan {
 
 declare function DatastreamCompanyPlanFromJSON(json: any): DatastreamCompanyPlan;
 
+declare const DEFAULT_INVOICE_QUERY: InvoiceQuery;
+
+declare type Discount = CompanyDiscountResponseData;
+
 declare type EmptyListenerFn = () => void;
 
 /**
@@ -407,6 +1067,12 @@ declare interface EventBodyFlagCheck {
      * @memberof EventBodyFlagCheck
      */
     flagKey: string;
+    /**
+     * Whether the check was a preflight, asking whether an action would be allowed rather than reporting one that happened. Absent on ordinary checks
+     * @type {boolean}
+     * @memberof EventBodyFlagCheck
+     */
+    preflight?: boolean;
     /**
      * The reason why the value was returned
      * @type {string}
@@ -584,12 +1250,69 @@ declare interface FeatureEntitlement {
      * @memberof FeatureEntitlement
      */
     valueType: EntitlementValueType;
+    /**
+     * Customer-defined usage warning thresholds configured on this entitlement
+     * @type {Array<WarningTier>}
+     * @memberof FeatureEntitlement
+     */
+    warningTiers?: Array<WarningTier>;
 }
 
+/**
+ * Server prefetch for a provider's `initialData`. A resource that fails is
+ * left out rather than thrown, so one of them cannot block a page.
+ */
+declare function fetchBillingData(client: BillingClient, options: BillingPrefetchOptions): Promise<BillingData>;
+
 declare type FlagCheckListenerFn = CheckFlagReturnListenerFn | EmptyListenerFn;
 
 declare type FlagValueListenerFn = BooleanListenerFn | EmptyListenerFn;
 
+declare type Invoice = CompanyInvoiceResponseData;
+
+/** A `limit` above this is a 400 (PaginationFilter in schematic-api). */
+declare const INVOICE_MAX_PAGE_SIZE = 250;
+
+declare const INVOICE_PAGE_SIZE = 12;
+
+declare interface InvoicePage {
+    invoices: Invoice[];
+    /** Matching the query on the server, not the number loaded here. */
+    count: number;
+    hasMore: boolean;
+}
+
+/** Each distinct query is its own row set with its own paging. */
+declare interface InvoiceQuery {
+    /** Include unpaid invoices that are not yet due. Default false. */
+    includePending?: boolean;
+}
+
+declare interface InvoicesRequest extends InvoiceQuery {
+    limit: number;
+    offset: number;
+}
+
+/**
+ * The rows asked for, and how many the query matches in total. `hasMore` is
+ * the page's, and only the caller knows its offset.
+ */
+declare type InvoicesResult = Omit<InvoicePage, "hasMore">;
+
+/**
+ *
+ * @export
+ */
+declare const InvoiceStatus: {
+    readonly Draft: "draft";
+    readonly Open: "open";
+    readonly Paid: "paid";
+    readonly Uncollectible: "uncollectible";
+    readonly Void: "void";
+};
+
+declare type InvoiceStatus = (typeof InvoiceStatus)[keyof typeof InvoiceStatus];
+
 /** A record of unique key-value pairs used for identifying a company or user */
 export declare type Keys = Record<string, string>;
 
@@ -617,10 +1340,53 @@ declare const MetricPeriodMonthReset: {
 
 declare type MetricPeriodMonthReset = (typeof MetricPeriodMonthReset)[keyof typeof MetricPeriodMonthReset];
 
+/**
+ * The store keys a resource by the query's shape, so without this
+ * `{ includePending: false }` is a different row set from `{}` — it would
+ * miss the seed and refetch rows identical to those already on screen.
+ */
+declare function normalizeInvoiceQuery(query: InvoiceQuery): InvoiceQuery;
+
+/**
+ * One way the company pays. Two flags the server has already decided, so a
+ * consumer never re-derives a provider's rules:
+ *
+ * * `isDefault` — the subscription's default method, or, when the
+ *   subscription names none, the customer's.
+ * * `canRemove` — whether a delete would be accepted; the server's rule,
+ *   not `!isDefault`.
+ *
+ * `id` is Schematic's, and is what a delete takes; `externalId` is the
+ * provider's, and is what making it the default takes.
+ */
+declare type PaymentMethod = CompanyPaymentMethodResponseData;
+
 declare type PendingListenerFn = BooleanListenerFn | EmptyListenerFn;
 
 declare type PlanListenerFn = CheckPlanReturnListenerFn | EmptyListenerFn;
 
+declare interface RequestOptions {
+    method?: string;
+    body?: unknown;
+    /**
+     * Success statuses that carry no body — a 204 for a resource that is
+     * legitimately absent. The request resolves `undefined` for them, which
+     * is distinct from a body that parsed to `null`. A 401 is never one — the
+     * refresh and retry run first, and only what comes back from that is
+     * judged.
+     */
+    noContentOn?: number[];
+}
+
+declare interface ResourceState<T> {
+    /** `undefined` until the first successful load; retained across later errors. */
+    data: T | undefined;
+    /** The latest failure; cleared by the next success. */
+    error: Error | undefined;
+    /** A request is in flight and no data has arrived yet, or a refetch is running. */
+    isPending: boolean;
+}
+
 export declare enum RuleType {
     /** A global rule that, if present, will override all other rules for a flag */
     GLOBAL_OVERRIDE = "global_override",
@@ -655,9 +1421,9 @@ declare const RuleType_2: {
 declare type RuleType_2 = (typeof RuleType_2)[keyof typeof RuleType_2];
 
 export declare class Schematic {
-    private additionalHeaders;
+    private _additionalHeaders;
     private apiKey;
-    private apiUrl;
+    private _apiUrl;
     private conn;
     private context;
     private debugEnabled;
@@ -671,6 +1437,7 @@ export declare class Schematic {
     private isPendingListeners;
     private planListeners;
     private creditBalanceListeners;
+    private creditSpendPolicyListeners;
     private storage;
     private persistFlagState;
     private flagStateCacheKey;
@@ -681,6 +1448,7 @@ export declare class Schematic {
     private featureUsageEventMap;
     private planChecks;
     private creditBalances;
+    private creditSpendPolicies;
     private webSocketUrl;
     private webSocketConnectionTimeout;
     private webSocketReconnect;
@@ -702,6 +1470,8 @@ export declare class Schematic {
     private flagCheckDefaults;
     private fallbackCheckCache;
     constructor(apiKey: string, options?: SchematicOptions);
+    get apiUrl(): string;
+    get additionalHeaders(): Record<string, string>;
     /**
      * Resolve fallback value according to priority order:
      * 1. Callsite fallback value (if provided)
@@ -897,6 +1667,10 @@ export declare class Schematic {
     getCreditBalances: () => CreditBalances;
     /** Get the company's lease-aware balance for a single credit type in the current context */
     getCreditBalance: (creditId: string) => CreditBalance | undefined;
+    /** Get every credit spend policy binding the current context, company-scope first */
+    getCreditSpendPolicies: () => CreditSpendPolicies;
+    /** Get the spend policies binding a single credit type in the current context */
+    getCreditSpendPoliciesForCredit: (creditId: string) => CreditSpendPolicies;
     getFlagCheck: (flagKey: string) => CheckFlagReturn | undefined;
     getFlagValue: (flagKey: string) => boolean | undefined;
     /** Register an event listener that will be notified with the boolean value for a given flag when this value changes */
@@ -906,14 +1680,43 @@ export declare class Schematic {
     addPlanListener: (listener: PlanListenerFn) => () => void;
     /** Register an event listener that will be notified with the company's credit balances (keyed by credit ID) whenever they change */
     addCreditBalanceListener: (listener: CreditBalanceListenerFn) => () => void;
+    /** Register an event listener that will be notified with the context's credit spend policies whenever the set changes */
+    addCreditSpendPolicyListener: (listener: CreditSpendPolicyListenerFn) => () => void;
     private notifyFlagCheckListeners;
     /** Add or update a CheckFlagReturn in the featureUsageEventMap */
     private updateFeatureUsageEventMap;
     private notifyFlagValueListeners;
     private notifyPlanListeners;
+    private notifyCreditSpendPolicyListeners;
     private notifyCreditBalanceListeners;
 }
 
+declare class SchematicApiError extends Error {
+    readonly status: number;
+    readonly path: string;
+    readonly body: unknown;
+    constructor(status: number, path: string, body: unknown);
+}
+
+declare class SchematicBillingClient implements BillingClient {
+    /**
+     * Public so a second client over the same surface can be constructed on
+     * this one rather than minting tokens of its own.
+     */
+    readonly session: SchematicSession;
+    constructor(options?: BillingClientOptions | SchematicSession);
+    get sessionKey(): string | undefined;
+    get sessionStatus(): SessionStatus;
+    setSession(session: SessionInput): void;
+    onSessionChange(listener: (event: SessionEvent) => void): () => void;
+    fetchInvoices(params: InvoicesRequest): Promise<InvoicesResult>;
+    fetchUpcomingInvoice(): Promise<UpcomingInvoice | null>;
+    fetchPaymentMethods(): Promise<PaymentMethod[]>;
+    createSetupIntent(): Promise<SetupIntent>;
+    updatePaymentMethod(externalId: string): Promise<void>;
+    deletePaymentMethod(id: string): Promise<void>;
+}
+
 export declare interface SchematicComposableOpts {
     client?: SchematicJS.Schematic;
 }
@@ -934,6 +1737,20 @@ declare namespace SchematicJS {
         CheckFlagsResponseFromJSON,
         DatastreamCompanyPlanFromJSON,
         EventBodyFlagCheckToJSON,
+        fetchBillingData,
+        normalizeInvoiceQuery,
+        sessionKey,
+        AccessToken,
+        AccessTokenProvider,
+        AccessTokenResult,
+        billingApi,
+        BillingClient,
+        BillingClientOptions,
+        BillingData,
+        BillingPrefetchOptions,
+        BillingResourceName,
+        BillingResourceParams,
+        BillingResources,
         BooleanListenerFn,
         CheckFlagResponseData,
         CheckFlagReturn,
@@ -944,11 +1761,26 @@ declare namespace SchematicJS {
         CheckPlanReturnFromJSON,
         CheckPlanReturnListenerFn,
         CompanyCreditBalance,
+        CompanyDiscountResponseData,
+        CompanyInvoiceResponseData,
+        CompanyPaymentMethodResponseData,
+        CompanyUpcomingInvoiceResponseData,
         CreditBalance,
         CreditBalanceListenerFn,
         CreditBalances,
         CreditBalancesFromJSON,
         CreditBalancesListenerFn,
+        CreditSpendPolicies,
+        creditSpendPoliciesEqual,
+        CreditSpendPoliciesFromJSON,
+        CreditSpendPoliciesListenerFn,
+        CreditSpendPolicy,
+        CreditSpendPolicyKind,
+        CreditSpendPolicyListenerFn,
+        CreditSpendPolicyScope,
+        CreditSpendWindow,
+        DEFAULT_INVOICE_QUERY,
+        Discount,
         EmptyListenerFn,
         Event_2 as Event,
         EventBody,
@@ -958,17 +1790,42 @@ declare namespace SchematicJS {
         EventType,
         FlagCheckListenerFn,
         FlagValueListenerFn,
+        Invoice,
+        INVOICE_MAX_PAGE_SIZE,
+        INVOICE_PAGE_SIZE,
+        InvoicePage,
+        InvoiceQuery,
+        InvoicesRequest,
+        InvoicesResult,
+        InvoiceStatus,
         Keys,
+        PaymentMethod,
         PendingListenerFn,
         PlanListenerFn,
+        RequestOptions,
+        ResourceState,
         RuleType,
         Schematic,
+        SchematicApiError,
+        SchematicBillingClient,
         SchematicContext,
         SchematicOptions,
+        SchematicSession,
+        Session,
+        SessionEvent,
+        SessionInput,
+        SessionOptions,
+        SessionStatus,
+        SetupIntent,
+        SetupIntentResponseData,
+        SINGLETON,
         StoragePersister,
+        TOKEN_CACHE_SIZE,
         Traits,
         TrialStatus,
-        UsagePeriod
+        UpcomingInvoice,
+        UsagePeriod,
+        WarningTier
     }
 }
 
@@ -1051,6 +1908,160 @@ declare type SchematicPluginOptionsWithPublishableKey = BaseSchematicPluginOptio
     publishableKey: string;
 };
 
+/**
+ * Session identity is the (company, user) pair alone: a freshly minted token,
+ * a rebuilt provider closure, and a refresh this session asked for itself are
+ * all the same session. Nothing in a token says who it was minted for, so
+ * that question is the host's to answer.
+ *
+ * Credentials survive a change of session, keyed by pair — switching back to
+ * a company reads with the token already in hand. They do not survive the
+ * session ending: after a sign-out the next person at this page is somebody
+ * else, and nothing minted for the last one is theirs to send.
+ */
+declare class SchematicSession {
+    private readonly _apiUrl;
+    private readonly _headers;
+    private readonly _fetch;
+    private _session;
+    private readonly _tokens;
+    private readonly _resolving;
+    /**
+     * Bumped when the session's identity changes, and only then — the object
+     * itself is replaced on every render. Anything asking "is this still the
+     * session I started under?" counts generations rather than comparing.
+     */
+    private _generation;
+    private readonly _listeners;
+    constructor(options?: SessionOptions);
+    get key(): string | undefined;
+    get status(): SessionStatus;
+    /** Only a statement that changes which pair is read counts as a change. */
+    set(session: SessionInput): void;
+    onChange(listener: (event: SessionEvent) => void): () => void;
+    private _emit;
+    private _cached;
+    private _cache;
+    /**
+     * The credential for a session, minted if this one is not held. `force`
+     * retires what is held first: the caller is a request the API has just
+     * rejected.
+     */
+    resolveToken(session: Session, force: boolean): Promise<string>;
+    /**
+     * Sends a request under the active session's credential, refreshing once
+     * and retrying if the API rejects it. Rejects rather than answering when
+     * the session changes while the request is in flight: the rows would
+     * otherwise come back as the answer to a question asked for another pair.
+     */
+    request(path: string, options?: RequestOptions): Promise<unknown>;
+}
+
+/**
+ * Who is being read. Users and companies are many-to-many: the same person
+ * reads one company's billing and then another's, and the same company is
+ * read by several people. A token is minted for the pair, so the pair — not
+ * the company alone — is the session's identity.
+ */
+declare interface Session {
+    /** The host's name for the company, its id in their own system say. */
+    company: string;
+    /**
+     * The user, where the host mints per (company, user). Left out by a host
+     * whose tokens are company-wide, and then every reader of that company
+     * shares one session.
+     */
+    user?: string;
+    token: AccessToken;
+}
+
+/**
+ * What happened to the session, for anything holding data that belongs to
+ * one. `started`: whatever is loaded belongs to the new session — a prefetch
+ * the host seeded before its auth resolved. `changed`: another pair is being
+ * read, and what is loaded belongs to the pair being left. `ended`: nobody is
+ * signed in, and what is loaded belongs to nobody.
+ */
+declare type SessionEvent = {
+    type: "started" | "changed" | "ended";
+};
+
+/**
+ * Three states that are not interchangeable:
+ *
+ * * `Session` — active: this pair, read with this credential.
+ * * `null` — ended: nobody is signed in; what is loaded is dropped.
+ * * `undefined` — pending: the host's auth has not resolved. It states
+ *   nothing, so the session in hand stands.
+ */
+declare type SessionInput = Session | null | undefined;
+
+/**
+ * The pair as one string, for anything that has to compare sessions or key
+ * something by one — a prefetch stating which session it was fetched for, a
+ * store keeping a page per session. Opaque: read it only by equality.
+ */
+declare function sessionKey(session: Session): string;
+
+declare interface SessionOptions {
+    session?: SessionInput;
+    apiUrl?: string;
+    additionalHeaders?: Record<string, string>;
+    /** Override for tests and non-browser runtimes. */
+    fetch?: typeof fetch;
+}
+
+declare type SessionStatus = "pending" | "active" | "ended";
+
+/** What a provider's card form is mounted with to add a method. */
+declare type SetupIntent = SetupIntentResponseData;
+
+/**
+ * Schematic API
+ * Schematic API
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface SetupIntentResponseData
+ */
+declare interface SetupIntentResponseData {
+    /**
+     *
+     * @type {string}
+     * @memberof SetupIntentResponseData
+     */
+    accountId?: string | null;
+    /**
+     *
+     * @type {string}
+     * @memberof SetupIntentResponseData
+     */
+    publishableKey?: string | null;
+    /**
+     *
+     * @type {string}
+     * @memberof SetupIntentResponseData
+     */
+    schematicPublishableKey: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SetupIntentResponseData
+     */
+    setupIntentClientSecret?: string | null;
+}
+
+/** The params of every singleton resource. */
+declare const SINGLETON: Record<string, never>;
+
 /** Optional type for implementing custom client-side storage */
 export declare type StoragePersister = {
     setItem(key: string, value: any): void;
@@ -1058,6 +2069,15 @@ export declare type StoragePersister = {
     removeItem(key: string): void;
 };
 
+/**
+ * Sessions whose credentials are kept. A reader switching between the
+ * organizations they belong to walks a handful of them and comes back, and
+ * re-minting on every step is a round trip to the host's token endpoint for
+ * a token this client already holds and has not seen expire. The same
+ * handful the flag cache bounds its contexts at.
+ */
+declare const TOKEN_CACHE_SIZE = 10;
+
 /**
  * A flexible key/value type that can store any type of value on a company or user.
  */
@@ -1075,6 +2095,8 @@ declare const TrialStatus: {
 
 declare type TrialStatus = (typeof TrialStatus)[keyof typeof TrialStatus];
 
+declare type UpcomingInvoice = CompanyUpcomingInvoiceResponseData;
+
 export declare enum UsagePeriod {
     ALL_TIME = "all_time",
     CURRENT_DAY = "current_day",
@@ -1123,9 +2145,12 @@ export declare const useSchematicContext: (opts?: SchematicComposableOpts) => {
  * `remaining` would otherwise read stale / falsely "exhausted".
  *
  * The credit ID is available on a feature's entitlement: `useSchematicEntitlement(key)`
- * returns `creditId` for credit-based features.
+ * returns `creditId` for credit-based features. Pass that computed ref straight
+ * in; the composable unwraps a ref, a getter, or a plain string, and re-keys to
+ * the new credit when the source changes. While the ID is undefined it reports
+ * the client's loading state and a balance of 0.
  *
- * @param creditId - The credit ID to read the balance for
+ * @param creditId - The credit ID to read the balance for, as a ref, a getter, or a plain string
  * @param opts - Optional configuration including a client override
  * @returns Object with `balance` and `isLoading` computed refs
  *
@@ -1133,18 +2158,67 @@ export declare const useSchematicContext: (opts?: SchematicComposableOpts) => {
  * ```typescript
  * const { balance, isLoading } = useSchematicCreditBalance('credit-id')
  *
+ * // Or keyed off an entitlement, without unwrapping it yourself
+ * const { creditId } = useSchematicEntitlement('my-flag-key')
+ * const { balance } = useSchematicCreditBalance(creditId)
+ *
  * // In template
  * <div v-if="isLoading">Loading…</div>
  * <div v-else>{{ balance }} credits remaining</div>
  * ```
  */
-export declare const useSchematicCreditBalance: (creditId: string, opts?: SchematicComposableOpts) => {
+export declare const useSchematicCreditBalance: (creditId: MaybeRefOrGetter<string | undefined>, opts?: SchematicComposableOpts) => {
     /** The spendable balance; 0 while loading or when the company holds no balance in this credit */
     balance: ComputedRef<number>;
     /** True while the balance is still loading and no value has arrived yet */
     isLoading: ComputedRef<boolean>;
 };
 
+/**
+ * Get every credit spend policy binding the current context.
+ * Returns reactive computed refs for the policies and a loading flag.
+ *
+ * Company-scope policies come first, then the user's own. The list updates
+ * as partials arrive over the DataStream, so a policy edited or deleted in the
+ * dashboard reaches the component without a refetch. A window policy also
+ * carries `consumed` and `resetsAt`, which update as credits are spent.
+ *
+ * @param opts - Optional configuration including a client override
+ * @returns Object with `policies` and `isLoading` computed refs
+ *
+ * @example
+ * ```typescript
+ * const { policies, isLoading } = useSchematicCreditSpendPolicies()
+ *
+ * // In template
+ * <div v-if="isLoading">Loading…</div>
+ * <ul v-else>
+ *   <li v-for="policy in policies" :key="policy.id">
+ *     {{ policy.scope }} limit: {{ policy.limit }} credits
+ *   </li>
+ * </ul>
+ * ```
+ */
+export declare const useSchematicCreditSpendPolicies: (opts?: SchematicComposableOpts) => {
+    /** Company-scope policies first, then the user's own; empty when none bind */
+    policies: ComputedRef<    {
+    id: string;
+    creditId: string;
+    kind: SchematicJS.CreditSpendPolicyKind;
+    scope: SchematicJS.CreditSpendPolicyScope;
+    label?: string | undefined;
+    limit: number;
+    consumed: number;
+    resetsAt?: Date | undefined;
+    window?: {
+    unit: string;
+    count: number;
+    } | undefined;
+    }[]>;
+    /** True while the policies are still loading and nothing has arrived yet */
+    isLoading: ComputedRef<boolean>;
+};
+
 /**
  * Check feature entitlement with usage details
  * Returns reactive refs for flag value, usage, allocation, and exceeded status
@@ -1190,6 +2264,10 @@ export declare const useSchematicEntitlement: (key: string, opts?: UseSchematicF
     softLimit?: number | undefined;
     userId?: string | undefined;
     value: boolean;
+    warningTiers?: {
+    key: string;
+    value: number;
+    }[] | undefined;
     }>;
     value: ComputedRef<boolean>;
     flag: ComputedRef<string>;
@@ -1199,10 +2277,19 @@ export declare const useSchematicEntitlement: (key: string, opts?: UseSchematicF
     featureUsageExceeded: ComputedRef<boolean | undefined>;
     featureUsageEvent: ComputedRef<string | undefined>;
     featureUsagePeriod: ComputedRef<SchematicJS.UsagePeriod | undefined>;
+    softLimit: ComputedRef<number | undefined>;
+    warningTiers: ComputedRef<    {
+    key: string;
+    value: number;
+    }[] | undefined>;
     flagId: ComputedRef<string | undefined>;
     ruleId: ComputedRef<string | undefined>;
     companyId: ComputedRef<string | undefined>;
     userId: ComputedRef<string | undefined>;
+    creditId: ComputedRef<string | undefined>;
+    creditSettled: ComputedRef<number | undefined>;
+    creditRemaining: ComputedRef<number | undefined>;
+    creditReserved: ComputedRef<number | undefined>;
 };
 
 /**
@@ -1292,4 +2379,35 @@ export declare type UseSchematicPlanOpts = SchematicComposableOpts & {
     fallback?: SchematicJS.CheckPlanReturn;
 };
 
+/**
+ * Schematic API
+ * Schematic API
+ *
+ * The version of the OpenAPI document: 0.1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface WarningTier
+ */
+export declare interface WarningTier {
+    /**
+     * A customer-defined identifier for the warning tier
+     * @type {string}
+     * @memberof WarningTier
+     */
+    key: string;
+    /**
+     * The warning threshold, in the entitlement's usage units
+     * @type {number}
+     * @memberof WarningTier
+     */
+    value: number;
+}
+
 export { }