import { FirebaseApp } from 'firebase/app';
import { WhereFilterOp } from 'firebase/firestore';
export { WhereFilterOp } from 'firebase/firestore';

/**
 * Serves as the main entry point to this library. Initializes the client SDK,
 * and returns a handle object that can be passed into other APIs.
 *
 * @param app - A FirebaseApp instance initialized by the Firebase JS SDK.
 * @param options - Configuration options for the SDK.
 * @returns An instance of the StripePayments class.
 */
declare function getStripePayments(app: FirebaseApp, options: StripePaymentsOptions): StripePayments;
/**
 * Configuration options that indicate how the Stripe payments extension has been set up.
 */
interface StripePaymentsOptions {
    customersCollection: string;
    productsCollection: string;
}
/**
 * Holds the configuration and other state information of the SDK. An instance of this class
 * must be passed to almost all the other APIs of this library. Do not directly call the
 * constructor. Use the {@link getStripePayments} function to obtain an instance.
 */
declare class StripePayments {
    readonly app: FirebaseApp;
    private readonly options;
    private readonly components;
    private constructor();
    /**
     * Name of the customers collection as configured in the extension.
     */
    get customersCollection(): string;
    /**
     * Name of the products collection as configured in the extension.
     */
    get productsCollection(): string;
}
/**
 * Union of possible error codes.
 */
type StripePaymentsErrorCode = "deadline-exceeded" | "not-found" | "permission-denied" | "unauthenticated" | "internal";
/**
 * An error thrown by this SDK.
 */
declare class StripePaymentsError extends Error {
    readonly code: StripePaymentsErrorCode;
    readonly message: string;
    readonly cause?: any | undefined;
    constructor(code: StripePaymentsErrorCode, message: string, cause?: any | undefined);
}

/**
 * Parameters common across all session types.
 */
interface CommonSessionCreateParams {
    /**
     * Enables user redeemable promotion codes.
     */
    allow_promotion_codes?: boolean;
    /**
     * Set to true to enable automatic taxes. Defaults to false.
     */
    automatic_tax?: boolean;
    /**
     * A unique string to reference the Checkout Session. This can be a customer ID, a cart ID,
     * or similar, and can be used to reconcile the session with your internal systems.
     */
    client_reference_id?: string;
    /**
     * The URL the customer will be directed to if they decide to cancel payment and return to
     * your website.
     */
    cancel_url?: string;
    /**
     * Set of key-value pairs that you can attach to an object. This can be useful for storing
     * additional information about the object in a structured format.
     */
    metadata?: {
        [key: string]: any;
    };
    /**
     * The mode of the Checkout Session. If not specified defaults to `subscription`.
     */
    mode?: "subscription" | "payment";
    /**
     * A list of the types of payment methods (e.g., `card`) this Checkout Session can accept.
     * Defaults to `["card"]`.
     */
    payment_method_types?: PaymentMethodType[];
    /**
     * The promotion code to apply to this Session.
     */
    promotion_code?: string;
    /**
     * The URL to which Stripe should send customers when payment or setup is complete.
     */
    success_url?: string;
    /**
     * Controls tax ID collection settings for the session.
     */
    tax_id_collection?: boolean;
    /**
     * Indicates if a plan’s `trial_period_days` should be applied to the subscription. Defaults
     * to `true`.
     */
    trial_from_plan?: boolean;
}
/**
 * Supported payment methods.
 */
type PaymentMethodType = "card" | "acss_debit" | "afterpay_clearpay" | "alipay" | "bacs_debit" | "bancontact" | "boleto" | "eps" | "fpx" | "giropay" | "grabpay" | "ideal" | "klarna" | "oxxo" | "p24" | "sepa_debit" | "sofort" | "wechat_pay";
/**
 * Parameters for createing a session with one or more line items.
 */
interface LineItemSessionCreateParams extends CommonSessionCreateParams {
    line_items: LineItemParams[];
}
/**
 * Parameters common across all line item types.
 */
interface CommonLineItemParams {
    /**
     * The description for the line item, to be displayed on the Checkout page.
     */
    description?: string;
    /**
     * The quantity of the line item being purchased.
     */
    quantity?: number;
}
/**
 * Parameters for createing a line item with a Stripe price ID.
 */
interface PriceIdLineItemParams extends CommonLineItemParams {
    /**
     * The ID of the Stripe price.
     */
    price: string;
}
/**
 * Parameters for creating a new line item.
 */
type LineItemParams = PriceIdLineItemParams;
/**
 * Parameters for createing a session with a Stripe price ID.
 */
interface PriceIdSessionCreateParams extends CommonSessionCreateParams {
    /**
     * The ID of the Stripe price.
     */
    price: string;
    /**
     * The quantity of the item being purchased. Defaults to 1.
     */
    quantity?: number;
}
/**
 * Parameters for creating a new session.
 */
type SessionCreateParams = LineItemSessionCreateParams | PriceIdSessionCreateParams;
/**
 * Interface of Stripe checkout session.
 */
interface Session {
    /**
     * The URL the customer will be directed to if they decide to cancel payment and return to
     * your website.
     */
    readonly cancel_url: string;
    /**
     * Time when the session was created as a UTC timestamp.
     */
    readonly created_at: string;
    /**
     * Unique identifier for the session. Used to pass to `redirectToCheckout()` in Stripe.js.
     */
    readonly id: string;
    /**
     * The mode of the Checkout Session.
     */
    readonly mode: "subscription" | "payment";
    /**
     * The URL to which Stripe should send customers when payment or setup is complete.
     */
    readonly success_url: string;
    /**
     * The URL to the Checkout Session. Redirect the user to this URL to complete the payment.
     */
    readonly url: string;
    /**
     * Enables user redeemable promotion codes.
     */
    readonly allow_promotion_codes?: boolean;
    /**
     * Indicates whether automatic tax is enabled for the session
     */
    readonly automatic_tax?: boolean;
    /**
     * A unique string to reference the Checkout Session. This can be a customer ID, a cart ID,
     * or similar, and can be used to reconcile the session with your internal systems.
     */
    readonly client_reference_id?: string;
    /**
     * The array of line items purchased with this session. A session is guaranteed to contain either
     * {@link Session.line_items} or {@link Session.price}.
     */
    readonly line_items?: LineItem[];
    /**
     * Set of key-value pairs that you can attach to an object. This can be useful for storing
     * additional information about the object in a structured format.
     */
    readonly metadata?: {
        [key: string]: any;
    };
    /**
     * A list of the types of payment methods (e.g., `card`) this Checkout Session can accept.
     * Defaults to `["card"]`.
     */
    readonly payment_method_types?: PaymentMethodType[];
    /**
     * The ID of the Stripe price object purchased with this session. A session is guaranteed to
     * contain either {@link Session.line_items} or {@link Session.price}.
     */
    readonly price?: string;
    /**
     * The promotion code to apply to this Session.
     */
    readonly promotion_code?: string;
    /**
     * The quantity of item purchased. Defaults to 1.
     */
    readonly quantity?: number;
    /**
     * Controls tax ID collection settings for the session.
     */
    readonly tax_id_collection?: boolean;
    /**
     * Indicates if a plan’s `trial_period_days` should be applied to the subscription. Defaults
     * to `true`.
     */
    readonly trial_from_plan?: boolean;
}
/**
 * Interface of a Stripe line item associated with a checkout session. A line item represents
 * an individual item purchased using the session.
 */
interface LineItem {
    /**
     * The amount to be collected per unit of the line item.
     */
    amount?: number;
    /**
     * Three-letter {@link https://www.iso.org/iso-4217-currency-codes.html | ISO currency code},
     * in lowercase. Must be a {@link https://stripe.com/docs/currencies | supported currency}.
     */
    currency?: string;
    /**
     * The description for the line item, to be displayed on the Checkout page.
     */
    description?: string;
    /**
     * The name for the item to be displayed on the Checkout page.
     */
    name?: string;
    /**
     * The ID of the Stripe price.
     */
    price?: string;
    /**
     * The quantity of the line item being purchased.
     */
    quantity?: number;
}
declare const CREATE_SESSION_TIMEOUT_MILLIS: number;
/**
 * Optional settings for the {@link createCheckoutSession} function.
 */
interface CreateCheckoutSessionOptions {
    /**
     * Time to wait (in milliseconds) until the session is created and acknowledged by  Stripe.
     * If not specified, defaults to {@link CREATE_SESSION_TIMEOUT_MILLIS}.
     */
    timeoutMillis?: number;
}
/**
 * Creates a new Stripe checkout session with the given parameters. Returned session contains a
 * session ID and a session URL that can be used to redirect the user to complete the checkout.
 * User must be currently signed in with Firebase Auth to call this API. If a timeout occurs
 * while waiting for the session to be created and acknowledged by Stripe, rejects with a
 * `deadline-exceeded` error. Default timeout duration is {@link CREATE_SESSION_TIMEOUT_MILLIS}.
 *
 * @param payments - A valid {@link StripePayments} object.
 * @param params - Parameters of the checkout session.
 * @param options - Optional settings to customize the behavior.
 * @returns Resolves with the created Stripe Session object.
 */
declare function createCheckoutSession(payments: StripePayments, params: SessionCreateParams, options?: CreateCheckoutSessionOptions): Promise<Session>;

/**
 * Interface of a Stripe payment stored in the app database.
 */
interface Payment {
    /**
     * Amount intended to be collected by this payment. A positive integer representing how much
     * to charge in the smallest currency unit (e.g., 100 cents to charge $1.00 or 100 to charge
     * ¥100, a zero-decimal currency). The minimum amount is $0.50 US or equivalent in charge
     * currency. The amount value supports up to eight digits (e.g., a value of 99999999 for a
     * USD charge of $999,999.99).
     */
    readonly amount: number;
    /**
     * Amount that can be captured from this payment.
     */
    readonly amount_capturable: number;
    /**
     * Amount that was collected by this payment.
     */
    readonly amount_received: number;
    /**
     * The date when the payment was created as a UTC timestamp.
     */
    readonly created: string;
    /**
     * Three-letter ISO currency code, in lowercase. Must be a supported currency.
     */
    readonly currency: string;
    /**
     * ID of the Customer this payment belongs to, if one exists. Payment methods attached
     * to other Customers cannot be used with this payment.
     */
    readonly customer: string | null;
    /**
     * An arbitrary string attached to the object. Often useful for displaying to users.
     */
    readonly description: string | null;
    /**
     * Unique Stripe payment ID.
     */
    readonly id: string;
    /**
     * ID of the invoice that created this payment, if it exists.
     */
    readonly invoice: string | null;
    /**
     * Set of key-value pairs that you can attach to an object. This can be useful for storing
     * additional information about the object in a structured format.
     */
    readonly metadata: {
        [name: string]: string;
    };
    /**
     * The list of payment method types (e.g. card) that this payment is allowed to use.
     */
    readonly payment_method_types: string[];
    /**
     * Array of product ID and price ID pairs.
     */
    readonly prices: Array<{
        product: string;
        price: string;
    }>;
    /**
     * Status of this payment.
     */
    readonly status: PaymentStatus;
    /**
     * Firebase Auth UID of the user that created the payment.
     */
    readonly uid: string;
    readonly [propName: string]: any;
}
/**
 * Possible states a payment can be in.
 */
type PaymentStatus = "requires_payment_method" | "requires_confirmation" | "requires_action" | "processing" | "requires_capture" | "cancelled" | "succeeded";
/**
 * Retrieves an existing Stripe payment for the currently signed in user from the database.
 *
 * @param payments - A valid {@link StripePayments} object.
 * @param subscriptionId - ID of the payment to retrieve.
 * @returns Resolves with a Payment object if found. Rejects if the specified payment ID
 *  does not exist, or if the user is not signed in.
 */
declare function getCurrentUserPayment(payments: StripePayments, paymentId: string): Promise<Payment>;
/**
 * Optional parameters for the {@link getCurrentUserPayments} function.
 */
interface GetPaymentsOptions {
    /**
     * Specify one or more payment status values to retrieve. When set only the payments
     * with the given status are returned.
     */
    status?: PaymentStatus | PaymentStatus[];
}
declare function getCurrentUserPayments(payments: StripePayments, options?: GetPaymentsOptions): Promise<Payment[]>;
/**
 * Different types of changes that may occur on a payment object.
 */
type PaymentChangeType = "added" | "modified" | "removed";
/**
 * Represents the current state of a set of payments owned by a user.
 */
interface PaymentSnapshot {
    /**
     * A list of all currently available payments ordered by the payment ID. Empty
     * if no payments are available.
     */
    payments: Payment[];
    /**
     * The list of changes in the payments since the last snapshot.
     */
    changes: Array<{
        type: PaymentChangeType;
        payment: Payment;
    }>;
    /**
     * Number of currently available payments. This is same as the length of the
     * `payments` array in the snapshot.
     */
    size: number;
    /**
     * True if there are no payments available. False whenever at least one payment is
     * present. When True, the `payments` array is empty, and the `size` is 0.
     */
    empty: boolean;
}
/**
 * Registers a listener to receive payment update events for the currently signed in
 * user. If the user is not signed in throws an `unauthenticated` error, and no listener is
 * registered.
 *
 * Upon successful registration, the `onUpdate` callback will fire once with
 * the current state of all the payments. From then onwards, each update to a payment
 * will fire the `onUpdate` callback with the latest state of the payments.
 *
 * @param payments - A valid {@link StripePayments} object.
 * @param onUpdate - A callback that will fire whenever the current user's payments
 *   are updated.
 * @param onError - A callback that will fire whenever an error occurs while listening to
 *   payment updates.
 * @returns A function that can be called to cancel and unregister the listener.
 */
declare function onCurrentUserPaymentUpdate(payments: StripePayments, onUpdate: (snapshot: PaymentSnapshot) => void, onError?: (error: StripePaymentsError) => void): () => void;

/**
 * Interface of a Stripe Product stored in the app database.
 */
interface Product {
    /**
     * Unique Stripe product ID.
     */
    readonly id: string;
    /**
     * Whether the product is currently available for purchase.
     */
    readonly active: boolean;
    /**
     * The product's name, meant to be displayable to the customer. Whenever this product is sold
     * via a subscription, name will show up on associated invoice line item descriptions.
     */
    readonly name: string;
    /**
     * The product's description, meant to be displayable to the customer. Use this field to
     * optionally store a long form explanation of the product being sold for your own
     * rendering purposes.
     */
    readonly description: string | null;
    /**
     * The Firebase role that will be assigned to the user if they are subscribed to this plan.
     */
    readonly role: string | null;
    /**
     * A list of up to 8 URLs of images for this product, meant to be displayable to the customer.
     */
    readonly images: string[];
    /**
     * A list of Prices for this billing product. Only populated if explicitly requested
     * during retrieval.
     */
    readonly prices: Price[];
    /**
     * A collection of additional product metadata.
     */
    readonly metadata: {
        [key: string]: string | number | null;
    };
    readonly [propName: string]: any;
}
/**
 * Interface of a Stripe Price object stored in the app database.
 */
interface Price {
    /**
     * Unique Stripe price ID.
     */
    readonly id: string;
    /**
     * ID of the Stripe product to which this price is related.
     */
    readonly product: string;
    /**
     * Whether the price can be used for new purchases.
     */
    readonly active: boolean;
    /**
     * Three-letter ISO currency code.
     */
    readonly currency: string;
    /**
     * The unit amount in cents to be charged, represented as a whole integer if possible.
     */
    readonly unit_amount: number | null;
    /**
     * A brief description of the price.
     */
    readonly description: string | null;
    /**
     * One of `one_time` or `recurring` depending on whether the price is for a one-time purchase
     * or a recurring (subscription) purchase.
     */
    readonly type: "one_time" | "recurring";
    /**
     * The frequency at which a subscription is billed. One of `day`, `week`, `month` or `year`.
     */
    readonly interval: "day" | "month" | "week" | "year" | null;
    /**
     * The number of intervals (specified in the {@link Price.interval} attribute) between
     * subscription billings. For example, `interval=month` and `interval_count=3` bills every
     * 3 months.
     */
    readonly interval_count: number | null;
    /**
     * Default number of trial days when subscribing a customer to this price using
     * {@link https://stripe.com/docs/api#create_subscription-trial_from_plan | trial_from_plan}.
     */
    readonly trial_period_days: number | null;
    readonly [propName: string]: any;
}
/**
 * Optional parameters for the {@link getProduct} function.
 */
interface GetProductOptions {
    /**
     * Set to `true` to retrieve the prices along with a product. If not set, the product is
     * returned with no prices (i.e. {@link Product.prices} field will be empty).
     */
    includePrices?: boolean;
}
/**
 * Retrieves a Stripe product from the database.
 *
 * @param payments - A valid {@link StripePayments} object.
 * @param productId - ID of the product to retrieve.
 * @param options - A set of options to customize the behavior.
 * @returns Resolves with a Stripe Product object if found. Rejects if the specified product ID
 *  does not exist.
 */
declare function getProduct(payments: StripePayments, productId: string, options?: GetProductOptions): Promise<Product>;
/**
 * Optional parameters for the {@link getProducts} function.
 */
interface GetProductsOptions {
    /**
     * Set to `true` to retrieve only the currently active set of Stripe products. If not set,
     * returns all available products. When set, the effect is same as if called with the filter
     * `["active", "==", true]`.
     */
    activeOnly?: boolean;
    /**
     * An array of optoinal filters that will be applied when querying the products from the app
     * database.
     */
    where?: WhereFilter[];
    /**
     * Set to `true` to retrieve the prices along with a product. If not set, the product is
     * returned with no prices (i.e. {@link Product.prices} field will be empty).
     */
    includePrices?: boolean;
    /**
     * Maximum number of products to return.
     */
    limit?: number;
}

/**
 * A filter constraint that can be applied to database queries. Consists of a field name (in
 * Firestore dotted notation), a Firestore filter operator, and a value.
 */
type WhereFilter = [string, WhereFilterOp, any];
/**
 * Retrieves a Stripe product from the database.
 *
 * @param payments - A valid {@link StripePayments} object.
 * @param productId - ID of the product to retrieve.
 * @param options - A set of options to customize the behavior.
 * @returns Resolves with an array of Stripe Product objects. May be empty.
 */
declare function getProducts(payments: StripePayments, options?: GetProductsOptions): Promise<Product[]>;
/**
 * Retrieves a Stripe price from the database.
 *
 * @param payments - A valid {@link StripePayments} object.
 * @param productId - ID of the product to which the price belongs.
 * @param priceId - ID of the price to retrieve.
 * @returns Resolves with a Stripe Price object if found. Rejects if the specified
 *   product ID or the price ID does not exist.
 */
declare function getPrice(payments: StripePayments, productId: string, priceId: string): Promise<Price>;
/**
 * Retrieves all Stripe prices associated with the specified product.
 *
 * @param payments - A valid {@link StripePayments} object.
 * @param productId - ID of the product to which the prices belong.
 * @returns Resolves with an array of Stripe Price objects. Rejects if the specified
 *   product ID does not exist. If the product exists, but doesn't have any prices, resolves
 *   with the empty array.
 */
declare function getPrices(payments: StripePayments, productId: string): Promise<Price[]>;

/**
 * Interface of a Stripe Subscription stored in the app database.
 */
interface Subscription {
    /**
     * A future date in UTC format at which the subscription will automatically get canceled.
     */
    readonly cancel_at: string | null;
    /**
     * If `true`, the subscription has been canceled by the user and will be deleted at the end
     * of the billing period.
     */
    readonly cancel_at_period_end: boolean;
    /**
     * If the subscription has been canceled, the date of that cancellation as a UTC timestamp.
     * If the subscription was canceled with {@link Subscription.cancel_at_period_end}, this field
     * will still reflect the date of the initial cancellation request, not the end of the
     * subscription period when the subscription is automatically moved to a canceled state.
     */
    readonly canceled_at: string | null;
    /**
     * The date when the subscription was created as a UTC timestamp.
     */
    readonly created: string;
    /**
     * End of the current period that the subscription has been invoiced for as a UTC timestamp.
     * At the end of the period, a new invoice will be created.
     */
    readonly current_period_end: string;
    /**
     * Start of the current period that the subscription has been invoiced for as a UTC timestamp.
     */
    readonly current_period_start: string;
    /**
     * If the subscription has ended, the date the subscription ended as a UTC timestamp.
     */
    readonly ended_at: string | null;
    /**
     * Unique Stripe subscription ID.
     */
    readonly id: string;
    /**
     * Set of extra key-value pairs attached to the subscription object.
     */
    readonly metadata: {
        [name: string]: string;
    };
    /**
     * Stripe price ID associated with this subscription.
     */
    readonly price: string;
    /**
     * Array of product ID and price ID pairs. If multiple recurring prices were provided to the
     * checkout session (e.g. via `lineItems`) this array holds all recurring prices for this
     * subscription. The first element of this array always corresponds to the
     * {@link Subscription.price} and {@link Subscription.product} fields on the subscription.
     */
    readonly prices: Array<{
        product: string;
        price: string;
    }>;
    /**
     * Stripe product ID associated with this subscription.
     */
    readonly product: string;
    /**
     * Quantity of items purchased with this subscription.
     */
    readonly quantity: number | null;
    /**
     * The Firebae role that can be assigned to the user with this subscription.
     */
    readonly role: string | null;
    /**
     * The status of the subscription object
     */
    readonly status: SubscriptionStatus;
    /**
     * A link to the subscription in the Stripe dashboard.
     */
    readonly stripe_link: string;
    /**
     * If the subscription has a trial, the end date of that trial as a UTC timestamp.
     */
    readonly trial_end: string | null;
    /**
     * If the subscription has a trial, the start date of that trial as a UTC timestamp.
     */
    readonly trial_start: string | null;
    /**
     * Firebase Auth UID of the user that created the subscription.
     */
    readonly uid: string;
    readonly [propName: string]: any;
}
/**
 * Possible states a subscription can be in.
 */
type SubscriptionStatus = "active" | "canceled" | "incomplete" | "incomplete_expired" | "past_due" | "trialing" | "unpaid";
/**
 * Retrieves an existing Stripe subscription for the currently signed in user from the database.
 *
 * @param payments - A valid {@link StripePayments} object.
 * @param subscriptionId - ID of the subscription to retrieve.
 * @returns Resolves with a Subscription object if found. Rejects if the specified subscription ID
 *  does not exist, or if the user is not signed in.
 */
declare function getCurrentUserSubscription(payments: StripePayments, subscriptionId: string): Promise<Subscription>;
/**
 * Optional parameters for the {@link getCurrentUserSubscriptions} function.
 */
interface GetSubscriptionsOptions {
    /**
     * Specify one or more subscription status values to retrieve. When set only the subscriptions
     * with the given status are returned.
     */
    status?: SubscriptionStatus | SubscriptionStatus[];
}
/**
 * Retrieves existing Stripe subscriptions for the currently signed in user from the database.
 *
 * @param payments - A valid {@link StripePayments} object.
 * @param options - A set of options to customize the behavior.
 * @returns Resolves with an array of Stripe subscriptions. May be empty.
 */
declare function getCurrentUserSubscriptions(payments: StripePayments, options?: GetSubscriptionsOptions): Promise<Subscription[]>;
/**
 * Different types of changes that may occur on a subscription object.
 */
type SubscriptionChangeType = "added" | "modified" | "removed";
/**
 * Represents the current state of a set of subscriptions owned by a user.
 */
interface SubscriptionSnapshot {
    /**
     * A list of all currently available subscriptions ordered by the subscription ID. Empty
     * if no subscriptions are available.
     */
    subscriptions: Subscription[];
    /**
     * The list of changes in the subscriptions since the last snapshot.
     */
    changes: Array<{
        type: SubscriptionChangeType;
        subscription: Subscription;
    }>;
    /**
     * Number of currently available subscriptions. This is same as the length of the
     * `subscriptions` array in the snapshot.
     */
    size: number;
    /**
     * True if there are no subscriptions available. False whenever at least one subscription is
     * present. When True, the `subscriptions` array is empty, and the `size` is 0.
     */
    empty: boolean;
}
/**
 * Registers a listener to receive subscription update events for the currently signed in
 * user. If the user is not signed in throws an `unauthenticated` error, and no listener is
 * registered.
 *
 * Upon successful registration, the `onUpdate` callback will fire once with
 * the current state of all the subscriptions. From then onwards, each update to a subscription
 * will fire the `onUpdate` callback with the latest state of the subscriptions.
 *
 * @param payments - A valid {@link StripePayments} object.
 * @param onUpdate - A callback that will fire whenever the current user's subscriptions
 *   are updated.
 * @param onError - A callback that will fire whenever an error occurs while listening to
 *   subscription updates.
 * @returns A function that can be called to cancel and unregister the listener.
 */
declare function onCurrentUserSubscriptionUpdate(payments: StripePayments, onUpdate: (snapshot: SubscriptionSnapshot) => void, onError?: (error: StripePaymentsError) => void): () => void;

export { CREATE_SESSION_TIMEOUT_MILLIS, type CommonLineItemParams, type CommonSessionCreateParams, type CreateCheckoutSessionOptions, type GetPaymentsOptions, type GetProductOptions, type GetProductsOptions, type GetSubscriptionsOptions, type LineItem, type LineItemParams, type LineItemSessionCreateParams, type Payment, type PaymentChangeType, type PaymentMethodType, type PaymentSnapshot, type PaymentStatus, type Price, type PriceIdLineItemParams, type PriceIdSessionCreateParams, type Product, type Session, type SessionCreateParams, StripePayments, StripePaymentsError, type StripePaymentsErrorCode, type StripePaymentsOptions, type Subscription, type SubscriptionChangeType, type SubscriptionSnapshot, type SubscriptionStatus, type WhereFilter, createCheckoutSession, getCurrentUserPayment, getCurrentUserPayments, getCurrentUserSubscription, getCurrentUserSubscriptions, getPrice, getPrices, getProduct, getProducts, getStripePayments, onCurrentUserPaymentUpdate, onCurrentUserSubscriptionUpdate };