@djangocfg/ext-payments 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1287 @@
+import { ConsolaInstance } from 'consola';
+import React from 'react';
+import { z, ZodError } from 'zod';
+
+/**
+ * Current payment status
+ * * `pending` - Pending
+ * * `confirming` - Confirming
+ * * `confirmed` - Confirmed
+ * * `completed` - Completed
+ * * `partially_paid` - Partially Paid
+ * * `failed` - Failed
+ * * `expired` - Expired
+ * * `cancelled` - Cancelled
+ */
+declare enum PaymentDetailStatus {
+    PENDING = "pending",
+    CONFIRMING = "confirming",
+    CONFIRMED = "confirmed",
+    COMPLETED = "completed",
+    PARTIALLY_PAID = "partially_paid",
+    FAILED = "failed",
+    EXPIRED = "expired",
+    CANCELLED = "cancelled"
+}
+/**
+ * Current payment status
+ * * `pending` - Pending
+ * * `confirming` - Confirming
+ * * `confirmed` - Confirmed
+ * * `completed` - Completed
+ * * `partially_paid` - Partially Paid
+ * * `failed` - Failed
+ * * `expired` - Expired
+ * * `cancelled` - Cancelled
+ */
+declare enum PaymentListStatus {
+    PENDING = "pending",
+    CONFIRMING = "confirming",
+    CONFIRMED = "confirmed",
+    COMPLETED = "completed",
+    PARTIALLY_PAID = "partially_paid",
+    FAILED = "failed",
+    EXPIRED = "expired",
+    CANCELLED = "cancelled"
+}
+/**
+ * Type of transaction
+ * * `deposit` - Deposit
+ * * `withdrawal` - Withdrawal
+ * * `payment` - Payment
+ * * `refund` - Refund
+ * * `fee` - Fee
+ * * `bonus` - Bonus
+ * * `adjustment` - Adjustment
+ */
+declare enum TransactionTransactionType {
+    DEPOSIT = "deposit",
+    WITHDRAWAL = "withdrawal",
+    PAYMENT = "payment",
+    REFUND = "refund",
+    FEE = "fee",
+    BONUS = "bonus",
+    ADJUSTMENT = "adjustment"
+}
+
+type enums_PaymentDetailStatus = PaymentDetailStatus;
+declare const enums_PaymentDetailStatus: typeof PaymentDetailStatus;
+type enums_PaymentListStatus = PaymentListStatus;
+declare const enums_PaymentListStatus: typeof PaymentListStatus;
+type enums_TransactionTransactionType = TransactionTransactionType;
+declare const enums_TransactionTransactionType: typeof TransactionTransactionType;
+declare namespace enums {
+  export { enums_PaymentDetailStatus as PaymentDetailStatus, enums_PaymentListStatus as PaymentListStatus, enums_TransactionTransactionType as TransactionTransactionType };
+}
+
+/**
+ * User balance serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface Balance$1 {
+    /** Current balance in USD */
+    balance_usd: string;
+    balance_display: string;
+    /** Total amount deposited (lifetime) */
+    total_deposited: string;
+    /** Total amount withdrawn (lifetime) */
+    total_withdrawn: string;
+    /** When the last transaction occurred */
+    last_transaction_at?: string | null;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedPaymentListList$1 {
+    /** Total number of items across all pages */
+    count: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Total number of pages */
+    pages: number;
+    /** Number of items per page */
+    page_size: number;
+    /** Whether there is a next page */
+    has_next: boolean;
+    /** Whether there is a previous page */
+    has_previous: boolean;
+    /** Next page number (null if no next page) */
+    next_page?: number | null;
+    /** Previous page number (null if no previous page) */
+    previous_page?: number | null;
+    /** Array of items for current page */
+    results: Array<PaymentList$1>;
+}
+/**
+ * Detailed payment information.
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaymentDetail$1 {
+    /** Unique identifier for this record */
+    id: string;
+    /** Internal payment identifier (PAY_YYYYMMDDHHMMSS_UUID) */
+    internal_payment_id: string;
+    /** Payment amount in USD */
+    amount_usd: string;
+    currency_code: string;
+    currency_name: string;
+    currency_token: string;
+    currency_network: string;
+    /** Amount to pay in cryptocurrency */
+    pay_amount?: string | null;
+    /** Actual amount received in cryptocurrency */
+    actual_amount?: string | null;
+    /** Actual amount received in USD */
+    actual_amount_usd?: string | null;
+    /** Current payment status
+  
+    * `pending` - Pending
+    * `confirming` - Confirming
+    * `confirmed` - Confirmed
+    * `completed` - Completed
+    * `partially_paid` - Partially Paid
+    * `failed` - Failed
+    * `expired` - Expired
+    * `cancelled` - Cancelled */
+    status: PaymentDetailStatus;
+    status_display: string;
+    /** Cryptocurrency payment address */
+    pay_address?: string | null;
+    /** Get QR code URL. */
+    qr_code_url?: string | null;
+    /** Payment page URL (if provided by provider) */
+    payment_url?: string | null;
+    /** Blockchain transaction hash */
+    transaction_hash?: string | null;
+    /** Get blockchain explorer link. */
+    explorer_link?: string | null;
+    /** Number of blockchain confirmations */
+    confirmations_count: number;
+    /** When this payment expires (typically 30 minutes) */
+    expires_at?: string | null;
+    /** When this payment was completed */
+    completed_at?: string | null;
+    /** When this record was created */
+    created_at: string;
+    is_completed: boolean;
+    is_failed: boolean;
+    is_expired: boolean;
+    /** Payment description */
+    description: string;
+}
+/**
+ * Payment list item (lighter than detail).
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaymentList$1 {
+    /** Unique identifier for this record */
+    id: string;
+    /** Internal payment identifier (PAY_YYYYMMDDHHMMSS_UUID) */
+    internal_payment_id: string;
+    /** Payment amount in USD */
+    amount_usd: string;
+    currency_code: string;
+    currency_token: string;
+    /** Current payment status
+  
+    * `pending` - Pending
+    * `confirming` - Confirming
+    * `confirmed` - Confirmed
+    * `completed` - Completed
+    * `partially_paid` - Partially Paid
+    * `failed` - Failed
+    * `expired` - Expired
+    * `cancelled` - Cancelled */
+    status: PaymentListStatus;
+    status_display: string;
+    /** When this record was created */
+    created_at: string;
+    /** When this payment was completed */
+    completed_at?: string | null;
+}
+
+declare namespace models {
+  export type { Balance$1 as Balance, PaginatedPaymentListList$1 as PaginatedPaymentListList, PaymentDetail$1 as PaymentDetail, PaymentList$1 as PaymentList };
+}
+
+/**
+ * API endpoints for Payments.
+ */
+declare class ExtPaymentsPayments {
+    private client;
+    constructor(client: any);
+    /**
+     * Get user balance
+     *
+     * Get current user balance and transaction statistics
+     */
+    balanceRetrieve(): Promise<Balance$1>;
+    /**
+     * Get available currencies
+     *
+     * Returns list of available currencies with token+network info
+     */
+    currenciesList(): Promise<any>;
+    paymentsList(page?: number, page_size?: number): Promise<PaginatedPaymentListList$1>;
+    paymentsList(params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedPaymentListList$1>;
+    /**
+     * ViewSet for payment operations. Endpoints: - GET /payments/ - List
+     * user's payments - GET /payments/{id}/ - Get payment details - POST
+     * /payments/create/ - Create new payment - GET /payments/{id}/status/ -
+     * Check payment status - POST /payments/{id}/confirm/ - Confirm payment
+     */
+    paymentsRetrieve(id: string): Promise<PaymentDetail$1>;
+    /**
+     * POST /api/v1/payments/{id}/confirm/ Confirm payment (user clicked "I
+     * have paid"). Checks status with provider and creates transaction if
+     * completed.
+     */
+    paymentsConfirmCreate(id: string): Promise<PaymentList$1>;
+    /**
+     * GET /api/v1/payments/{id}/status/?refresh=true Check payment status
+     * (with optional refresh from provider). Query params: - refresh: boolean
+     * (default: false) - Force refresh from provider
+     */
+    paymentsStatusRetrieve(id: string): Promise<PaymentList$1[]>;
+    /**
+     * POST /api/v1/payments/create/ Create new payment. Request body: {
+     * "amount_usd": "100.00", "currency_code": "USDTTRC20", "description":
+     * "Optional description" }
+     */
+    paymentsCreateCreate(): Promise<PaymentList$1>;
+    transactionsList(limit?: number, offset?: number, type?: string): Promise<any>;
+    transactionsList(params?: {
+        limit?: number;
+        offset?: number;
+        type?: string;
+    }): Promise<any>;
+}
+
+/**
+ * HTTP Client Adapter Pattern
+ *
+ * Allows switching between fetch/axios/httpx without changing generated code.
+ * Provides unified interface for making HTTP requests.
+ */
+interface HttpRequest {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: any;
+    params?: Record<string, any>;
+    /** FormData for file uploads (multipart/form-data) */
+    formData?: FormData;
+}
+interface HttpResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+}
+/**
+ * HTTP Client Adapter Interface.
+ * Implement this to use custom HTTP clients (axios, httpx, etc.)
+ */
+interface HttpClientAdapter {
+    request<T = any>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+/**
+ * Default Fetch API adapter.
+ * Uses native browser fetch() with proper error handling.
+ */
+declare class FetchAdapter implements HttpClientAdapter {
+    request<T = any>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+
+/**
+ * API Logger with Consola
+ * Beautiful console logging for API requests and responses
+ *
+ * Installation:
+ *   npm install consola
+ */
+
+/**
+ * Request log data
+ */
+interface RequestLog {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: any;
+    timestamp: number;
+}
+/**
+ * Response log data
+ */
+interface ResponseLog {
+    status: number;
+    statusText: string;
+    data?: any;
+    duration: number;
+    timestamp: number;
+}
+/**
+ * Error log data
+ */
+interface ErrorLog {
+    message: string;
+    statusCode?: number;
+    fieldErrors?: Record<string, string[]>;
+    duration: number;
+    timestamp: number;
+}
+/**
+ * Logger configuration
+ */
+interface LoggerConfig {
+    /** Enable logging */
+    enabled: boolean;
+    /** Log requests */
+    logRequests: boolean;
+    /** Log responses */
+    logResponses: boolean;
+    /** Log errors */
+    logErrors: boolean;
+    /** Log request/response bodies */
+    logBodies: boolean;
+    /** Log headers (excluding sensitive ones) */
+    logHeaders: boolean;
+    /** Custom consola instance */
+    consola?: ConsolaInstance;
+}
+/**
+ * API Logger class
+ */
+declare class APILogger {
+    private config;
+    private consola;
+    constructor(config?: Partial<LoggerConfig>);
+    /**
+     * Enable logging
+     */
+    enable(): void;
+    /**
+     * Disable logging
+     */
+    disable(): void;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<LoggerConfig>): void;
+    /**
+     * Filter sensitive headers
+     */
+    private filterHeaders;
+    /**
+     * Log request
+     */
+    logRequest(request: RequestLog): void;
+    /**
+     * Log response
+     */
+    logResponse(request: RequestLog, response: ResponseLog): void;
+    /**
+     * Log error
+     */
+    logError(request: RequestLog, error: ErrorLog): void;
+    /**
+     * Log general info
+     */
+    info(message: string, ...args: any[]): void;
+    /**
+     * Log warning
+     */
+    warn(message: string, ...args: any[]): void;
+    /**
+     * Log error
+     */
+    error(message: string, ...args: any[]): void;
+    /**
+     * Log debug
+     */
+    debug(message: string, ...args: any[]): void;
+    /**
+     * Log success
+     */
+    success(message: string, ...args: any[]): void;
+    /**
+     * Create a sub-logger with prefix
+     */
+    withTag(tag: string): ConsolaInstance;
+}
+
+/**
+ * Retry Configuration and Utilities
+ *
+ * Provides automatic retry logic for failed HTTP requests using p-retry.
+ * Retries only on network errors and server errors (5xx), not client errors (4xx).
+ */
+/**
+ * Information about a failed retry attempt.
+ */
+interface FailedAttemptInfo {
+    /** The error that caused the failure */
+    error: Error;
+    /** The attempt number (1-indexed) */
+    attemptNumber: number;
+    /** Number of retries left */
+    retriesLeft: number;
+}
+/**
+ * Retry configuration options.
+ *
+ * Uses exponential backoff with jitter by default to avoid thundering herd.
+ */
+interface RetryConfig {
+    /**
+     * Maximum number of retry attempts.
+     * @default 3
+     */
+    retries?: number;
+    /**
+     * Exponential backoff factor.
+     * @default 2
+     */
+    factor?: number;
+    /**
+     * Minimum wait time between retries (ms).
+     * @default 1000
+     */
+    minTimeout?: number;
+    /**
+     * Maximum wait time between retries (ms).
+     * @default 60000
+     */
+    maxTimeout?: number;
+    /**
+     * Add randomness to wait times (jitter).
+     * Helps avoid thundering herd problem.
+     * @default true
+     */
+    randomize?: boolean;
+    /**
+     * Callback called on each failed attempt.
+     */
+    onFailedAttempt?: (info: FailedAttemptInfo) => void;
+}
+/**
+ * Default retry configuration.
+ */
+declare const DEFAULT_RETRY_CONFIG: Required<RetryConfig>;
+/**
+ * Determine if an error should trigger a retry.
+ *
+ * Retries on:
+ * - Network errors (connection refused, timeout, etc.)
+ * - Server errors (5xx status codes)
+ * - Rate limiting (429 status code)
+ *
+ * Does NOT retry on:
+ * - Client errors (4xx except 429)
+ * - Authentication errors (401, 403)
+ * - Not found (404)
+ *
+ * @param error - The error to check
+ * @returns true if should retry, false otherwise
+ */
+declare function shouldRetry(error: any): boolean;
+/**
+ * Wrap a function with retry logic.
+ *
+ * @param fn - Async function to retry
+ * @param config - Retry configuration
+ * @returns Result of the function
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   async () => fetch('https://api.example.com/users'),
+ *   { retries: 5, minTimeout: 2000 }
+ * );
+ * ```
+ */
+declare function withRetry<T>(fn: () => Promise<T>, config?: RetryConfig): Promise<T>;
+
+/**
+ * Async API client for Django CFG API.
+ *
+ * Usage:
+ * ```typescript
+ * const client = new APIClient('https://api.example.com');
+ * const users = await client.users.list();
+ * const post = await client.posts.create(newPost);
+ *
+ * // Custom HTTP adapter (e.g., Axios)
+ * const client = new APIClient('https://api.example.com', {
+ *   httpClient: new AxiosAdapter()
+ * });
+ * ```
+ */
+declare class APIClient {
+    private baseUrl;
+    private httpClient;
+    private logger;
+    private retryConfig;
+    ext_payments_payments: ExtPaymentsPayments;
+    constructor(baseUrl: string, options?: {
+        httpClient?: HttpClientAdapter;
+        loggerConfig?: Partial<LoggerConfig>;
+        retryConfig?: RetryConfig;
+    });
+    /**
+     * Get CSRF token from cookies (for SessionAuthentication).
+     *
+     * Returns null if cookie doesn't exist (JWT-only auth).
+     */
+    getCsrfToken(): string | null;
+    /**
+     * Make HTTP request with Django CSRF and session handling.
+     * Automatically retries on network errors and 5xx server errors.
+     */
+    request<T>(method: string, path: string, options?: {
+        params?: Record<string, any>;
+        body?: any;
+        formData?: FormData;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /**
+     * Internal request method (without retry wrapper).
+     * Used by request() method with optional retry logic.
+     */
+    private _makeRequest;
+}
+
+/**
+ * Storage adapters for cross-platform token storage.
+ *
+ * Supports:
+ * - LocalStorage (browser)
+ * - Cookies (SSR/browser)
+ * - Memory (Node.js/Electron/testing)
+ */
+
+/**
+ * Storage adapter interface for cross-platform token storage.
+ */
+interface StorageAdapter {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/**
+ * LocalStorage adapter with safe try-catch for browser environments.
+ * Works in modern browsers with localStorage support.
+ *
+ * Note: This adapter uses window.localStorage and should only be used in browser/client environments.
+ * For server-side usage, use MemoryStorageAdapter or CookieStorageAdapter instead.
+ */
+declare class LocalStorageAdapter implements StorageAdapter {
+    private logger?;
+    constructor(logger?: APILogger);
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/**
+ * Cookie-based storage adapter for SSR and browser environments.
+ * Useful for Next.js, Nuxt.js, and other SSR frameworks.
+ */
+declare class CookieStorageAdapter implements StorageAdapter {
+    private logger?;
+    constructor(logger?: APILogger);
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/**
+ * In-memory storage adapter for Node.js, Electron, and testing environments.
+ * Data is stored in RAM and cleared when process exits.
+ */
+declare class MemoryStorageAdapter implements StorageAdapter {
+    private storage;
+    private logger?;
+    constructor(logger?: APILogger);
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+
+/**
+ * Zod schema for Balance
+ *
+ * This schema provides runtime validation and type inference.
+ *  * User balance serializer.
+ *  */
+
+/**
+ * User balance serializer.
+ */
+declare const BalanceSchema: z.ZodObject<{
+    balance_usd: z.ZodString;
+    balance_display: z.ZodString;
+    total_deposited: z.ZodString;
+    total_withdrawn: z.ZodString;
+    last_transaction_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type Balance = z.infer<typeof BalanceSchema>;
+
+/**
+ * Zod schema for Currency
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Currency list serializer.
+ *  */
+
+/**
+ * Currency list serializer.
+ */
+declare const CurrencySchema: z.ZodObject<{
+    code: z.ZodString;
+    name: z.ZodString;
+    token: z.ZodString;
+    network: z.ZodNullable<z.ZodString>;
+    display_name: z.ZodString;
+    symbol: z.ZodString;
+    decimal_places: z.ZodInt;
+    is_active: z.ZodBoolean;
+    min_amount_usd: z.ZodString;
+    sort_order: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type Currency = z.infer<typeof CurrencySchema>;
+
+declare const PaginatedPaymentListListSchema: z.ZodObject<{
+    count: z.ZodInt;
+    page: z.ZodInt;
+    pages: z.ZodInt;
+    page_size: z.ZodInt;
+    has_next: z.ZodBoolean;
+    has_previous: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    previous_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        internal_payment_id: z.ZodString;
+        amount_usd: z.ZodString;
+        currency_code: z.ZodString;
+        currency_token: z.ZodString;
+        status: z.ZodEnum<typeof PaymentListStatus>;
+        status_display: z.ZodString;
+        created_at: z.ZodISODateTime;
+        completed_at: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedPaymentListList = z.infer<typeof PaginatedPaymentListListSchema>;
+
+/**
+ * Zod schema for PaymentDetail
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Detailed payment information.
+ *  */
+
+/**
+ * Detailed payment information.
+ */
+declare const PaymentDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    internal_payment_id: z.ZodString;
+    amount_usd: z.ZodString;
+    currency_code: z.ZodString;
+    currency_name: z.ZodString;
+    currency_token: z.ZodString;
+    currency_network: z.ZodString;
+    pay_amount: z.ZodNullable<z.ZodString>;
+    actual_amount: z.ZodNullable<z.ZodString>;
+    actual_amount_usd: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<typeof PaymentDetailStatus>;
+    status_display: z.ZodString;
+    pay_address: z.ZodNullable<z.ZodString>;
+    qr_code_url: z.ZodNullable<z.ZodString>;
+    payment_url: z.ZodNullable<z.ZodURL>;
+    transaction_hash: z.ZodNullable<z.ZodString>;
+    explorer_link: z.ZodNullable<z.ZodString>;
+    confirmations_count: z.ZodInt;
+    expires_at: z.ZodNullable<z.ZodISODateTime>;
+    completed_at: z.ZodNullable<z.ZodISODateTime>;
+    created_at: z.ZodISODateTime;
+    is_completed: z.ZodBoolean;
+    is_failed: z.ZodBoolean;
+    is_expired: z.ZodBoolean;
+    description: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaymentDetail = z.infer<typeof PaymentDetailSchema>;
+
+/**
+ * Zod schema for PaymentList
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Payment list item (lighter than detail).
+ *  */
+
+/**
+ * Payment list item (lighter than detail).
+ */
+declare const PaymentListSchema: z.ZodObject<{
+    id: z.ZodString;
+    internal_payment_id: z.ZodString;
+    amount_usd: z.ZodString;
+    currency_code: z.ZodString;
+    currency_token: z.ZodString;
+    status: z.ZodEnum<typeof PaymentListStatus>;
+    status_display: z.ZodString;
+    created_at: z.ZodISODateTime;
+    completed_at: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaymentList = z.infer<typeof PaymentListSchema>;
+
+/**
+ * Zod schema for Transaction
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Transaction serializer.
+ *  */
+
+/**
+ * Transaction serializer.
+ */
+declare const TransactionSchema: z.ZodObject<{
+    id: z.ZodString;
+    transaction_type: z.ZodEnum<typeof TransactionTransactionType>;
+    type_display: z.ZodString;
+    amount_usd: z.ZodString;
+    amount_display: z.ZodString;
+    balance_after: z.ZodString;
+    payment_id: z.ZodNullable<z.ZodString>;
+    description: z.ZodString;
+    created_at: z.ZodISODateTime;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type Transaction = z.infer<typeof TransactionSchema>;
+
+/**
+ * Zod Schemas - Runtime validation and type inference
+ *
+ * Auto-generated from OpenAPI specification.
+ * Provides runtime validation for API requests and responses.
+ *
+ * Usage:
+ * ```typescript
+ * import { UserSchema } from './schemas'
+ *
+ * // Validate data
+ * const user = UserSchema.parse(data)
+ *
+ * // Type inference
+ * type User = z.infer<typeof UserSchema>
+ * ```
+ */
+
+type index$1_Balance = Balance;
+declare const index$1_BalanceSchema: typeof BalanceSchema;
+type index$1_Currency = Currency;
+declare const index$1_CurrencySchema: typeof CurrencySchema;
+type index$1_PaginatedPaymentListList = PaginatedPaymentListList;
+declare const index$1_PaginatedPaymentListListSchema: typeof PaginatedPaymentListListSchema;
+type index$1_PaymentDetail = PaymentDetail;
+declare const index$1_PaymentDetailSchema: typeof PaymentDetailSchema;
+type index$1_PaymentList = PaymentList;
+declare const index$1_PaymentListSchema: typeof PaymentListSchema;
+type index$1_Transaction = Transaction;
+declare const index$1_TransactionSchema: typeof TransactionSchema;
+declare namespace index$1 {
+  export { type index$1_Balance as Balance, index$1_BalanceSchema as BalanceSchema, type index$1_Currency as Currency, index$1_CurrencySchema as CurrencySchema, type index$1_PaginatedPaymentListList as PaginatedPaymentListList, index$1_PaginatedPaymentListListSchema as PaginatedPaymentListListSchema, type index$1_PaymentDetail as PaymentDetail, index$1_PaymentDetailSchema as PaymentDetailSchema, type index$1_PaymentList as PaymentList, index$1_PaymentListSchema as PaymentListSchema, type index$1_Transaction as Transaction, index$1_TransactionSchema as TransactionSchema };
+}
+
+/**
+ * Zod Validation Events - Browser CustomEvent integration
+ *
+ * Dispatches browser CustomEvents when Zod validation fails, allowing
+ * React/frontend apps to listen and handle validation errors globally.
+ *
+ * @example
+ * ```typescript
+ * // In your React app
+ * window.addEventListener('zod-validation-error', (event) => {
+ *   const { operation, path, method, error, response } = event.detail;
+ *   console.error(`Validation failed for ${method} ${path}`, error);
+ *   // Show toast notification, log to Sentry, etc.
+ * });
+ * ```
+ */
+
+/**
+ * Validation error event detail
+ */
+interface ValidationErrorDetail {
+    /** Operation/function name that failed validation */
+    operation: string;
+    /** API endpoint path */
+    path: string;
+    /** HTTP method */
+    method: string;
+    /** Zod validation error */
+    error: ZodError;
+    /** Raw response data that failed validation */
+    response: any;
+    /** Timestamp of the error */
+    timestamp: Date;
+}
+/**
+ * Custom event type for Zod validation errors
+ */
+type ValidationErrorEvent = CustomEvent<ValidationErrorDetail>;
+/**
+ * Dispatch a Zod validation error event.
+ *
+ * Only dispatches in browser environment (when window is defined).
+ * Safe to call in Node.js/SSR - will be a no-op.
+ *
+ * @param detail - Validation error details
+ */
+declare function dispatchValidationError(detail: ValidationErrorDetail): void;
+/**
+ * Add a global listener for Zod validation errors.
+ *
+ * @param callback - Function to call when validation error occurs
+ * @returns Cleanup function to remove the listener
+ *
+ * @example
+ * ```typescript
+ * const cleanup = onValidationError(({ operation, error }) => {
+ *   toast.error(`Validation failed in ${operation}`);
+ *   logToSentry(error);
+ * });
+ *
+ * // Later, remove listener
+ * cleanup();
+ * ```
+ */
+declare function onValidationError(callback: (detail: ValidationErrorDetail) => void): () => void;
+/**
+ * Format Zod error for logging/display.
+ *
+ * @param error - Zod validation error
+ * @returns Formatted error message
+ */
+declare function formatZodError(error: ZodError): string;
+
+/**
+ * Get user balance
+ *
+ * @method GET
+ * @path /cfg/payments/balance/
+ */
+declare function getPaymentsBalanceRetrieve(client?: any): Promise<Balance>;
+/**
+ * Get available currencies
+ *
+ * @method GET
+ * @path /cfg/payments/currencies/
+ */
+declare function getPaymentsCurrenciesList(client?: any): Promise<any>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/payments/payments/
+ */
+declare function getPaymentsPaymentsList(params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedPaymentListList>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/payments/payments/{id}/
+ */
+declare function getPaymentsPaymentsRetrieve(id: string, client?: any): Promise<PaymentDetail>;
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/payments/payments/{id}/confirm/
+ */
+declare function createPaymentsPaymentsConfirmCreate(id: string, client?: any): Promise<PaymentList>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/payments/payments/{id}/status/
+ */
+declare function getPaymentsPaymentsStatusRetrieve(id: string, client?: any): Promise<PaymentList>;
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/payments/payments/create/
+ */
+declare function createPaymentsPaymentsCreateCreate(client?: any): Promise<PaymentList>;
+/**
+ * Get user transactions
+ *
+ * @method GET
+ * @path /cfg/payments/transactions/
+ */
+declare function getPaymentsTransactionsList(params?: {
+    limit?: number;
+    offset?: number;
+    type?: string;
+}, client?: any): Promise<any>;
+
+/**
+ * Typed Fetchers - Universal API functions
+ *
+ * Auto-generated from OpenAPI specification.
+ * These functions work in any JavaScript environment.
+ *
+ * Features:
+ * - Runtime validation with Zod
+ * - Type-safe parameters and responses
+ * - Works with any data-fetching library (SWR, React Query, etc)
+ * - Server Component compatible
+ *
+ * Usage:
+ * ```typescript
+ * import * as fetchers from './fetchers'
+ *
+ * // Direct usage
+ * const user = await fetchers.getUser(1)
+ *
+ * // With SWR
+ * const { data } = useSWR('user-1', () => fetchers.getUser(1))
+ *
+ * // With React Query
+ * const { data } = useQuery(['user', 1], () => fetchers.getUser(1))
+ * ```
+ */
+
+declare const index_createPaymentsPaymentsConfirmCreate: typeof createPaymentsPaymentsConfirmCreate;
+declare const index_createPaymentsPaymentsCreateCreate: typeof createPaymentsPaymentsCreateCreate;
+declare const index_getPaymentsBalanceRetrieve: typeof getPaymentsBalanceRetrieve;
+declare const index_getPaymentsCurrenciesList: typeof getPaymentsCurrenciesList;
+declare const index_getPaymentsPaymentsList: typeof getPaymentsPaymentsList;
+declare const index_getPaymentsPaymentsRetrieve: typeof getPaymentsPaymentsRetrieve;
+declare const index_getPaymentsPaymentsStatusRetrieve: typeof getPaymentsPaymentsStatusRetrieve;
+declare const index_getPaymentsTransactionsList: typeof getPaymentsTransactionsList;
+declare namespace index {
+  export { index_createPaymentsPaymentsConfirmCreate as createPaymentsPaymentsConfirmCreate, index_createPaymentsPaymentsCreateCreate as createPaymentsPaymentsCreateCreate, index_getPaymentsBalanceRetrieve as getPaymentsBalanceRetrieve, index_getPaymentsCurrenciesList as getPaymentsCurrenciesList, index_getPaymentsPaymentsList as getPaymentsPaymentsList, index_getPaymentsPaymentsRetrieve as getPaymentsPaymentsRetrieve, index_getPaymentsPaymentsStatusRetrieve as getPaymentsPaymentsStatusRetrieve, index_getPaymentsTransactionsList as getPaymentsTransactionsList };
+}
+
+/**
+ * Global API Instance - Singleton configuration
+ *
+ * This module provides a global API instance that can be configured once
+ * and used throughout your application.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure once (e.g., in your app entry point)
+ * import { configureAPI } from './api-instance'
+ *
+ * configureAPI({
+ *   baseUrl: 'https://api.example.com',
+ *   token: 'your-jwt-token'
+ * })
+ *
+ * // Then use fetchers and hooks anywhere without configuration
+ * import { getUsers } from './fetchers'
+ * const users = await getUsers({ page: 1 })
+ * ```
+ *
+ * For SSR or multiple instances:
+ * ```typescript
+ * import { API } from './index'
+ * import { getUsers } from './fetchers'
+ *
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+
+/**
+ * Get the global API instance
+ * @throws Error if API is not configured
+ */
+declare function getAPIInstance(): API;
+/**
+ * Check if API is configured
+ */
+declare function isAPIConfigured(): boolean;
+/**
+ * Configure the global API instance
+ *
+ * @param baseUrl - Base URL for the API
+ * @param options - Optional configuration (storage, retry, logger)
+ *
+ * @example
+ * ```typescript
+ * configureAPI({
+ *   baseUrl: 'https://api.example.com',
+ *   token: 'jwt-token',
+ *   options: {
+ *     retryConfig: { maxRetries: 3 },
+ *     loggerConfig: { enabled: true }
+ *   }
+ * })
+ * ```
+ */
+declare function configureAPI(config: {
+    baseUrl: string;
+    token?: string;
+    refreshToken?: string;
+    options?: APIOptions;
+}): API;
+/**
+ * Reconfigure the global API instance with new settings
+ * Useful for updating tokens or base URL
+ */
+declare function reconfigureAPI(updates: {
+    baseUrl?: string;
+    token?: string;
+    refreshToken?: string;
+}): API;
+/**
+ * Clear tokens from the global API instance
+ */
+declare function clearAPITokens(): void;
+/**
+ * Reset the global API instance
+ * Useful for testing or logout scenarios
+ */
+declare function resetAPI(): void;
+
+/**
+ * API Error Classes
+ *
+ * Typed error classes with Django REST Framework support.
+ */
+/**
+ * HTTP API Error with DRF field-specific validation errors.
+ *
+ * Usage:
+ * ```typescript
+ * try {
+ *   await api.users.create(userData);
+ * } catch (error) {
+ *   if (error instanceof APIError) {
+ *     if (error.isValidationError) {
+ *       console.log('Field errors:', error.fieldErrors);
+ *       // { "email": ["Email already exists"], "username": ["Required"] }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class APIError extends Error {
+    statusCode: number;
+    statusText: string;
+    response: any;
+    url: string;
+    constructor(statusCode: number, statusText: string, response: any, url: string, message?: string);
+    /**
+     * Get error details from response.
+     * DRF typically returns: { "detail": "Error message" } or { "field": ["error1", "error2"] }
+     */
+    get details(): Record<string, any> | null;
+    /**
+     * Get field-specific validation errors from DRF.
+     * Returns: { "field_name": ["error1", "error2"], ... }
+     */
+    get fieldErrors(): Record<string, string[]> | null;
+    /**
+     * Get single error message from DRF.
+     * Checks for "detail", "message", or first field error.
+     */
+    get errorMessage(): string;
+    get isValidationError(): boolean;
+    get isAuthError(): boolean;
+    get isPermissionError(): boolean;
+    get isNotFoundError(): boolean;
+    get isServerError(): boolean;
+}
+/**
+ * Network Error (connection failed, timeout, etc.)
+ */
+declare class NetworkError extends Error {
+    url: string;
+    originalError?: Error;
+    constructor(message: string, url: string, originalError?: Error);
+}
+
+/**
+ * Django CFG API - API Client with JWT Management
+ *
+ * Usage:
+ * ```typescript
+ * import { API } from './api';
+ *
+ * const api = new API('https://api.example.com');
+ *
+ * // Set JWT token
+ * api.setToken('your-jwt-token', 'refresh-token');
+ *
+ * // Use API
+ * const posts = await api.posts.list();
+ * const user = await api.users.retrieve(1);
+ *
+ * // Check authentication
+ * if (api.isAuthenticated()) {
+ *   // ...
+ * }
+ *
+ * // Custom storage with logging (for Electron/Node.js)
+ * import { MemoryStorageAdapter, APILogger } from './storage';
+ * const logger = new APILogger({ enabled: true, logLevel: 'debug' });
+ * const api = new API('https://api.example.com', {
+ *   storage: new MemoryStorageAdapter(logger),
+ *   loggerConfig: { enabled: true, logLevel: 'debug' }
+ * });
+ *
+ * // Get OpenAPI schema
+ * const schema = api.getSchema();
+ * ```
+ */
+
+declare const TOKEN_KEY = "auth_token";
+declare const REFRESH_TOKEN_KEY = "refresh_token";
+interface APIOptions {
+    /** Custom storage adapter (defaults to LocalStorageAdapter) */
+    storage?: StorageAdapter;
+    /** Retry configuration for failed requests */
+    retryConfig?: RetryConfig;
+    /** Logger configuration */
+    loggerConfig?: Partial<LoggerConfig>;
+}
+declare class API {
+    private baseUrl;
+    private _client;
+    private _token;
+    private _refreshToken;
+    private storage;
+    private options?;
+    ext_payments_payments: ExtPaymentsPayments;
+    constructor(baseUrl: string, options?: APIOptions);
+    private _loadTokensFromStorage;
+    private _reinitClients;
+    private _injectAuthHeader;
+    /**
+     * Get current JWT token
+     */
+    getToken(): string | null;
+    /**
+     * Get current refresh token
+     */
+    getRefreshToken(): string | null;
+    /**
+     * Set JWT token and refresh token
+     * @param token - JWT access token
+     * @param refreshToken - JWT refresh token (optional)
+     */
+    setToken(token: string, refreshToken?: string): void;
+    /**
+     * Clear all tokens
+     */
+    clearTokens(): void;
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Update base URL and reinitialize clients
+     * @param url - New base URL
+     */
+    setBaseUrl(url: string): void;
+    /**
+     * Get current base URL
+     */
+    getBaseUrl(): string;
+    /**
+     * Get OpenAPI schema path
+     * @returns Path to the OpenAPI schema JSON file
+     *
+     * Note: The OpenAPI schema is available in the schema.json file.
+     * You can load it dynamically using:
+     * ```typescript
+     * const schema = await fetch('./schema.json').then(r => r.json());
+     * // or using fs in Node.js:
+     * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
+     * ```
+     */
+    getSchemaPath(): string;
+}
+
+/**
+ * Payments Extension API
+ *
+ * Pre-configured API instance with shared authentication
+ */
+
+declare const apiPayments: API;
+
+/**
+ * Payments Layout (v2.0 - Simplified)
+ *
+ * Simplified layout with 3 tabs: Overview, Payments, Transactions
+ * Removed: API Keys, Tariffs (deprecated in v2.0)
+ */
+
+interface PaymentsLayoutProps {
+    children?: React.ReactNode;
+}
+declare const PaymentsLayout: React.FC<PaymentsLayoutProps>;
+
+/**
+ * Payments Layout Types (v2.0 - Simplified)
+ */
+type PaymentTab = 'overview' | 'payments' | 'transactions';
+
+/**
+ * Payment Events System (v2.0 - Simplified)
+ *
+ * Event-based communication for dialogs using DOM events
+ * Removed: API Keys events (deprecated)
+ */
+declare const PAYMENT_EVENTS: {
+    readonly OPEN_CREATE_PAYMENT_DIALOG: "payments:open-create-payment";
+    readonly OPEN_PAYMENT_DETAILS_DIALOG: "payments:open-payment-details";
+    readonly CLOSE_DIALOG: "payments:close-dialog";
+};
+type PaymentEvent = {
+    type: 'OPEN_CREATE_PAYMENT';
+} | {
+    type: 'OPEN_PAYMENT_DETAILS';
+    id: string;
+} | {
+    type: 'CLOSE_DIALOG';
+};
+declare const openCreatePaymentDialog: () => void;
+declare const openPaymentDetailsDialog: (id: string) => void;
+declare const closePaymentsDialog: () => void;
+
+export { API, APIClient, APIError, APILogger, type APIOptions, type Balance, BalanceSchema, CookieStorageAdapter, type Currency, CurrencySchema, DEFAULT_RETRY_CONFIG, enums as Enums, type ErrorLog, models as ExtPaymentsPaymentsTypes, type FailedAttemptInfo, FetchAdapter, index as Fetchers, type HttpClientAdapter, type HttpRequest, type HttpResponse, LocalStorageAdapter, type LoggerConfig, MemoryStorageAdapter, NetworkError, PAYMENT_EVENTS, type PaginatedPaymentListList, PaginatedPaymentListListSchema, type PaymentDetail, PaymentDetailSchema, type PaymentEvent, type PaymentList, PaymentListSchema, type PaymentTab, PaymentsLayout, type PaymentsLayoutProps, REFRESH_TOKEN_KEY, type RequestLog, type ResponseLog, type RetryConfig, index$1 as Schemas, type StorageAdapter, TOKEN_KEY, type Transaction, TransactionSchema, type ValidationErrorDetail, type ValidationErrorEvent, apiPayments, clearAPITokens, closePaymentsDialog, configureAPI, createPaymentsPaymentsConfirmCreate, createPaymentsPaymentsCreateCreate, dispatchValidationError, formatZodError, getAPIInstance, getPaymentsBalanceRetrieve, getPaymentsCurrenciesList, getPaymentsPaymentsList, getPaymentsPaymentsRetrieve, getPaymentsPaymentsStatusRetrieve, getPaymentsTransactionsList, isAPIConfigured, onValidationError, openCreatePaymentDialog, openPaymentDetailsDialog, reconfigureAPI, resetAPI, shouldRetry, withRetry };