vue3-stripe-kit/dist/subscriptions-lite.d.ts

Complete Vue 3 Stripe integration with Payment Elements, Checkout, Subscriptions. TypeScript support, composables, components, modular architecture for payments, billing, and e-commerce

import { Ref } from 'vue';

export declare interface CreateSubscriptionData {
    customer?: string;
    items: SubscriptionItem[];
    payment_behavior?: 'default_incomplete' | 'error_if_incomplete' | 'allow_incomplete';
    payment_settings?: {
        payment_method_types?: string[];
        save_default_payment_method?: 'on_subscription' | 'off';
    };
    expand?: string[];
    metadata?: Record<string, string>;
    description?: string;
    trial_period_days?: number;
    trial_end?: number;
    trial_settings?: TrialSettings;
    billing_cycle_anchor?: number;
    collection_method?: 'charge_automatically' | 'send_invoice';
    days_until_due?: number;
    default_payment_method?: string;
    proration_behavior?: 'create_prorations' | 'none' | 'always_invoice';
    billing_thresholds?: {
        amount_gte?: number;
        reset_billing_cycle_anchor?: boolean;
    };
    cancel_at?: number;
    cancel_at_period_end?: boolean;
    default_source?: string;
    default_tax_rates?: string[];
    off_session?: boolean;
    promotion_code?: string;
    transfer_data?: {
        destination: string;
        amount_percent?: number;
    };
}

export declare function getGlobalConfig(): StripeConfig | null;

declare interface PriceData {
    currency: string;
    product: string | ProductData;
    unit_amount?: number;
    recurring: {
        interval: 'day' | 'week' | 'month' | 'year';
        interval_count?: number;
        usage_type?: 'licensed' | 'metered';
    };
    billing_scheme?: 'per_unit' | 'tiered';
    tiers?: Array<{
        up_to: number | 'inf';
        flat_amount?: number;
        unit_amount?: number;
    }>;
    transform_usage?: {
        divide_by: number;
        round: 'up' | 'down';
    };
}

declare interface ProductData {
    name: string;
    description?: string;
    images?: string[];
    metadata?: Record<string, string>;
    statement_descriptor?: string;
}

declare interface RequestConfig {
    apiEndpoint?: string;
    timeout?: number;
    headers?: Record<string, string>;
    retries?: number;
}

export declare function setGlobalConfig(config: StripeConfig): void;

declare interface StripeConfig {
    publishableKey: string;
    apiVersion?: string;
    locale?: string;
    stripeAccount?: string;
    apiBaseUrl?: string;
    checkoutEndpoint?: string;
    requestTimeout?: number;
    headers?: Record<string, string>;
}

export declare interface StripeError {
    type: string;
    code?: string;
    message: string;
    param?: string;
}

export declare interface SubscriptionConfig extends RequestConfig {
    createEndpoint?: string;
    updateEndpoint?: string;
    cancelEndpoint?: string;
    retrieveEndpoint?: string;
    listEndpoint?: string;
    pauseEndpoint?: string;
    resumeEndpoint?: string;
    createCustomerEndpoint?: string;
    updateCustomerEndpoint?: string;
    retrieveCustomerEndpoint?: string;
    createPriceEndpoint?: string;
    createProductEndpoint?: string;
    listPricesEndpoint?: string;
    listProductsEndpoint?: string;
    retrievePriceEndpoint?: string;
    retrieveProductEndpoint?: string;
    retrieveUpcomingInvoiceEndpoint?: string;
    retrieveInvoiceEndpoint?: string;
    payInvoiceEndpoint?: string;
    listInvoicesEndpoint?: string;
    attachPaymentMethodEndpoint?: string;
    detachPaymentMethodEndpoint?: string;
    listPaymentMethodsEndpoint?: string;
    retrievePaymentMethodEndpoint?: string;
    defaultPaymentBehavior?: 'default_incomplete' | 'error_if_incomplete' | 'allow_incomplete';
    defaultCollectionMethod?: 'charge_automatically' | 'send_invoice';
    defaultProrationBehavior?: 'create_prorations' | 'none' | 'always_invoice';
    defaultTrialDays?: number;
    allowTrialExtension?: boolean;
    cancelAtPeriodEnd?: boolean;
    cancellationReason?: string;
    webhookEndpointSecret?: string;
}

declare interface SubscriptionItem {
    id?: string;
    price: string | PriceData;
    quantity?: number;
    metadata?: Record<string, string>;
}

export declare interface SubscriptionStatus {
    id: string;
    status: 'incomplete' | 'incomplete_expired' | 'trialing' | 'active' | 'past_due' | 'canceled' | 'unpaid';
    customer: string;
    current_period_start: number;
    current_period_end: number;
    trial_start?: number;
    trial_end?: number;
    canceled_at?: number;
    cancel_at?: number;
    cancel_at_period_end: boolean;
    items: {
        data: Array<{
            id: string;
            price: {
                id: string;
                nickname?: string;
                unit_amount: number;
                currency: string;
                recurring: {
                    interval: string;
                    interval_count: number;
                };
            };
            quantity: number;
        }>;
    };
    latest_invoice?: string;
    pending_setup_intent?: string;
    default_payment_method?: string;
    metadata: Record<string, string>;
}

declare interface TrialSettings {
    trial_period_days?: number;
    trial_end?: number;
    trial_from_plan?: boolean;
}

declare interface UpdateSubscriptionData {
    cancel_at_period_end?: boolean;
    default_payment_method?: string;
    description?: string;
    items?: Array<{
        id?: string;
        price?: string;
        quantity?: number;
        deleted?: boolean;
        metadata?: Record<string, string>;
    }>;
    metadata?: Record<string, string>;
    payment_behavior?: 'default_incomplete' | 'error_if_incomplete' | 'allow_incomplete';
    proration_behavior?: 'create_prorations' | 'none' | 'always_invoice';
    proration_date?: number;
    billing_cycle_anchor?: 'now' | 'unchanged';
    trial_end?: number | 'now';
    billing_thresholds?: {
        amount_gte?: number;
        reset_billing_cycle_anchor?: boolean;
    };
    cancel_at?: number;
    default_source?: string;
    default_tax_rates?: string[];
    off_session?: boolean;
    payment_settings?: {
        payment_method_types?: string[];
        save_default_payment_method?: 'on_subscription' | 'off';
    };
    pending_invoice_item_interval?: {
        interval: 'day' | 'week' | 'month' | 'year';
        interval_count?: number;
    };
    promotion_code?: string;
    transfer_data?: {
        destination: string;
        amount_percent?: number;
    };
}

export declare function useSubscriptionsLite(config?: Partial<SubscriptionConfig>): Pick<UseSubscriptionsReturn, 'createSubscription' | 'cancelSubscription' | 'retrieveSubscription' | 'loading' | 'error'>;

declare interface UseSubscriptionsReturn {
    loading: Ref<boolean>;
    error: Ref<StripeError | null>;
    createSubscription: (data: CreateSubscriptionData, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    updateSubscription: (subscriptionId: string, data: UpdateSubscriptionData, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    cancelSubscription: (subscriptionId: string, config?: {
        cancelAtPeriodEnd?: boolean;
        cancellationReason?: string;
    } & Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    retrieveSubscription: (subscriptionId: string, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    listSubscriptions: (params?: {
        customer?: string;
        price?: string;
        status?: string;
        limit?: number;
    }, config?: Partial<SubscriptionConfig>) => Promise<{
        data: SubscriptionStatus[];
        has_more: boolean;
    }>;
    startTrial: (subscriptionId: string, trialEnd: number | Date, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    endTrial: (subscriptionId: string, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    extendTrial: (subscriptionId: string, additionalDays: number, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    changePlan: (subscriptionId: string, newPriceId: string, config?: {
        prorationBehavior?: 'create_prorations' | 'none' | 'always_invoice';
    } & Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    addItem: (subscriptionId: string, priceId: string, quantity?: number, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    removeItem: (subscriptionId: string, itemId: string, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    updateQuantity: (subscriptionId: string, itemId: string, quantity: number, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    resumeSubscription: (subscriptionId: string, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    pauseSubscription: (subscriptionId: string, pauseBehavior?: {
        behavior: 'mark_uncollectible' | 'keep_as_draft' | 'void';
    }, config?: Partial<SubscriptionConfig>) => Promise<SubscriptionStatus>;
    getUpcomingInvoice: (customerId: string, subscriptionId?: string, config?: Partial<SubscriptionConfig>) => Promise<any>;
    payInvoice: (invoiceId: string, config?: Partial<SubscriptionConfig>) => Promise<any>;
    createCustomer: (data: {
        email?: string;
        name?: string;
        payment_method?: string;
        metadata?: Record<string, string>;
    }, config?: Partial<SubscriptionConfig>) => Promise<any>;
    updateCustomer: (customerId: string, data: {
        email?: string;
        name?: string;
        metadata?: Record<string, string>;
    }, config?: Partial<SubscriptionConfig>) => Promise<any>;
    isTrialing: (subscription: SubscriptionStatus) => boolean;
    isActive: (subscription: SubscriptionStatus) => boolean;
    isCanceled: (subscription: SubscriptionStatus) => boolean;
    isPastDue: (subscription: SubscriptionStatus) => boolean;
    daysUntilRenewal: (subscription: SubscriptionStatus) => number;
    daysRemainingInTrial: (subscription: SubscriptionStatus) => number;
}

export { }