@stripe/extensibility-sdk 1.0.1 → 1.3.0

package/dist/extensibility-sdk-extensions-billing-recurring_billing_item_handling-alpha.d.ts

@@ -0,0 +1,735 @@
+import { __integerBrand } from '@formspec/core';
+
+/**
+ * Opaque brand key used as a property key in SDK branded types.
+ *
+ * @remarks
+ * You do not need to use this directly — it is already embedded in
+ * branded values returned by factory functions like {@link (Integer:type)}.from().
+ *
+ * String-literal const (not `unique symbol`) so that independent
+ * declaration rollups (root vs subpath) produce structurally compatible
+ * branded types.
+ *
+ * @public
+ */
+declare const __brand: '__brand';
+
+/* Excluded from this release type: __decimalBrand */
+
+/**
+ * Distinct brand key for PositiveInteger so an Integer is not assignable to
+ * PositiveInteger without going through the guard. PositiveInteger is a
+ * subtype of Integer (it carries both brands), so it can be used wherever
+ * Integer is expected.
+ *
+ * String-literal const (not `unique symbol`) so that independent
+ * declaration rollups (root vs subpath) produce structurally compatible
+ * branded types.
+ *
+ * For internal use only — may be removed in a future release.
+ *
+ * @public
+ */
+declare const __positiveIntegerBrand: '__positiveIntegerBrand';
+
+/**
+ * Opaque type-tag key used by SDK scalar types to carry Stripe type metadata.
+ *
+ * @remarks
+ * You do not need to use this directly — it is already embedded in
+ * branded values returned by factory functions like {@link (Integer:type)}.from().
+ *
+ * String-literal const (not `unique symbol`) so that independent
+ * declaration rollups (root vs subpath) produce structurally compatible
+ * branded types.
+ *
+ * @public
+ */
+declare const __stripeType: '__stripeType';
+
+/** @public */
+declare type AnyTimeRange = {
+    at: Date;
+    value: 'oneTime';
+} | {
+    endDate: Date;
+    startDate: Date;
+    value: 'timeRange';
+} | {
+    otherValue: string;
+    value: 'other';
+};
+
+/* Excluded from this release type: _ConfigApplicationContext */
+
+/** @public */
+declare interface Context {
+    type: string;
+    id: string;
+    livemode: boolean;
+    stripeContext?: string;
+    clockTime?: string;
+}
+
+/** @public */
+declare type Currency = 'aed' | 'afn' | 'all' | 'amd' | 'ang' | 'aoa' | 'apt' | 'arb' | 'ars' | 'aud' | 'avax' | 'awg' | 'azn' | 'bam' | 'bbd' | 'bdt' | 'bgn' | 'bhd' | 'bif' | 'bmd' | 'bnb' | 'bnd' | 'bob' | 'bov' | 'brl' | 'bsd' | 'btc' | 'btn' | 'buidl' | 'bwp' | 'byn' | 'byr' | 'bzd' | 'cad' | 'cdf' | 'celo' | 'che' | 'chf' | 'chw' | 'clf' | 'clp' | 'cny' | 'cop' | 'cou' | 'crc' | 'cuc' | 'cup' | 'cve' | 'czk' | 'dai' | 'djf' | 'dkk' | 'dop' | 'dzd' | 'eek' | 'egp' | 'ern' | 'etb' | 'eth' | 'eur' | 'eurc' | 'fjd' | 'fkp' | 'frxusd' | 'gbp' | 'gel' | 'ghc' | 'ghs' | 'gip' | 'gmd' | 'gnf' | 'gtq' | 'gyd' | 'hkd' | 'hnl' | 'hrk' | 'htg' | 'huf' | 'hype' | 'idr' | 'ils' | 'inr' | 'iqd' | 'irr' | 'isk' | 'jmd' | 'jod' | 'jpy' | 'kes' | 'kgs' | 'khr' | 'kmf' | 'kpw' | 'krw' | 'kwd' | 'kyd' | 'kzt' | 'lak' | 'lbp' | 'lkr' | 'lrd' | 'lsl' | 'ltl' | 'lvl' | 'lyd' | 'lzd' | 'm' | 'mad' | 'mdl' | 'mga' | 'mkd' | 'mmk' | 'mnt' | 'mon' | 'mop' | 'mro' | 'mru' | 'mur' | 'mvr' | 'mwk' | 'mxn' | 'mxv' | 'myr' | 'mzn' | 'nad' | 'ngn' | 'nio' | 'nok' | 'npr' | 'nzd' | 'omr' | 'open_usd' | 'ord' | 'pab' | 'pen' | 'pgk' | 'php' | 'pkr' | 'pln' | 'pol' | 'pyg' | 'pyusd' | 'qar' | 'rd' | 're' | 'ron' | 'rsd' | 'rub' | 'rwf' | 'sar' | 'sbd' | 'scr' | 'sdg' | 'sek' | 'sgd' | 'shp' | 'sle' | 'sll' | 'sol' | 'sos' | 'srd' | 'ssp' | 'std' | 'stn' | 'sui' | 'svc' | 'syp' | 'szl' | 'thb' | 'tjs' | 'tmt' | 'tnd' | 'top' | 'trx' | 'try' | 'ttd' | 'twd' | 'tzs' | 'uah' | 'ugx' | 'usd' | 'usdb' | 'usdc' | 'usdg' | 'usdp' | 'usdsui' | 'usdt' | 'usn' | 'ustb' | 'uyi' | 'uyu' | 'uzs' | 'vef' | 'ves' | 'vnd' | 'vuv' | 'wst' | 'xaf' | 'xcd' | 'xcg' | 'xeur' | 'xlm' | 'xof' | 'xpf' | 'xpl' | 'xusd' | 'yer' | 'zar' | 'zmk' | 'zmw' | 'zwd' | 'zwg' | 'zwl';
+
+/**
+ * Arbitrary-precision decimal type for billing calculations.
+ *
+ * @remarks
+ * `Decimal` values are created by the {@link (Decimal:variable) | Decimal companion object}
+ * and store values as `coefficient × 10^exponent` using `BigInt`. They avoid
+ * every common binary floating-point pitfall — `Decimal.from('0.1').add(Decimal.from('0.2'))`
+ * is exactly `0.3`.
+ *
+ * Instances are immutable (frozen) and all arithmetic returns a new
+ * `Decimal`. The public type carries two brand symbols so the type system
+ * prevents accidental assignment from plain `number`, `string`, or
+ * `bigint`.
+ *
+ * Create values via the companion object:
+ *
+ * @example
+ * ```ts
+ * import { Decimal, RoundDirection } from '@stripe/extensibility-sdk';
+ *
+ * const price = Decimal.from('19.99');
+ * const tax   = price.mul(Decimal.from('0.0825'));
+ * const total = price.add(tax);
+ *
+ * console.log(total.toFixed(2, 'half-up'));   // "21.64"
+ * console.log(JSON.stringify({ total }));          // '{"total":"21.639175"}'
+ * console.log(total.toFixed(2, 'half-even')); // "21.64"
+ * ```
+ *
+ * @public
+ */
+declare interface Decimal {
+    /* Excluded from this release type: __brand */
+    /* Excluded from this release type: __decimalBrand */
+    /* Excluded from this release type: __stripeType */
+    /**
+     * Return the sum of this value and `other`.
+     * @public
+     */
+    add(other: DecimalLike): Decimal;
+    /**
+     * Return the difference of this value and `other`.
+     * @public
+     */
+    sub(other: DecimalLike): Decimal;
+    /**
+     * Return the product of this value and `other`.
+     * @public
+     */
+    mul(other: DecimalLike): Decimal;
+    /**
+     * Return the quotient of this value divided by `other`.
+     * @public
+     */
+    div(other: DecimalLike, precision: number, direction: RoundDirection): Decimal;
+    /**
+     * Three-way comparison: returns `-1`, `0`, or `1`.
+     * @public
+     */
+    cmp(other: DecimalLike): -1 | 0 | 1;
+    /**
+     * Return `true` if this value is numerically equal to `other`.
+     * @public
+     */
+    eq(other: DecimalLike): boolean;
+    /**
+     * Return `true` if this value is strictly less than `other`.
+     * @public
+     */
+    lt(other: DecimalLike): boolean;
+    /**
+     * Return `true` if this value is less than or equal to `other`.
+     * @public
+     */
+    lte(other: DecimalLike): boolean;
+    /**
+     * Return `true` if this value is strictly greater than `other`.
+     * @public
+     */
+    gt(other: DecimalLike): boolean;
+    /**
+     * Return `true` if this value is greater than or equal to `other`.
+     * @public
+     */
+    gte(other: DecimalLike): boolean;
+    /**
+     * Return `true` if this value is exactly zero.
+     * @public
+     */
+    isZero(): boolean;
+    /**
+     * Return `true` if this value is strictly less than zero.
+     * @public
+     */
+    isNegative(): boolean;
+    /**
+     * Return `true` if this value is strictly greater than zero.
+     * @public
+     */
+    isPositive(): boolean;
+    /**
+     * Return the additive inverse of this value.
+     * @public
+     */
+    neg(): Decimal;
+    /**
+     * Return the absolute value.
+     * @public
+     */
+    abs(): Decimal;
+    /**
+     * Round this value to the specified precision.
+     * @public
+     */
+    round(direction: RoundDirection, options: DecimalRoundingOptions | keyof typeof DecimalRoundingPresets): Decimal;
+    /**
+     * Return the canonical string representation.
+     * @public
+     */
+    toString(): string;
+    /**
+     * Return the JSON-serializable string representation.
+     * @public
+     */
+    toJSON(): string;
+    /**
+     * Convert to a JavaScript `number` (lossy).
+     * @public
+     */
+    toNumber(): number;
+    /**
+     * Format as a fixed-point string with exactly `decimalPlaces` digits.
+     * @public
+     */
+    toFixed(decimalPlaces: number, direction: RoundDirection): string;
+    /**
+     * Convert to an {@link (Integer:type)} by rounding.
+     * @public
+     */
+    toInteger(direction: RoundDirection): Integer;
+    /**
+     * Rejects implicit coercion; explicit `String(d)` and template literals still work.
+     * @public
+     */
+    [Symbol.toPrimitive](hint: 'default' | 'number' | 'string'): string;
+    /**
+     * Returns the string representation; invoked by the JavaScript engine as a fallback coercion path.
+     * @public
+     */
+    valueOf(): string;
+}
+
+/**
+ * Companion object for creating `Decimal` instances.
+ *
+ * @public
+ */
+declare const Decimal: DecimalCompanion;
+
+/** @public */
+declare interface DecimalCompanion {
+    /** Type guard: narrows `unknown` to `Decimal`. @public */
+    is(value: unknown): value is Decimal;
+    /** Assertion guard: throws if not a `Decimal`. @public */
+    assert(value: unknown): asserts value is Decimal;
+    /** Create a Decimal from a {@link DecimalLike} value. @public */
+    from(value: DecimalLike): Decimal;
+    /** The Decimal value `0`. @public */
+    readonly zero: Decimal;
+}
+
+/**
+ * Values that can be coerced to a `Decimal` via `Decimal.from()`.
+ *
+ * @remarks
+ * This union is accepted by `Decimal.from()` and by all arithmetic and
+ * comparison methods on `Decimal` instances. Non-Decimal values are
+ * coerced via `Decimal.from()` before the operation.
+ *
+ * @public
+ */
+declare type DecimalLike = bigint | Decimal | Integer | number | string;
+
+/**
+ * Precision specification for `Decimal.round()`.
+ *
+ * @remarks
+ * Two modes are supported:
+ * - `"decimal-places"` — round to a fixed number of digits after the decimal point.
+ * - `"significant-figures"` — round to a fixed number of significant digits.
+ *
+ * @example
+ * ```ts
+ * // Round to 2 decimal places
+ * amount.round('half-even', { mode: 'decimal-places', value: 2 });
+ *
+ * // Round to 4 significant figures
+ * amount.round('half-up', { mode: 'significant-figures', value: 4 });
+ * ```
+ *
+ * @public
+ */
+declare interface DecimalRoundingOptions {
+    /** Whether to count digits from the decimal point (`"decimal-places"`) or from the most significant digit (`"significant-figures"`). */
+    mode: 'decimal-places' | 'significant-figures';
+    /**
+     * The number of digits to retain. Interpreted as decimal places when
+     * `mode` is `"decimal-places"`, or as significant figures when `mode`
+     * is `"significant-figures"`.
+     * @public
+     */
+    value: number;
+}
+
+/**
+ * Built-in rounding presets keyed by semantic name.
+ *
+ * @remarks
+ * Stripe defines the full set of supported preset names accepted by
+ * `Decimal.round()`.
+ *
+ * | Preset              | Equivalent DecimalRoundingOptions                     |
+ * | ------------------- | ----------------------------------------------------- |
+ * | `"ubb-usage-count"` | `{ mode: "significant-figures", value: 15 }`         |
+ * | `"v1-api"`          | `{ mode: "decimal-places", value: 12 }`              |
+ *
+ * @public
+ */
+declare const DecimalRoundingPresets: Readonly<{
+    'ubb-usage-count': Readonly<{
+        mode: "significant-figures";
+        value: number;
+    }>;
+    'v1-api': Readonly<{
+        mode: "decimal-places";
+        value: number;
+    }>;
+}>;
+
+/** A branded integer — a `number` guaranteed to satisfy `Number.isInteger`. @public */
+declare type Integer = {
+    readonly [__integerBrand]: true;
+    readonly [__stripeType]: 'int';
+} & number;
+
+/** Factory, type guard, and utilities for {@link (Integer:type)} branded values. @public */
+declare const Integer: IntegerCompanion;
+
+/** @public */
+declare interface IntegerCompanion {
+    /** The Integer value `0`. @public */
+    readonly zero: Integer;
+    /** Type guard: narrows `unknown` to {@link (Integer:type)}. @public */
+    is(value: unknown): value is Integer;
+    /** Assertion guard: throws if not an {@link (Integer:type)}. @public */
+    assert(value: unknown): asserts value is Integer;
+    /** Coerce a value to {@link (Integer:type)} by rounding. @public */
+    from(value: Decimal | Integer | number | string, rounding: IntegerRoundDirection): Integer;
+    /** Lossless conversion to `Decimal`. @public */
+    toDecimal(value: Integer): Decimal;
+    /** Type guard: narrows {@link (Integer:type)} to {@link (PositiveInteger:type)}. @public */
+    isPositive(value: Integer): value is PositiveInteger;
+    /** Assertion guard: throws if the Integer is negative. @public */
+    assertIsPositive(value: Integer): asserts value is PositiveInteger;
+}
+
+/**
+ * Rounding directions for coercing a number to an integer.
+ *
+ * A focused subset of {@link https://standards.ieee.org/ieee/754/6210/ | IEEE 754-2019} §4.3:
+ *
+ * | Direction      | Behavior                     | Examples (→ integer)           |
+ * | -------------- | ---------------------------- | ------------------------------ |
+ * | `'ceil'`       | Toward +∞                    | 1.1→2, -1.1→-1                |
+ * | `'floor'`      | Toward -∞                    | 1.9→1, -1.1→-2                |
+ * | `'round-down'` | Toward zero (truncate)       | 1.9→1, -1.9→-1                |
+ * | `'round-up'`   | Away from zero               | 1.1→2, -1.1→-2                |
+ * | `'half-up'`    | Nearest; ties away from zero | 0.5→1, -0.5→-1, 1.4→1         |
+ *
+ * @public
+ */
+declare type IntegerRoundDirection = 'ceil' | 'floor' | 'half-up' | 'round-down' | 'round-up';
+
+/**
+ * A branded non-negative integer — a `number` guaranteed to be an integer ≥ 0.
+ *
+ * This is a subtype of {@link (Integer:type)}: every non-negative integer is an
+ * integer, so `PositiveInteger` values are assignable to `Integer` contexts.
+ * The reverse is not true — an `Integer` cannot be assigned where a
+ * `PositiveInteger` is expected without going through the `PositiveInteger.is()`
+ * type guard or `PositiveInteger.from()` factory.
+ *
+ * @remarks
+ * Despite the name, this type includes zero (`>= 0`, not `> 0`).
+ * The schema-level constraint `@minimum 0` should be added to fields
+ * typed as `PositiveInteger` to ensure the non-negativity invariant
+ * is enforced at validation time.
+ *
+ * @public
+ */
+declare type PositiveInteger = {
+    readonly [__integerBrand]: true;
+    readonly [__positiveIntegerBrand]: true;
+    readonly [__stripeType]: 'int';
+} & number;
+
+/** Factory, type guard, and utilities for {@link (PositiveInteger:type)} branded values. @public */
+declare const PositiveInteger: PositiveIntegerCompanion;
+
+/** @public */
+declare interface PositiveIntegerCompanion {
+    /** Type guard: narrows `unknown` to {@link (PositiveInteger:type)}. @public */
+    is(value: unknown): value is PositiveInteger;
+    /** Assertion guard: throws if not a {@link (PositiveInteger:type)}. @public */
+    assert(value: unknown): asserts value is PositiveInteger;
+    /** Coerce a value to {@link (PositiveInteger:type)} by rounding. Throws if negative. @public */
+    from(value: Decimal | Integer | number | string, rounding: IntegerRoundDirection): PositiveInteger;
+}
+
+/** @public */
+export declare namespace RecurringBillingItemHandling {
+    /** @public */
+    export type PricingTierMode = 'graduated' | 'volume';
+    /** @public */
+    export type RecurringPriceInterval = 'day' | 'month' | 'week' | 'year';
+    /** @public */
+    export type PriceType = 'one_time' | 'recurring';
+    /** @public */
+    export type PricingScheme = 'per_unit' | 'tiered';
+    /** @public */
+    export type UsageType = 'licensed' | 'metered';
+    /** @public */
+    export type ItemType = 'credit' | 'debit';
+    /**
+     * The result of the group items extension.
+     * @public
+     */
+    export interface GroupItemsResult {
+        /** The groups of items, each corresponding to a separate invoice. */
+        groups: ItemGroup[];
+    }
+    /**
+     * A group of items to place on a single invoice.
+     * @public
+     */
+    export interface ItemGroup {
+        /** The items in this group. */
+        items: GroupedItem[];
+        /** Whether this group sets the latest invoice reference on the subscription. */
+        setsLatestInvoice: boolean;
+    }
+    /**
+     * An item assigned to a group.
+     * @public
+     */
+    export interface GroupedItem {
+        /** The unique identifier of the item, matching a key from the input. */
+        key: string;
+    }
+    /**
+     * The input to the group items extension.
+     * @public
+     */
+    export interface GroupItemsInput {
+        /** The list of items to group across invoices. */
+        items: Item[];
+    }
+    /** @public */
+    export type Item = ({
+        creditedItems: 'invoiceItem';
+        invoiceItem: CreditedInvoiceItem;
+    } | {
+        creditedItems: 'invoiceLineItems';
+        invoiceLineItems: InvoiceLineItems;
+    } | {
+        creditedItems: 'other';
+        otherCreditedItems: string;
+    } | { creditedItems?: never }) & ({
+        customPricingUnitOverageRate: CustomPricingUnitOverageRate;
+        priceKind: 'customPricingUnitOverageRate';
+    } | {
+        licenseFee: LicenseFee;
+        priceKind: 'licenseFee';
+    } | {
+        otherPriceKind: string;
+        priceKind: 'other';
+    } | {
+        price: Price;
+        priceKind: 'price';
+    } | {
+        priceKind: 'rateCardRate';
+        rateCardRate: RateCardRate;
+    } | { priceKind?: never }) & {
+        isProration: boolean;
+        key: string;
+        prorationFactor: Decimal;
+        servicePeriod: AnyTimeRange;
+        type: ItemType;
+    };
+    /**
+     * The invoice item corresponding to a credit item.
+     * @public
+     */
+    export interface CreditedInvoiceItem {
+        /** The id of the invoice item. */
+        id: string;
+    }
+    /**
+     * Information about debit line items corresponding to a credit item.
+     * @public
+     */
+    export interface InvoiceLineItems {
+        /** The invoice containing the line items. */
+        invoice: CreditedInvoice;
+        /** The line items corresponding to the credit. */
+        invoiceLineItems: CreditedInvoiceLineItem[];
+    }
+    /**
+     * The invoice line item corresponding to a credit item.
+     * @public
+     */
+    export interface CreditedInvoiceLineItem {
+        /** The id of the invoice line item. */
+        id: string;
+    }
+    /**
+     * The invoice corresponding to a credit item.
+     * @public
+     */
+    export interface CreditedInvoice {
+        /** The id of the invoice. */
+        id: string;
+    }
+    /** @public */
+    export interface CustomPricingUnitOverageRate {
+        id: string;
+        metadata: Record<string, string>;
+        rateCard: RateCard;
+        customPricingUnit: string;
+        unitAmount: Decimal;
+    }
+    /** @public */
+    export interface RateCard {
+        id: string;
+        currency: Currency;
+    }
+    /** @public */
+    export interface RateCardRate {
+        id: string;
+        metadata: Record<string, string>;
+        rateCard: RateCard;
+        tieringMode?: PricingTierMode;
+        tiers: RateCardRateTier[];
+        unitAmount?: Decimal;
+    }
+    /** @public */
+    export interface RateCardRateTier {
+        flatAmount?: Decimal;
+        unitAmount?: Decimal;
+        upTo?: Decimal;
+    }
+    /** @public */
+    export interface LicenseFee {
+        id: string;
+        lookupKey?: string;
+        metadata: Record<string, string>;
+        serviceInterval: RecurringPriceInterval;
+        serviceIntervalCount: number;
+        tieringMode?: PricingTierMode;
+        tiers: LicenseFeeTier[];
+        currency: Currency;
+        unitAmount?: Decimal;
+    }
+    /** @public */
+    export interface LicenseFeeTier {
+        flatAmount?: Decimal;
+        unitAmount?: Decimal;
+        upTo?: Decimal;
+    }
+    /** @public */
+    export interface Price {
+        id: string;
+        product: Product;
+        recurring?: RecurringPrice;
+        billingScheme: PricingScheme;
+        tiers: PriceTier[];
+        type: PriceType;
+        tiersMode?: PricingTierMode;
+        metadata: Record<string, string>;
+        currency: Currency;
+        unitAmount?: Decimal;
+    }
+    /** @public */
+    export interface PriceTier {
+        flatAmount?: Decimal;
+        unitAmount?: Decimal;
+        upTo?: number;
+    }
+    /** @public */
+    export interface RecurringPrice {
+        interval: RecurringPriceInterval;
+        intervalCount: number;
+        usageType?: UsageType;
+        meter?: string;
+    }
+    /** @public */
+    export interface Product {
+        id: string;
+        name: string;
+        metadata: Record<string, string>;
+    }
+    /**
+     * The result of the filter items extension.
+     * @public
+     */
+    export interface FilterItemsResult {
+        /** The items to include on the invoice. */
+        items: ItemToInvoice[];
+    }
+    /**
+     * An item selected for inclusion on the invoice.
+     * @public
+     */
+    export interface ItemToInvoice {
+        /** The unique identifier of the item, matching a key from the input. */
+        key: string;
+    }
+    /**
+     * The input to the filter items extension.
+     * @public
+     */
+    export interface FilterItemsInput {
+        /** The list of items to evaluate for inclusion on the invoice. */
+        items: Item[];
+    }
+    /**
+     * The result of the before item creation extension.
+     * @public
+     */
+    export interface BeforeItemCreationResult {
+        /** The items with their creation strategies. */
+        items: ItemWithCreationStrategy[];
+    }
+    /** @public */
+    export type ItemWithCreationStrategy = ({
+        creationStrategy: 'other';
+        otherCreationStrategy: string;
+    } | { creationStrategy: 'doNotCreate' } | { creationStrategy: 'invoice' } | { creationStrategy?: never }) & { key: string };
+    /** @public */
+    export type Invoice = Record<string, never>;
+    /** @public */
+    export type DoNotCreate = Record<string, never>;
+    /**
+     * The input to the before item creation extension.
+     * @public
+     */
+    export interface BeforeItemCreationInput {
+        /** The list of items to evaluate for creation. */
+        items: Item[];
+    }
+    /* Excluded from this release type: $platformWrapBeforeItemCreation */
+    /* Excluded from this release type: $platformWrapFilterItems */
+    /* Excluded from this release type: $platformWrapGroupItems */
+    /**
+     * Runs before invoice items are created. Decides whether each item should be created or skipped.
+     * @public
+     */
+    export type BeforeItemCreationFunction<Config> = (request: BeforeItemCreationInput, config: Config, context: Context) => BeforeItemCreationResult;
+    /**
+     * Runs before invoices are created. Decides which items to include on the invoice. Items not included are deferred as pending invoice items.
+     * @public
+     */
+    export type FilterItemsFunction<Config> = (request: FilterItemsInput, config: Config, context: Context) => FilterItemsResult;
+    /**
+     * Runs before invoices are created. Decides how items are grouped across one or more invoices.
+     * @public
+     */
+    export type GroupItemsFunction<Config> = (request: GroupItemsInput, config: Config, context: Context) => GroupItemsResult;
+}
+
+/**
+ * @example
+ * ```ts
+ * import type { Billing, Context } from '@stripe/extensibility-sdk';
+ *
+ * // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+ * interface MyRecurringBillingItemHandlingConfig {}
+ *
+ * export default class MyRecurringBillingItemHandling implements Billing.RecurringBillingItemHandling<MyRecurringBillingItemHandlingConfig> {
+ *   beforeItemCreation(
+ *     _request: Billing.RecurringBillingItemHandling.BeforeItemCreationInput,
+ *     _config: MyRecurringBillingItemHandlingConfig,
+ *     _context: Context
+ *   ) {
+ *     // TODO: implement your before-item-creation logic here
+ *
+ *     return {
+ *       items: [],
+ *     };
+ *   }
+ *
+ *   filterItems(
+ *     _request: Billing.RecurringBillingItemHandling.FilterItemsInput,
+ *     _config: MyRecurringBillingItemHandlingConfig,
+ *     _context: Context
+ *   ) {
+ *     // TODO: implement your filter-items logic here
+ *
+ *     return {
+ *       items: [],
+ *     };
+ *   }
+ *
+ *   groupItems(
+ *     _request: Billing.RecurringBillingItemHandling.GroupItemsInput,
+ *     _config: MyRecurringBillingItemHandlingConfig,
+ *     _context: Context
+ *   ) {
+ *     // TODO: implement your group-items logic here
+ *
+ *     return {
+ *       groups: [],
+ *     };
+ *   }
+ * }
+ *
+ * ```
+ * @public
+ */
+export declare interface RecurringBillingItemHandling<Config> {
+    beforeItemCreation: RecurringBillingItemHandling.BeforeItemCreationFunction<Config>;
+    filterItems: RecurringBillingItemHandling.FilterItemsFunction<Config>;
+    groupItems: RecurringBillingItemHandling.GroupItemsFunction<Config>;
+}
+
+/**
+ * Rounding direction for Decimal operations.
+ *
+ * @remarks
+ * Seven modes corresponding to
+ * {@link https://standards.ieee.org/ieee/754/6210/ | IEEE 754-2019} §4.3
+ * rounding-direction attributes:
+ *
+ * | Direction      | IEEE 754 name           | Behavior                          | Examples (→ integer)                  |
+ * | -------------- | ----------------------- | --------------------------------- | ------------------------------------- |
+ * | `'ceil'`       | `roundTowardPositive`   | Toward +∞                         |  1.1→2, -1.1→-1                       |
+ * | `'floor'`      | `roundTowardNegative`   | Toward -∞                         |  1.9→1, -1.1→-2                       |
+ * | `'round-down'` | `roundTowardZero`       | Toward zero (truncate)            |  1.9→1, -1.9→-1                       |
+ * | `'round-up'`   | —                       | Away from zero                    |  1.1→2, -1.1→-2                       |
+ * | `'half-up'`    | `roundTiesToAway`       | Nearest; ties away from zero      |  0.5→1, -0.5→-1, 1.4→1               |
+ * | `'half-down'`  | —                       | Nearest; ties toward zero         |  0.5→0, -0.5→0, 1.6→2                |
+ * | `'half-even'`  | `roundTiesToEven`       | Nearest; ties to even (banker's)  |  0.5→0, 1.5→2, 2.5→2, 3.5→4          |
+ *
+ * @public
+ */
+declare type RoundDirection = 'ceil' | 'floor' | 'half-down' | 'half-even' | 'half-up' | 'round-down' | 'round-up';
+
+export { }