@djangocfg/ext-payments 1.0.2 → 1.0.4

package/dist/index.d.ts

@@ -0,0 +1,1293 @@
+import { ConsolaInstance } from 'consola';
+import React from 'react';
+import { z, ZodError } from 'zod';
+import * as _djangocfg_ext_base from '@djangocfg/ext-base';
+
+/**
+ * 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;
+
+/**
+ * Payments extension configuration
+ */
+declare const extensionConfig: _djangocfg_ext_base.ExtensionMetadata;
+
+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, extensionConfig, formatZodError, getAPIInstance, getPaymentsBalanceRetrieve, getPaymentsCurrenciesList, getPaymentsPaymentsList, getPaymentsPaymentsRetrieve, getPaymentsPaymentsStatusRetrieve, getPaymentsTransactionsList, isAPIConfigured, onValidationError, openCreatePaymentDialog, openPaymentDetailsDialog, reconfigureAPI, resetAPI, shouldRetry, withRetry };