import Stripe from 'stripe';
import { Request as Request$1, Response as Response$1 } from 'express';
import { D as DonationTier, a as DonationCheckoutOptions, b as DonationCheckoutResult } from './donation-BosbuKM6.mjs';

declare class StripeServerAPI {
    private stripe;
    constructor(secretKey: string, options?: {
        apiVersion?: string;
        typescript?: boolean;
    });
    createCustomer(params: {
        email: string;
        name?: string;
        phone?: string;
        metadata?: Record<string, string>;
    }): Promise<Stripe.Response<Stripe.Customer>>;
    getCustomer(customerId: string): Promise<Stripe.Response<Stripe.Customer | Stripe.DeletedCustomer>>;
    updateCustomer(customerId: string, params: {
        email?: string;
        name?: string;
        phone?: string;
        metadata?: Record<string, string>;
    }): Promise<Stripe.Response<Stripe.Customer>>;
    deleteCustomer(customerId: string): Promise<Stripe.Response<Stripe.DeletedCustomer>>;
    createSubscription(params: {
        customerId: string;
        priceId: string;
        quantity?: number;
        trialPeriodDays?: number;
        metadata?: Record<string, string>;
        paymentBehavior?: 'default_incomplete' | 'error_if_incomplete' | 'allow_incomplete';
    }): Promise<Stripe.Response<Stripe.Subscription>>;
    getSubscription(subscriptionId: string): Promise<Stripe.Response<Stripe.Subscription>>;
    updateSubscription(subscriptionId: string, params: {
        priceId?: string;
        quantity?: number;
        metadata?: Record<string, string>;
        cancelAtPeriodEnd?: boolean;
    }): Promise<Stripe.Response<Stripe.Subscription>>;
    cancelSubscription(subscriptionId: string, immediately?: boolean): Promise<Stripe.Response<Stripe.Subscription>>;
    reactivateSubscription(subscriptionId: string): Promise<Stripe.Response<Stripe.Subscription>>;
    getCustomerSubscriptions(customerId: string): Promise<Stripe.Response<Stripe.ApiList<Stripe.Subscription>>>;
    createCheckoutSession(params: {
        priceId: string;
        customerId?: string;
        customerEmail?: string;
        successUrl: string;
        cancelUrl: string;
        mode?: 'payment' | 'subscription' | 'setup';
        allowPromotionCodes?: boolean;
        billingAddressCollection?: 'auto' | 'required';
        metadata?: Record<string, string>;
        trialPeriodDays?: number;
    }): Promise<Stripe.Response<Stripe.Checkout.Session>>;
    getPaymentIntent(paymentIntentId: string): Promise<Stripe.Response<Stripe.PaymentIntent>>;
    createPaymentIntent(params: {
        amount: number;
        currency: string;
        customerId?: string;
        paymentMethodTypes?: string[];
        metadata?: Record<string, string>;
        description?: string;
    }): Promise<Stripe.Response<Stripe.PaymentIntent>>;
    confirmPaymentIntent(paymentIntentId: string, params?: {
        paymentMethod?: string;
    }): Promise<Stripe.Response<Stripe.PaymentIntent>>;
    createSetupIntent(params: {
        customerId: string;
        paymentMethodTypes?: string[];
        metadata?: Record<string, string>;
    }): Promise<Stripe.Response<Stripe.SetupIntent>>;
    createPortalSession(params: {
        customerId: string;
        returnUrl: string;
    }): Promise<Stripe.Response<Stripe.BillingPortal.Session>>;
    getCustomerPaymentMethods(customerId: string, type?: Stripe.PaymentMethodListParams.Type): Promise<Stripe.Response<Stripe.ApiList<Stripe.PaymentMethod>>>;
    attachPaymentMethod(paymentMethodId: string, customerId: string): Promise<Stripe.Response<Stripe.PaymentMethod>>;
    detachPaymentMethod(paymentMethodId: string): Promise<Stripe.Response<Stripe.PaymentMethod>>;
    setDefaultPaymentMethod(customerId: string, paymentMethodId: string): Promise<Stripe.Response<Stripe.Customer>>;
    getCustomerInvoices(customerId: string, limit?: number): Promise<Stripe.Response<Stripe.ApiList<Stripe.Invoice>>>;
    getInvoice(invoiceId: string): Promise<Stripe.Response<Stripe.Invoice>>;
    constructWebhookEvent(payload: string | Buffer, signature: string, webhookSecret: string): Stripe.Event;
    getPrice(priceId: string): Promise<Stripe.Response<Stripe.Price>>;
    getPrices(params?: {
        active?: boolean;
        limit?: number;
        product?: string;
    }): Promise<Stripe.Response<Stripe.ApiList<Stripe.Price>>>;
    getProduct(productId: string): Promise<Stripe.Response<Stripe.Product>>;
    createEphemeralKey(customerId: string, apiVersion: string): Promise<Stripe.Response<Stripe.EphemeralKey>>;
}

interface NextApiRequest {
    method?: string;
    headers: Record<string, string | string[] | undefined>;
    body: any;
}
interface NextApiResponse {
    setHeader(name: string, value: string): void;
    status(code: number): NextApiResponse;
    json(body: unknown): void;
}
interface WebhookHandlers {
    onCustomerSubscriptionCreated?: (subscription: Stripe.Subscription) => Promise<void>;
    onCustomerSubscriptionUpdated?: (subscription: Stripe.Subscription) => Promise<void>;
    onCustomerSubscriptionDeleted?: (subscription: Stripe.Subscription) => Promise<void>;
    onInvoicePaymentSucceeded?: (invoice: Stripe.Invoice) => Promise<void>;
    onInvoicePaymentFailed?: (invoice: Stripe.Invoice) => Promise<void>;
    onCheckoutSessionCompleted?: (session: Stripe.Checkout.Session) => Promise<void>;
    onPaymentIntentSucceeded?: (paymentIntent: Stripe.PaymentIntent) => Promise<void>;
    onPaymentIntentPaymentFailed?: (paymentIntent: Stripe.PaymentIntent) => Promise<void>;
}
declare class StripeWebhookHandler {
    private stripeAPI;
    private handlers;
    constructor(secretKey: string, handlers?: WebhookHandlers);
    handleWebhook(payload: string | Buffer, signature: string, webhookSecret: string): Promise<{
        success: boolean;
        error?: string;
    }>;
    private processEvent;
    private handleSubscriptionCreated;
    private handleSubscriptionUpdated;
    private handleSubscriptionDeleted;
    private handleInvoicePaymentSucceeded;
    private handleInvoicePaymentFailed;
    private handleCheckoutSessionCompleted;
    private handlePaymentIntentSucceeded;
    private handlePaymentIntentFailed;
}
declare const createStripeWebhookHandler: (secretKey: string, handlers?: WebhookHandlers) => StripeWebhookHandler;
declare const createStripeWebhookMiddleware: (secretKey: string, webhookSecret: string, handlers?: WebhookHandlers) => (req: Request$1, res: Response$1) => Promise<Response$1<any, Record<string, any>> | undefined>;
/**
 * Next.js App Router webhook handler (Next.js 13+ with `app/` directory).
 *
 * Returns a `POST` function suitable for use in `app/api/.../route.ts` files.
 * Uses the Web-standard `Request`/`Response` API instead of Pages Router types.
 *
 * @example
 * ```ts
 * // app/api/stripe-webhook/route.ts
 * import { createAppRouterWebhookHandler } from '@digilogiclabs/saas-factory-payments/server';
 *
 * export const POST = createAppRouterWebhookHandler(
 *   process.env.STRIPE_SECRET_KEY!,
 *   process.env.STRIPE_WEBHOOK_SECRET!,
 *   {
 *     onCheckoutSessionCompleted: async (session) => {
 *       if (session.metadata?.product_type === 'donation') {
 *         // Handle donation...
 *       }
 *     },
 *   },
 * );
 * ```
 */
declare const createAppRouterWebhookHandler: (secretKey: string, webhookSecret: string, handlers?: WebhookHandlers) => (request: Request) => Promise<Response>;
/** @deprecated Use `createAppRouterWebhookHandler` for Next.js 13+ App Router. */
declare const createNextJSWebhookHandler: (secretKey: string, webhookSecret: string, handlers?: WebhookHandlers) => (req: NextApiRequest, res: NextApiResponse) => Promise<void>;

interface CreateCheckoutSessionOptions {
    priceId: string;
    customerId?: string;
    successUrl: string;
    cancelUrl: string;
    mode?: 'payment' | 'subscription' | 'setup';
    metadata?: Record<string, string>;
}
interface ProcessPaymentOptions {
    amount: number;
    currency: string;
    paymentMethodId: string;
    customerId?: string;
    description?: string;
    metadata?: Record<string, string>;
}
interface CreateSubscriptionOptions {
    customerId: string;
    priceId: string;
    paymentMethodId?: string;
    trialPeriodDays?: number;
    metadata?: Record<string, string>;
}
interface UpdateSubscriptionOptions {
    subscriptionId: string;
    priceId?: string;
    quantity?: number;
    metadata?: Record<string, string>;
}
/**
 * Create a Stripe checkout session
 */
declare const createStripeCheckoutSession: (stripe: Stripe, options: CreateCheckoutSessionOptions) => Promise<Stripe.Checkout.Session>;
/**
 * Process a one-time payment
 */
declare const processPayment: (stripe: Stripe, options: ProcessPaymentOptions) => Promise<Stripe.PaymentIntent>;
/**
 * Create a subscription
 */
declare const createSubscription: (stripe: Stripe, options: CreateSubscriptionOptions) => Promise<Stripe.Subscription>;
/**
 * Update a subscription
 */
declare const updateSubscription: (stripe: Stripe, options: UpdateSubscriptionOptions) => Promise<Stripe.Subscription>;
/**
 * Cancel a subscription
 */
declare const cancelSubscription: (stripe: Stripe, subscriptionId: string, cancelAtPeriodEnd?: boolean) => Promise<Stripe.Subscription>;
/**
 * Create a donation checkout session using inline price_data.
 *
 * Unlike `createStripeCheckoutSession` which requires a pre-created Price ID,
 * this uses Stripe's inline `price_data` so apps don't need any Stripe
 * Dashboard setup. Stripe auto-creates the products on first use.
 *
 * Supports:
 * - Named tiers with fixed amounts (one-time or monthly)
 * - Custom amounts with configurable recurrence
 * - Metadata tagging for webhook identification
 *
 * @example
 * ```ts
 * const tiers: DonationTier[] = [
 *   { id: 'fan', name: 'Fan', description: 'Monthly $3 support', amountCents: 300, recurring: true },
 *   { id: 'gold', name: 'Gold', description: 'One-time $25 donation', amountCents: 2500 },
 * ];
 *
 * const result = await createDonationCheckout(stripe, tiers, {
 *   tier: 'fan',
 *   successUrl: 'https://example.com/thank-you?session_id={CHECKOUT_SESSION_ID}',
 *   cancelUrl: 'https://example.com/support',
 * });
 * // result.url → redirect user here
 * ```
 */
declare const createDonationCheckout: (stripe: Stripe, tiers: DonationTier[], options: DonationCheckoutOptions) => Promise<DonationCheckoutResult>;
/**
 * Validate Stripe webhook signature
 */
declare const validateStripeSignature: (payload: string | Buffer, signature: string, endpointSecret: string) => Stripe.Event;
/**
 * Handle common Stripe webhook events
 */
declare const handleStripeWebhook: (event: Stripe.Event, handlers: {
    onPaymentSucceeded?: (paymentIntent: Stripe.PaymentIntent) => Promise<void>;
    onPaymentFailed?: (paymentIntent: Stripe.PaymentIntent) => Promise<void>;
    onSubscriptionCreated?: (subscription: Stripe.Subscription) => Promise<void>;
    onSubscriptionUpdated?: (subscription: Stripe.Subscription) => Promise<void>;
    onSubscriptionDeleted?: (subscription: Stripe.Subscription) => Promise<void>;
    onInvoicePaid?: (invoice: Stripe.Invoice) => Promise<void>;
    onInvoicePaymentFailed?: (invoice: Stripe.Invoice) => Promise<void>;
}) => Promise<void>;

export { type CreateCheckoutSessionOptions, type CreateSubscriptionOptions, DonationCheckoutOptions, DonationCheckoutResult, DonationTier, type ProcessPaymentOptions, StripeServerAPI, StripeWebhookHandler, type UpdateSubscriptionOptions, type WebhookHandlers, cancelSubscription, createAppRouterWebhookHandler, createDonationCheckout, createNextJSWebhookHandler, createStripeCheckoutSession, createStripeWebhookHandler, createStripeWebhookMiddleware, createSubscription, handleStripeWebhook, processPayment, updateSubscription, validateStripeSignature };