import { AxiosRequestConfig, AxiosInstance } from 'axios';
import { L as ListResponse, P as PaginationParams } from './common-DxOEZ2Dn.cjs';
import { CustomerListParams, Customer, CreateCustomerRequest, UpdateCustomerRequest, Order, InvoiceListParams, Invoice, CreatePaymentMethodRequest, PaymentMethod, UpdatePaymentMethodRequest, ListDiscountRedemptionsParams, DiscountRedemption, CustomerMrrResponse, Product, CreateProductRequest, UpdateProductRequest, Variant, CreateVariantRequest, UpdateVariantRequest, Price, CreatePriceRequest, UpdatePriceRequest, SubscriptionListParams, Subscription, CreateSubscriptionRequest, UpdateSubscriptionRequest, PauseSubscriptionRequest, ResumeSubscriptionRequest, ActivateSubscriptionRequest, CancelSubscriptionRequest, ChangePlanRequest, UpdateBillingAnchorRequest, Payment, UsageEventResponse, UsageEstimateResponse, CloudEventUsageRequest, CloudEventUsageResponse, RecordUsageRequest, UsageRecord, BatchRecordUsageRequest, UsageSummary, CreateOrganizationRequest, Organization, ApiKey, Meter, CreateMeterRequest, UpdateMeterRequest, CreateOrderRequest, CompleteOrderRequest, AddCartItemRequest, RemoveCartItemRequest, PaymentListParams, RefundPaymentRequest, Refund, CreateInvoiceRequest, UpdateInvoiceRequest, InvoiceLineItem, CreateInvoiceLineItemRequest, UpdateInvoiceLineItemRequest, InvoiceHistory, CreateInvoicePaymentLinkRequest, PaymentLinkResponse, InitiateInvoicePaymentRequest, InitiatePaymentResponse, DunningCampaignListParams, DunningCampaign, UpdateDunningCampaignRequest, DunningAttempt, DunningCommunication, DunningConfiguration, CreateDunningConfigurationRequest, UpdateDunningConfigurationRequest, VerifyPaymentTokenRequest, PaymentTokenVerification, ActivatePaymentTokenRequest, PaymentToken, WebhookSubscription, CreateWebhookRequest, RevenueReport, SubscriberReport, RefundReport, ChurnReport, Setting, CreateSettingRequest, UpdateSettingRequest, PspConfiguration, CreatePspConfigurationRequest, CreateSessionRequest, Session, ListDiscountsParams, Discount, CreateDiscountRequest, UpdateDiscountRequest, ValidateDiscountRequest, DiscountValidationResponse, ApplyDiscountRequest, DiscountApplicationResponse, ListPaymentLinksParams, CreatePaymentLinkRequest, UpdatePaymentLinkRequest, ListPaymentLinkUsagesParams, PaymentLinkUsageResponse, RecordPaymentLinkUsageRequest, CartResponse, ValidateCouponRequest, PublicPaymentDetailsResponse, PublicCreateOrderRequest, CreateOrderResponse, PublicOrderStatusResponse } from './types/index.cjs';

interface AuthConfig {
    apiKey?: string;
    getToken?: () => Promise<string | null>;
    token?: string;
}
declare class AuthManager {
    private config;
    constructor(config: AuthConfig);
    applyAuth(requestConfig: AxiosRequestConfig): Promise<AxiosRequestConfig>;
    updateApiKey(apiKey: string): void;
    getAuthType(): 'apiKey' | 'bearer' | 'token' | null;
}

interface HttpClientConfig {
    baseURL: string;
    timeout?: number;
    retries?: number;
    retryDelay?: number;
    userAgent?: string;
}
declare class HttpClient {
    private client;
    private authManager;
    constructor(config: HttpClientConfig, authManager: AuthManager);
    get<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
    post<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
    put<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
    patch<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
    delete<T = void>(url: string, config?: AxiosRequestConfig): Promise<T>;
    getAxiosInstance(): AxiosInstance;
}

declare class CustomersResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    list(params?: CustomerListParams): Promise<ListResponse<Customer>>;
    create(data: CreateCustomerRequest): Promise<Customer>;
    get(customerId: string): Promise<Customer>;
    update(customerId: string, data: UpdateCustomerRequest): Promise<Customer>;
    delete(customerId: string): Promise<void>;
    suspend(customerId: string): Promise<Customer>;
    activate(customerId: string): Promise<Customer>;
    getOrders(_customerId: string): Promise<Order[]>;
    listInvoices(customerId: string, params?: InvoiceListParams): Promise<ListResponse<Invoice>>;
    createPaymentMethod(customerId: string, data: CreatePaymentMethodRequest): Promise<PaymentMethod>;
    listPaymentMethods(customerId: string): Promise<PaymentMethod[]>;
    getPaymentMethod(customerId: string, paymentMethodId: string): Promise<PaymentMethod>;
    updatePaymentMethod(customerId: string, paymentMethodId: string, data: UpdatePaymentMethodRequest): Promise<PaymentMethod>;
    deletePaymentMethod(customerId: string, paymentMethodId: string): Promise<void>;
    getDunningHistory(customerId: string): Promise<any[]>;
    /**
     * List customer discount redemptions
     */
    listDiscountRedemptions(customerId: string, params?: ListDiscountRedemptionsParams): Promise<ListResponse<DiscountRedemption>>;
    /**
     * Get customer MRR calculation
     * Calculate Monthly Recurring Revenue (MRR) for a specific customer,
     * including breakdown by subscription and projected annual revenue
     */
    getMrr(customerId: string): Promise<CustomerMrrResponse>;
}

declare class ProductsResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    list(params?: PaginationParams): Promise<ListResponse<Product>>;
    create(data: CreateProductRequest): Promise<Product>;
    get(productId: string): Promise<Product>;
    update(productId: string, data: UpdateProductRequest): Promise<Product>;
    delete(productId: string): Promise<void>;
    listVariants(productId: string): Promise<Variant[]>;
    createVariant(productId: string, data: CreateVariantRequest): Promise<Variant>;
}
declare class VariantsResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    get(variantId: string): Promise<Variant>;
    update(variantId: string, data: UpdateVariantRequest): Promise<Variant>;
    delete(variantId: string): Promise<void>;
    listPrices(variantId: string): Promise<Price[]>;
}
declare class PricesResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    create(data: CreatePriceRequest): Promise<Price>;
    get(priceId: string): Promise<Price>;
    update(priceId: string, data: UpdatePriceRequest): Promise<Price>;
    delete(priceId: string): Promise<void>;
}

declare class SubscriptionsResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    list(params?: SubscriptionListParams): Promise<ListResponse<Subscription>>;
    create(data: CreateSubscriptionRequest): Promise<Subscription>;
    get(subscriptionId: string): Promise<Subscription>;
    update(subscriptionId: string, data: UpdateSubscriptionRequest): Promise<Subscription>;
    pause(subscriptionId: string, data: PauseSubscriptionRequest): Promise<Subscription>;
    resume(subscriptionId: string, data: ResumeSubscriptionRequest): Promise<Subscription>;
    activate(subscriptionId: string, data?: ActivateSubscriptionRequest): Promise<Subscription>;
    cancel(subscriptionId: string, data: CancelSubscriptionRequest): Promise<Subscription>;
    changePlan(subscriptionId: string, data: ChangePlanRequest): Promise<{
        subscription: Subscription;
        plan_change: any;
    }>;
    updateBillingAnchor(subscriptionId: string, data: UpdateBillingAnchorRequest): Promise<{
        subscription: Subscription;
        proration_details: any;
    }>;
    listPayments(subscriptionId: string, params?: PaginationParams): Promise<ListResponse<Payment>>;
    getUsage(subscriptionId: string, params?: {
        start_date?: string;
        end_date?: string;
    }): Promise<{
        items: UsageEventResponse[];
        count: number;
    }>;
    getUsageEstimate(subscriptionId: string): Promise<UsageEstimateResponse>;
}

declare class UsageResource {
    private httpClient;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    recordCloudEvent(data: CloudEventUsageRequest): Promise<CloudEventUsageResponse>;
    record(data: RecordUsageRequest): Promise<UsageRecord>;
    batchRecord(data: BatchRecordUsageRequest): Promise<{
        records: UsageRecord[];
        total_count: number;
    }>;
    list(params: {
        subscription_item_id: string;
    } & PaginationParams): Promise<ListResponse<UsageRecord>>;
    getUsageRecord(usageRecordId: string): Promise<UsageRecord>;
    deleteUsageRecord(usageRecordId: string): Promise<void>;
    getSummary(subscriptionItemId: string, params: {
        start_date: string;
        end_date: string;
    }): Promise<UsageSummary>;
}

declare class OrganizationsResource {
    private httpClient;
    constructor(httpClient: HttpClient);
    create(data: CreateOrganizationRequest): Promise<Organization>;
    getApiKeys(): Promise<ApiKey[]>;
}

declare class MetersResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    list(params?: PaginationParams): Promise<ListResponse<Meter>>;
    create(data: CreateMeterRequest): Promise<Meter>;
    get(meterId: string): Promise<Meter>;
    getBySlug(slug: string): Promise<Meter>;
    update(meterId: string, data: UpdateMeterRequest): Promise<Meter>;
    delete(meterId: string): Promise<void>;
}

declare class OrdersResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    list(params?: PaginationParams): Promise<ListResponse<Order>>;
    create(data: CreateOrderRequest): Promise<Order>;
    get(orderId: string): Promise<Order>;
    complete(orderId: string, data: CompleteOrderRequest): Promise<Order>;
    /**
     * Add item to cart
     */
    addCartItem(cartId: string, data: AddCartItemRequest): Promise<{
        status: string;
    }>;
    /**
     * Remove item from cart
     */
    removeCartItem(cartId: string, data: RemoveCartItemRequest): Promise<{
        status: string;
    }>;
    /**
     * List subscriptions created from an order
     */
    listSubscriptions(orderId: string): Promise<any[]>;
}

declare class PaymentsResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    list(params?: PaymentListParams): Promise<ListResponse<Payment>>;
    get(paymentId: string): Promise<Payment>;
    refund(paymentId: string, data: RefundPaymentRequest): Promise<Refund>;
    getPaymentMethod(paymentMethodId: string): Promise<PaymentMethod>;
}

declare class InvoicesResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    list(params?: InvoiceListParams): Promise<ListResponse<Invoice>>;
    create(data: CreateInvoiceRequest): Promise<Invoice>;
    get(invoiceId: string): Promise<Invoice>;
    update(invoiceId: string, data: UpdateInvoiceRequest): Promise<Invoice>;
    performAction(invoiceId: string, action: 'send' | 'finalize' | 'void' | 'mark_paid'): Promise<Invoice>;
    send(invoiceId: string): Promise<Invoice>;
    finalize(invoiceId: string): Promise<Invoice>;
    void(invoiceId: string): Promise<Invoice>;
    markPaid(invoiceId: string): Promise<Invoice>;
    listLineItems(invoiceId: string): Promise<InvoiceLineItem[]>;
    addLineItem(invoiceId: string, data: CreateInvoiceLineItemRequest): Promise<InvoiceLineItem>;
    updateLineItem(invoiceId: string, lineItemId: string, data: UpdateInvoiceLineItemRequest): Promise<InvoiceLineItem>;
    deleteLineItem(invoiceId: string, lineItemId: string): Promise<{
        status: string;
    }>;
    listHistory(invoiceId: string): Promise<InvoiceHistory[]>;
    generatePdf(invoiceId: string): Promise<Blob>;
    /**
     * Create payment link for invoice
     */
    createPaymentLink(invoiceId: string, data?: CreateInvoicePaymentLinkRequest): Promise<PaymentLinkResponse>;
    /**
     * Initiate payment for invoice
     */
    initiatePayment(invoiceId: string, data: InitiateInvoicePaymentRequest): Promise<InitiatePaymentResponse>;
}

declare class DunningResource {
    private httpClient;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    listCampaigns(params?: DunningCampaignListParams): Promise<ListResponse<DunningCampaign>>;
    getCampaign(campaignId: string): Promise<DunningCampaign>;
    updateCampaign(campaignId: string, data: UpdateDunningCampaignRequest): Promise<DunningCampaign>;
    listCampaignAttempts(campaignId: string): Promise<DunningAttempt[]>;
    triggerManualAttempt(campaignId: string): Promise<DunningAttempt>;
    listCampaignCommunications(campaignId: string): Promise<DunningCommunication[]>;
    listConfigurations(): Promise<DunningConfiguration[]>;
    createConfiguration(data: CreateDunningConfigurationRequest): Promise<DunningConfiguration>;
    getConfiguration(configId: string): Promise<DunningConfiguration>;
    updateConfiguration(configId: string, data: UpdateDunningConfigurationRequest): Promise<DunningConfiguration>;
    verifyPaymentToken(data: VerifyPaymentTokenRequest): Promise<PaymentTokenVerification>;
    activatePaymentToken(data: ActivatePaymentTokenRequest): Promise<{
        status: string;
    }>;
    createSubscriptionPaymentToken(subscriptionId: string): Promise<PaymentToken>;
}

declare class WebhooksResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    list(): Promise<WebhookSubscription[]>;
    create(data: CreateWebhookRequest): Promise<WebhookSubscription>;
    processWebhook(data: any): Promise<{
        status: string;
    }>;
    processCdcWebhook(data: any): Promise<{
        status: string;
    }>;
}

declare class ReportsResource {
    private httpClient;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    getMrr(params?: {
        start_date?: string;
        end_date?: string;
    }): Promise<RevenueReport>;
    getArr(params?: {
        year?: number;
    }): Promise<RevenueReport>;
    getActiveSubscribers(params?: {
        date?: string;
    }): Promise<SubscriberReport>;
    getRefundTotals(params?: {
        start_date?: string;
        end_date?: string;
    }): Promise<RefundReport>;
    getChurnTotals(params?: {
        start_date?: string;
        end_date?: string;
    }): Promise<ChurnReport>;
    getChurnRates(params?: {
        period?: 'monthly' | 'quarterly' | 'yearly';
    }): Promise<ChurnReport>;
}

declare class SettingsResource {
    private httpClient;
    constructor(httpClient: HttpClient);
    list(parentId: string): Promise<Setting[]>;
    create(parentId: string, data: CreateSettingRequest): Promise<Setting>;
    get(parentId: string, settingId: string): Promise<Setting>;
    update(parentId: string, settingId: string, data: UpdateSettingRequest): Promise<Setting>;
    delete(parentId: string, settingId: string): Promise<void>;
}

declare class GatewaysResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    private buildQueryString;
    /**
     * List payment gateways
     */
    list(params?: PaginationParams): Promise<ListResponse<PspConfiguration>>;
    /**
     * Create a payment gateway
     */
    create(data: CreatePspConfigurationRequest): Promise<PspConfiguration>;
    /**
     * Get a gateway by ID
     */
    get(gatewayId: string): Promise<PspConfiguration>;
    /**
     * Update a gateway
     */
    update(gatewayId: string, data: Partial<CreatePspConfigurationRequest>): Promise<PspConfiguration>;
    /**
     * Delete a gateway
     */
    delete(gatewayId: string): Promise<void>;
}

declare class SessionsResource {
    private httpClient;
    constructor(httpClient: HttpClient);
    create(data: CreateSessionRequest): Promise<Session>;
}

declare class DiscountsResource {
    private httpClient;
    constructor(httpClient: HttpClient);
    /**
     * List all discounts
     */
    list(params?: ListDiscountsParams): Promise<ListResponse<Discount>>;
    /**
     * Create a new discount
     */
    create(data: CreateDiscountRequest): Promise<Discount>;
    /**
     * Get a discount by ID
     */
    get(id: string): Promise<Discount>;
    /**
     * Update a discount
     */
    update(id: string, data: UpdateDiscountRequest): Promise<Discount>;
    /**
     * Delete a discount
     */
    delete(id: string): Promise<void>;
    /**
     * Validate a discount code
     */
    validate(data: ValidateDiscountRequest): Promise<DiscountValidationResponse>;
    /**
     * Apply a discount
     */
    apply(data: ApplyDiscountRequest): Promise<DiscountApplicationResponse>;
    /**
     * List discount redemptions for a specific discount
     */
    listRedemptions(discountId: string, params?: ListDiscountRedemptionsParams): Promise<ListResponse<DiscountRedemption>>;
}

declare class PaymentLinksResource {
    private httpClient;
    constructor(httpClient: HttpClient);
    /**
     * List all payment links
     */
    list(params?: ListPaymentLinksParams): Promise<ListResponse<PaymentLinkResponse>>;
    /**
     * Create a new payment link
     */
    create(data: CreatePaymentLinkRequest): Promise<PaymentLinkResponse>;
    /**
     * Get a payment link by ID
     */
    get(id: string): Promise<PaymentLinkResponse>;
    /**
     * Update a payment link
     */
    update(id: string, data: UpdatePaymentLinkRequest): Promise<PaymentLinkResponse>;
    /**
     * Delete a payment link
     */
    delete(id: string): Promise<void>;
    /**
     * Get a payment link by slug
     */
    getBySlug(slug: string): Promise<PaymentLinkResponse>;
    /**
     * List usage records for a specific payment link
     */
    listUsages(paymentLinkId: string, params?: ListPaymentLinkUsagesParams): Promise<ListResponse<PaymentLinkUsageResponse>>;
    /**
     * Record payment link usage
     */
    recordUsage(data: RecordPaymentLinkUsageRequest): Promise<PaymentLinkUsageResponse>;
    /**
     * Get a specific payment link usage record
     */
    getUsage(usageId: string): Promise<PaymentLinkUsageResponse>;
}

declare class CartsResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    addItem(cartId: string, data: AddCartItemRequest): Promise<CartResponse>;
    removeItem(cartId: string, data: RemoveCartItemRequest): Promise<CartResponse>;
    validateCoupon(cartId: string, data: ValidateCouponRequest): Promise<CartResponse>;
}

declare class PublicPaymentsResource {
    private httpClient;
    private readonly resourcePath;
    constructor(httpClient: HttpClient);
    getPublicPaymentDetails(slug: string): Promise<PublicPaymentDetailsResponse>;
    createPublicPaymentOrder(slug: string, data: PublicCreateOrderRequest): Promise<CreateOrderResponse>;
    getPublicOrderStatus(slug: string, orderId: string): Promise<PublicOrderStatusResponse>;
}

export { CustomersResource as C, DunningResource as D, GatewaysResource as G, HttpClient as H, InvoicesResource as I, MetersResource as M, OrganizationsResource as O, ProductsResource as P, ReportsResource as R, SubscriptionsResource as S, UsageResource as U, VariantsResource as V, WebhooksResource as W, PricesResource as a, OrdersResource as b, PaymentsResource as c, SettingsResource as d, SessionsResource as e, DiscountsResource as f, PaymentLinksResource as g, CartsResource as h, PublicPaymentsResource as i };