import * as React from 'react';
import { ReactNode } from 'react';
import { j as StripeSubscriptionInterface, P as PaymentMethodInterface, S as StripeCustomerInterface, a as StripeInvoiceInterface, M as MeterInterface, o as MeterSummaryInterface, d as StripePriceInterface, f as StripePriceInput, g as StripeProductInterface, h as StripeProductInput, I as InvoiceStatus, b as ProrationPreviewInterface, i as SubscriptionStatus, n as StripeUsageInterface, q as PromotionCodeValidationResult } from '../stripe-promotion-code.interface-ClZ7DxS9.mjs';
import { J as JsonApiHydratedDataInterface } from '../ApiDataInterface-BcZeXy5X.mjs';
import '../feature.interface-CXb1-vNq.mjs';

type SubscriptionSummaryCardProps = {
    subscriptions: StripeSubscriptionInterface[];
    loading?: boolean;
    error?: string;
    onManageClick: () => void;
};
declare function SubscriptionSummaryCard({ subscriptions, loading, error, onManageClick, }: SubscriptionSummaryCardProps): React.JSX.Element;

type PaymentMethodSummaryCardProps = {
    paymentMethods: PaymentMethodInterface[];
    defaultPaymentMethodId?: string;
    loading?: boolean;
    error?: string;
    onManageClick: () => void;
};
declare function PaymentMethodSummaryCard({ paymentMethods, defaultPaymentMethodId, loading, error, onManageClick, }: PaymentMethodSummaryCardProps): React.JSX.Element;

type CustomerInfoCardProps = {
    customer: StripeCustomerInterface | null;
    loading?: boolean;
    error?: string;
};
declare function CustomerInfoCard({ customer, loading, error }: CustomerInfoCardProps): React.JSX.Element;

type InvoicesSummaryCardProps = {
    invoices: StripeInvoiceInterface[];
    loading?: boolean;
    error?: string;
    onViewAllClick: () => void;
};
declare function InvoicesSummaryCard({ invoices, loading, error, onViewAllClick }: InvoicesSummaryCardProps): React.JSX.Element;

type BillingUsageSummaryCardProps = {
    meters: MeterInterface[];
    summaries: Record<string, MeterSummaryInterface | null>;
    loading?: boolean;
    error?: string;
    onViewDetailsClick: () => void;
};
declare function BillingUsageSummaryCard({ meters, summaries, loading, error, onViewDetailsClick, }: BillingUsageSummaryCardProps): React.JSX.Element;

declare function BillingDashboardContainer(): React.JSX.Element;

type BillingDetailModalProps = {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    title: string;
    children: ReactNode;
    className?: string;
};
declare function BillingDetailModal({ open, onOpenChange, title, children, className }: BillingDetailModalProps): React.JSX.Element;

declare function StripeProvider({ children }: {
    children: ReactNode;
}): React.JSX.Element;
declare function isStripeConfigured(): boolean;

/**
 * Format price recurring interval for display
 * @param price - Stripe price object
 * @returns Formatted interval string (e.g., "/month", "/year", "/2 weeks", "one-time")
 */
declare function formatInterval(price: StripePriceInterface): string;
/**
 * Format currency amount from cents to localized currency string
 * @param amount - Amount in cents
 * @param currency - Currency code (e.g., "USD", "EUR", "GBP")
 * @returns Formatted currency string (e.g., "$9.99", "€9,99")
 */
declare function formatCurrency(amount: number | undefined, currency: string): string;

/**
 * Format a date to a localized date string
 * @param date - Date object or ISO string
 * @returns Formatted date string (e.g., "Jan 15, 2025")
 */
declare function formatDate(date: Date | string | undefined): string;

type BillingAlertBannerProps = {
    subscription: StripeSubscriptionInterface;
    onUpdatePayment?: () => void;
    onAddPayment?: () => void;
};
declare function BillingAlertBanner({ subscription, onUpdatePayment, onAddPayment }: BillingAlertBannerProps): React.JSX.Element | null;

interface PriceContextType {
    price: StripePriceInterface | undefined;
    setPrice: (value: StripePriceInterface | undefined) => void;
    reloadPrice: () => Promise<void>;
    createPrice: (input: StripePriceInput) => Promise<StripePriceInterface>;
    updatePrice: (input: StripePriceInput) => Promise<StripePriceInterface>;
    archivePrice: (id?: string) => Promise<void>;
    restorePrice: (id?: string) => Promise<void>;
    /** Bumped by every mutation. Mounted lists re-fetch on it. */
    priceVersion: number;
    refreshPrices: () => void;
    /** Product a newly created price attaches to. Set in list mode (prices tab). */
    productId: string | undefined;
}
type PriceProviderProps = {
    children: ReactNode;
    dehydratedPrice?: JsonApiHydratedDataInterface;
    /**
     * Publish breadcrumbs + title into SharedProvider. Pass `false` when this
     * provider is mounted INSIDE another entity's page (the prices tab mounts
     * PriceProvider that way): SharedProvider replaces its value for the subtree
     * rather than merging (SharedContext.tsx:35-37), so a nested provider that
     * publishes chrome would blank the host page's title.
     */
    publishChrome?: boolean;
    /** Required in list mode (the prices tab) so new prices attach to the right product. */
    productId?: string;
};
/** Human label for a price: its nickname, else amount + interval. */
declare function priceLabel(price: StripePriceInterface): string;
declare const PriceProvider: ({ children, dehydratedPrice, publishChrome, productId: productIdProp, }: PriceProviderProps) => React.JSX.Element;
declare const usePriceContext: () => PriceContextType;

interface ProductContextType {
    product: StripeProductInterface | undefined;
    setProduct: (value: StripeProductInterface | undefined) => void;
    reloadProduct: () => Promise<void>;
    createProduct: (input: StripeProductInput) => Promise<StripeProductInterface>;
    updateProduct: (input: StripeProductInput) => Promise<StripeProductInterface>;
    archiveProduct: (id?: string) => Promise<void>;
    restoreProduct: (id?: string) => Promise<void>;
    /** Bumped by every mutation. Mounted lists re-fetch on it. */
    catalogueVersion: number;
    refreshCatalogue: () => void;
}
type ProductProviderProps = {
    children: ReactNode;
    dehydratedProduct?: JsonApiHydratedDataInterface;
    /**
     * Publish breadcrumbs + title into SharedProvider. Pass `false` when this
     * provider is mounted INSIDE another entity's page (the prices tab mounts
     * PriceProvider that way): SharedProvider replaces its value for the subtree
     * rather than merging (SharedContext.tsx:35-37), so a nested provider that
     * publishes chrome would blank the host page's title.
     */
    publishChrome?: boolean;
};
declare const ProductProvider: ({ children, dehydratedProduct, publishChrome }: ProductProviderProps) => React.JSX.Element;
declare const useProductContext: () => ProductContextType;

declare function PaymentMethodsContainer(): React.JSX.Element;

type PaymentMethodCardProps = {
    paymentMethod: PaymentMethodInterface;
    onUpdate: () => void;
};
declare function PaymentMethodCard({ paymentMethod, onUpdate }: PaymentMethodCardProps): React.JSX.Element;

type PaymentMethodEditorProps = {
    open: boolean;
    onOpenChange: (open: boolean) => void;
    onSuccess: () => void;
};
declare function PaymentMethodEditor({ open, onOpenChange, onSuccess }: PaymentMethodEditorProps): React.JSX.Element;

type PaymentMethodFormProps = {
    onSuccess: () => void;
    onCancel: () => void;
    isLoading?: boolean;
};
declare function PaymentMethodForm({ onSuccess, onCancel, isLoading }: PaymentMethodFormProps): React.JSX.Element;

type PaymentMethodsListProps = {
    paymentMethods: PaymentMethodInterface[];
    onUpdate: () => void;
};
declare function PaymentMethodsList({ paymentMethods, onUpdate }: PaymentMethodsListProps): React.JSX.Element;

declare function InvoicesContainer(): React.JSX.Element;

type InvoiceDetailsProps = {
    invoice: StripeInvoiceInterface;
    open: boolean;
    onOpenChange: (open: boolean) => void;
    onInvoiceChange: () => void;
};
declare function InvoiceDetails({ invoice, open, onOpenChange, onInvoiceChange: _onInvoiceChange, }: InvoiceDetailsProps): React.JSX.Element;

type InvoicesListProps = {
    invoices: StripeInvoiceInterface[];
    onInvoicesChange: () => void;
};
declare function InvoicesList({ invoices, onInvoicesChange }: InvoicesListProps): React.JSX.Element;

type InvoiceStatusBadgeProps = {
    status: InvoiceStatus;
};
declare function InvoiceStatusBadge({ status }: InvoiceStatusBadgeProps): React.JSX.Element;

declare function PriceContainer(): React.JSX.Element | null;

declare function PriceDetails(): React.JSX.Element | null;

type PriceArchiverProps = {
    price: StripePriceInterface;
};
/**
 * Archive / restore control for a price. Built on ConfirmDialog, which is
 * controlled and trigger-less by design — the caller owns the trigger button,
 * so none of Base UI's trigger-composition pitfalls apply (no asChild, no
 * nested <button>).
 */
declare function PriceArchiver({ price }: PriceArchiverProps): React.JSX.Element;

type PriceEditorProps = {
    productId?: string;
    price?: StripePriceInterface;
    propagateChanges?: (price: StripePriceInterface) => void;
    onSuccess?: () => void | Promise<void>;
    trigger?: ReactNode;
    forceShow?: boolean;
    onClose?: () => void;
    dialogOpen?: boolean;
    onDialogOpenChange?: (open: boolean) => void;
};
declare function PriceEditor(props: PriceEditorProps): React.JSX.Element;

type PricesListProps = {
    productId: string;
    /**
     * Only when the list IS the page's own content inside a `RoundPageContainer
     * fullWidth`. Inside a tab panel leave it unset, or ContentListTable drops its
     * own `rounded-md border` and the table floats borderless in the panel.
     * Mirrors ThreatList, which is rendered both ways.
     */
    fullWidth?: boolean;
};
declare function PricesList({ productId, fullWidth }: PricesListProps): React.JSX.Element;

declare function ProductContainer(): React.JSX.Element | null;

/**
 * Page container for the administrative product list.
 *
 * Client component by necessity: `module={Modules.StripeProduct}` is a registry
 * entry carrying an icon component and methods, which a Server Component cannot
 * pass across the boundary. Routes mount this container instead — the same
 * shape as every other list page.
 *
 * No `forceHeader`: ContentListTable draws its own header row with the title
 * and the create action, exactly as the company and user list pages do.
 */
declare function ProductsListContainer(): React.JSX.Element;

declare function ProductDetails(): React.JSX.Element | null;

type ProductArchiverProps = {
    product: StripeProductInterface;
};
/**
 * Archive / restore control for a product. Built on ConfirmDialog, which is
 * controlled and trigger-less by design — the caller owns the trigger button,
 * so none of Base UI's trigger-composition pitfalls apply (no asChild, no
 * nested <button>).
 */
declare function ProductArchiver({ product }: ProductArchiverProps): React.JSX.Element;

type ProductEditorProps = {
    product?: StripeProductInterface;
    propagateChanges?: (product: StripeProductInterface) => void;
    onSuccess?: () => void | Promise<void>;
    trigger?: ReactNode;
    forceShow?: boolean;
    onClose?: () => void;
    dialogOpen?: boolean;
    onDialogOpenChange?: (open: boolean) => void;
};
declare function ProductEditor(props: ProductEditorProps): React.JSX.Element;

type ProductsListProps = {
    /**
     * Pass this whenever the list is the page's own content inside a
     * `RoundPageContainer fullWidth`. Without it ContentListTable wraps itself in
     * `rounded-md border`, drawing a second bordered card inside the page's
     * rounded shell.
     */
    fullWidth?: boolean;
};
declare function ProductsList({ fullWidth }?: ProductsListProps): React.JSX.Element;

type SubscriptionsContainerProps = {
    onOpenWizard?: (subscription?: StripeSubscriptionInterface) => void;
    hasActiveRecurringSubscription?: boolean;
};
declare function SubscriptionsContainer({ onOpenWizard, hasActiveRecurringSubscription }: SubscriptionsContainerProps): React.JSX.Element;

type SubscriptionDetailsProps = {
    subscription: StripeSubscriptionInterface;
    open: boolean;
    onOpenChange: (open: boolean) => void;
    onSubscriptionChange: () => void;
    onChangePlan?: (subscription: StripeSubscriptionInterface) => void;
};
declare function SubscriptionDetails({ subscription, open, onOpenChange, onSubscriptionChange, onChangePlan, }: SubscriptionDetailsProps): React.JSX.Element;

type CancelSubscriptionDialogProps = {
    subscription: StripeSubscriptionInterface;
    open: boolean;
    onOpenChange: (open: boolean) => void;
    onSuccess: () => void;
};
declare function CancelSubscriptionDialog({ subscription, open, onOpenChange, onSuccess, }: CancelSubscriptionDialogProps): React.JSX.Element;

type SubscriptionsListProps = {
    subscriptions: StripeSubscriptionInterface[];
    onSubscriptionsChange: () => void;
    onChangePlan?: (subscription: StripeSubscriptionInterface) => void;
};
declare function SubscriptionsList({ subscriptions, onSubscriptionsChange, onChangePlan }: SubscriptionsListProps): React.JSX.Element;

type BillingInterval = "month" | "year";
type IntervalToggleProps = {
    value: BillingInterval;
    onChange: (interval: BillingInterval) => void;
    hasMonthly: boolean;
    hasYearly: boolean;
};
declare function IntervalToggle({ value, onChange, hasMonthly, hasYearly }: IntervalToggleProps): React.JSX.Element | null;

type PricingCardProps = {
    price: StripePriceInterface;
    isCurrentPlan?: boolean;
    isSelected?: boolean;
    isDisabled?: boolean;
    isLoading?: boolean;
    onSelect: (price: StripePriceInterface) => void;
};
declare function PricingCard({ price, isCurrentPlan, isSelected, isDisabled, isLoading, onSelect, }: PricingCardProps): React.JSX.Element;

type ProductPricingListProps = {
    products: StripeProductInterface[];
    selectedInterval: BillingInterval;
    currentPriceId?: string;
    selectedPriceId?: string;
    loadingPriceId?: string;
    loading?: boolean;
    onSelectPrice: (price: StripePriceInterface) => void;
    hideRecurringPrices?: boolean;
    hideOneTimePrices?: boolean;
};
declare function ProductPricingList({ products, selectedInterval, currentPriceId, selectedPriceId, loadingPriceId, loading, onSelectPrice, hideRecurringPrices, hideOneTimePrices, }: ProductPricingListProps): React.JSX.Element;

type ProductPricingRowProps = {
    product: StripeProductInterface;
    prices: StripePriceInterface[];
    currentPriceId?: string;
    selectedPriceId?: string;
    loadingPriceId?: string;
    onSelectPrice: (price: StripePriceInterface) => void;
};
declare function ProductPricingRow({ product, prices, currentPriceId, selectedPriceId, loadingPriceId, onSelectPrice, }: ProductPricingRowProps): React.JSX.Element | null;

type ProrationPreviewProps = {
    preview: ProrationPreviewInterface;
};
declare function ProrationPreview({ preview }: ProrationPreviewProps): React.JSX.Element;

type SubscriptionStatusBadgeProps = {
    status: SubscriptionStatus;
    cancelAtPeriodEnd?: boolean;
};
declare function SubscriptionStatusBadge({ status, cancelAtPeriodEnd }: SubscriptionStatusBadgeProps): React.JSX.Element;

type SubscriptionConfirmationProps = {
    price: StripePriceInterface;
    isLoading: boolean;
    onConfirm: () => void;
    onCancel: () => void;
};
declare function SubscriptionConfirmation({ price, isLoading, onConfirm, onCancel }: SubscriptionConfirmationProps): React.JSX.Element;

declare function UsageContainer(): React.JSX.Element | null;

type UsageSummaryCardProps = {
    meter: MeterInterface;
    summary: MeterSummaryInterface | null;
};
declare function UsageSummaryCard({ meter, summary }: UsageSummaryCardProps): React.JSX.Element;

type UsageHistoryTableProps = {
    usageRecords: StripeUsageInterface[];
};
declare function UsageHistoryTable({ usageRecords }: UsageHistoryTableProps): React.JSX.Element;

type UsageSummaryCardsProps = {
    meters: MeterInterface[];
    summaries: Record<string, MeterSummaryInterface | null>;
};
declare function UsageSummaryCards({ meters, summaries }: UsageSummaryCardsProps): React.JSX.Element;

type PromoCodeInputProps = {
    appliedCode: PromotionCodeValidationResult | null;
    isValidating: boolean;
    error: string | null;
    onApply: (code: string) => void;
    onRemove: () => void;
    disabled?: boolean;
};
declare function PromoCodeInput({ appliedCode, isValidating, error, onApply, onRemove, disabled, }: PromoCodeInputProps): React.JSX.Element;

export { BillingAlertBanner, BillingDashboardContainer, BillingDetailModal, type BillingInterval, BillingUsageSummaryCard, CancelSubscriptionDialog, CustomerInfoCard, IntervalToggle, type IntervalToggleProps, InvoiceDetails, InvoiceStatusBadge, InvoicesContainer, InvoicesList, InvoicesSummaryCard, PaymentMethodCard, PaymentMethodEditor, PaymentMethodForm, PaymentMethodSummaryCard, PaymentMethodsContainer, PaymentMethodsList, PriceArchiver, PriceContainer, type PriceContextType, PriceDetails, PriceEditor, type PriceEditorProps, PriceProvider, type PriceProviderProps, PricesList, PricingCard, type PricingCardProps, ProductArchiver, ProductContainer, type ProductContextType, ProductDetails, ProductEditor, type ProductEditorProps, ProductPricingList, type ProductPricingListProps, ProductPricingRow, type ProductPricingRowProps, ProductProvider, type ProductProviderProps, ProductsList, ProductsListContainer, PromoCodeInput, ProrationPreview, StripeProvider, SubscriptionConfirmation, SubscriptionDetails, SubscriptionStatusBadge, SubscriptionSummaryCard, SubscriptionsContainer, SubscriptionsList, UsageContainer, UsageHistoryTable, UsageSummaryCard, UsageSummaryCards, formatCurrency, formatDate, formatInterval, isStripeConfigured, priceLabel, usePriceContext, useProductContext };