@djangocfg/ext-support 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -0,0 +1,1398 @@
+import { ConsolaInstance } from 'consola';
+import React from 'react';
+import { z, ZodError } from 'zod';
+import * as _djangocfg_ext_base from '@djangocfg/ext-base';
+
+/**
+ * * `open` - Open
+ * * `waiting_for_user` - Waiting for User
+ * * `waiting_for_admin` - Waiting for Admin
+ * * `resolved` - Resolved
+ * * `closed` - Closed
+ */
+declare enum PatchedTicketRequestStatus {
+    OPEN = "open",
+    WAITING_FOR_USER = "waiting_for_user",
+    WAITING_FOR_ADMIN = "waiting_for_admin",
+    RESOLVED = "resolved",
+    CLOSED = "closed"
+}
+/**
+ * * `open` - Open
+ * * `waiting_for_user` - Waiting for User
+ * * `waiting_for_admin` - Waiting for Admin
+ * * `resolved` - Resolved
+ * * `closed` - Closed
+ */
+declare enum TicketStatus {
+    OPEN = "open",
+    WAITING_FOR_USER = "waiting_for_user",
+    WAITING_FOR_ADMIN = "waiting_for_admin",
+    RESOLVED = "resolved",
+    CLOSED = "closed"
+}
+/**
+ * * `open` - Open
+ * * `waiting_for_user` - Waiting for User
+ * * `waiting_for_admin` - Waiting for Admin
+ * * `resolved` - Resolved
+ * * `closed` - Closed
+ */
+declare enum TicketRequestStatus {
+    OPEN = "open",
+    WAITING_FOR_USER = "waiting_for_user",
+    WAITING_FOR_ADMIN = "waiting_for_admin",
+    RESOLVED = "resolved",
+    CLOSED = "closed"
+}
+
+type enums_PatchedTicketRequestStatus = PatchedTicketRequestStatus;
+declare const enums_PatchedTicketRequestStatus: typeof PatchedTicketRequestStatus;
+type enums_TicketRequestStatus = TicketRequestStatus;
+declare const enums_TicketRequestStatus: typeof TicketRequestStatus;
+type enums_TicketStatus = TicketStatus;
+declare const enums_TicketStatus: typeof TicketStatus;
+declare namespace enums {
+  export { enums_PatchedTicketRequestStatus as PatchedTicketRequestStatus, enums_TicketRequestStatus as TicketRequestStatus, enums_TicketStatus as TicketStatus };
+}
+
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedTicketList$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<Ticket$1>;
+}
+/**
+ *
+ * Request model (no read-only fields).
+ */
+interface TicketRequest$1 {
+    user: number;
+    subject: string;
+    /** * `open` - Open
+    * `waiting_for_user` - Waiting for User
+    * `waiting_for_admin` - Waiting for Admin
+    * `resolved` - Resolved
+    * `closed` - Closed */
+    status?: TicketRequestStatus;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface Ticket$1 {
+    uuid: string;
+    user: number;
+    subject: string;
+    /** * `open` - Open
+    * `waiting_for_user` - Waiting for User
+    * `waiting_for_admin` - Waiting for Admin
+    * `resolved` - Resolved
+    * `closed` - Closed */
+    status?: TicketStatus;
+    created_at: string;
+    /** Get count of unanswered messages for this specific ticket. */
+    unanswered_messages_count: number;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedMessageList$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<Message$1>;
+}
+/**
+ *
+ * Request model (no read-only fields).
+ */
+interface MessageCreateRequest$1 {
+    text: string;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface MessageCreate$1 {
+    text: string;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface Message$1 {
+    uuid: string;
+    ticket: string;
+    sender: Sender$1;
+    /** Check if this message is from the ticket author. */
+    is_from_author: boolean;
+    text: string;
+    created_at: string;
+}
+/**
+ *
+ * Request model (no read-only fields).
+ */
+interface MessageRequest$1 {
+    text: string;
+}
+/**
+ *
+ * Request model (no read-only fields).
+ */
+interface PatchedMessageRequest$1 {
+    text?: string;
+}
+/**
+ *
+ * Request model (no read-only fields).
+ */
+interface PatchedTicketRequest$1 {
+    user?: number;
+    subject?: string;
+    /** * `open` - Open
+    * `waiting_for_user` - Waiting for User
+    * `waiting_for_admin` - Waiting for Admin
+    * `resolved` - Resolved
+    * `closed` - Closed */
+    status?: PatchedTicketRequestStatus;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface Sender$1 {
+    id: number;
+    /** Get formatted username for display. */
+    display_username: string;
+    email: string;
+    avatar?: string | null;
+    /** Get user's initials for avatar fallback. */
+    initials: string;
+    /** Designates whether the user can log into this admin site. */
+    is_staff: boolean;
+    /** Designates that this user has all permissions without explicitly assigning them. */
+    is_superuser: boolean;
+}
+
+declare namespace models {
+  export type { Message$1 as Message, MessageCreate$1 as MessageCreate, MessageCreateRequest$1 as MessageCreateRequest, MessageRequest$1 as MessageRequest, PaginatedMessageList$1 as PaginatedMessageList, PaginatedTicketList$1 as PaginatedTicketList, PatchedMessageRequest$1 as PatchedMessageRequest, PatchedTicketRequest$1 as PatchedTicketRequest, Sender$1 as Sender, Ticket$1 as Ticket, TicketRequest$1 as TicketRequest };
+}
+
+/**
+ * API endpoints for Support.
+ */
+declare class ExtSupportSupport {
+    private client;
+    constructor(client: any);
+    ticketsList(page?: number, page_size?: number): Promise<PaginatedTicketList$1>;
+    ticketsList(params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedTicketList$1>;
+    /**
+     * ViewSet for managing support tickets. Requires authenticated user (JWT
+     * or Session). Staff users can see all tickets, regular users see only
+     * their own.
+     */
+    ticketsCreate(data: TicketRequest$1): Promise<Ticket$1>;
+    ticketsMessagesList(ticket_uuid: string, page?: number, page_size?: number): Promise<PaginatedMessageList$1>;
+    ticketsMessagesList(ticket_uuid: string, params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedMessageList$1>;
+    /**
+     * ViewSet for managing support messages. Requires authenticated user (JWT
+     * or Session). Users can only access messages for their own tickets.
+     */
+    ticketsMessagesCreate(ticket_uuid: string, data: MessageCreateRequest$1): Promise<MessageCreate$1>;
+    /**
+     * ViewSet for managing support messages. Requires authenticated user (JWT
+     * or Session). Users can only access messages for their own tickets.
+     */
+    ticketsMessagesRetrieve(ticket_uuid: string, uuid: string): Promise<Message$1>;
+    /**
+     * ViewSet for managing support messages. Requires authenticated user (JWT
+     * or Session). Users can only access messages for their own tickets.
+     */
+    ticketsMessagesUpdate(ticket_uuid: string, uuid: string, data: MessageRequest$1): Promise<Message$1>;
+    /**
+     * ViewSet for managing support messages. Requires authenticated user (JWT
+     * or Session). Users can only access messages for their own tickets.
+     */
+    ticketsMessagesPartialUpdate(ticket_uuid: string, uuid: string, data?: PatchedMessageRequest$1): Promise<Message$1>;
+    /**
+     * ViewSet for managing support messages. Requires authenticated user (JWT
+     * or Session). Users can only access messages for their own tickets.
+     */
+    ticketsMessagesDestroy(ticket_uuid: string, uuid: string): Promise<void>;
+    /**
+     * ViewSet for managing support tickets. Requires authenticated user (JWT
+     * or Session). Staff users can see all tickets, regular users see only
+     * their own.
+     */
+    ticketsRetrieve(uuid: string): Promise<Ticket$1>;
+    /**
+     * ViewSet for managing support tickets. Requires authenticated user (JWT
+     * or Session). Staff users can see all tickets, regular users see only
+     * their own.
+     */
+    ticketsUpdate(uuid: string, data: TicketRequest$1): Promise<Ticket$1>;
+    /**
+     * ViewSet for managing support tickets. Requires authenticated user (JWT
+     * or Session). Staff users can see all tickets, regular users see only
+     * their own.
+     */
+    ticketsPartialUpdate(uuid: string, data?: PatchedTicketRequest$1): Promise<Ticket$1>;
+    /**
+     * ViewSet for managing support tickets. Requires authenticated user (JWT
+     * or Session). Staff users can see all tickets, regular users see only
+     * their own.
+     */
+    ticketsDestroy(uuid: string): Promise<void>;
+}
+
+/**
+ * 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_support_support: ExtSupportSupport;
+    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 Message
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const MessageSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    ticket: z.ZodString;
+    sender: z.ZodObject<{
+        id: z.ZodInt;
+        display_username: z.ZodString;
+        email: z.ZodEmail;
+        avatar: z.ZodNullable<z.ZodString>;
+        initials: z.ZodString;
+        is_staff: z.ZodBoolean;
+        is_superuser: z.ZodBoolean;
+    }, z.core.$strip>;
+    is_from_author: z.ZodBoolean;
+    text: z.ZodString;
+    created_at: z.ZodISODateTime;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type Message = z.infer<typeof MessageSchema>;
+
+/**
+ * Zod schema for MessageCreate
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const MessageCreateSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type MessageCreate = z.infer<typeof MessageCreateSchema>;
+
+/**
+ * Zod schema for MessageCreateRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const MessageCreateRequestSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type MessageCreateRequest = z.infer<typeof MessageCreateRequestSchema>;
+
+/**
+ * Zod schema for MessageRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const MessageRequestSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type MessageRequest = z.infer<typeof MessageRequestSchema>;
+
+/**
+ * Zod schema for PaginatedMessageList
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const PaginatedMessageListSchema: 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<{
+        uuid: z.ZodString;
+        ticket: z.ZodString;
+        sender: z.ZodObject<{
+            id: z.ZodInt;
+            display_username: z.ZodString;
+            email: z.ZodEmail;
+            avatar: z.ZodNullable<z.ZodString>;
+            initials: z.ZodString;
+            is_staff: z.ZodBoolean;
+            is_superuser: z.ZodBoolean;
+        }, z.core.$strip>;
+        is_from_author: z.ZodBoolean;
+        text: z.ZodString;
+        created_at: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedMessageList = z.infer<typeof PaginatedMessageListSchema>;
+
+declare const PaginatedTicketListSchema: 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<{
+        uuid: z.ZodString;
+        user: z.ZodInt;
+        subject: z.ZodString;
+        status: z.ZodOptional<z.ZodEnum<typeof TicketStatus>>;
+        created_at: z.ZodISODateTime;
+        unanswered_messages_count: z.ZodInt;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedTicketList = z.infer<typeof PaginatedTicketListSchema>;
+
+/**
+ * Zod schema for PatchedMessageRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const PatchedMessageRequestSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PatchedMessageRequest = z.infer<typeof PatchedMessageRequestSchema>;
+
+/**
+ * Zod schema for PatchedTicketRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const PatchedTicketRequestSchema: z.ZodObject<{
+    user: z.ZodOptional<z.ZodInt>;
+    subject: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<typeof PatchedTicketRequestStatus>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PatchedTicketRequest = z.infer<typeof PatchedTicketRequestSchema>;
+
+/**
+ * Zod schema for Sender
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const SenderSchema: z.ZodObject<{
+    id: z.ZodInt;
+    display_username: z.ZodString;
+    email: z.ZodEmail;
+    avatar: z.ZodNullable<z.ZodString>;
+    initials: z.ZodString;
+    is_staff: z.ZodBoolean;
+    is_superuser: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type Sender = z.infer<typeof SenderSchema>;
+
+/**
+ * Zod schema for Ticket
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const TicketSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    user: z.ZodInt;
+    subject: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<typeof TicketStatus>>;
+    created_at: z.ZodISODateTime;
+    unanswered_messages_count: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type Ticket = z.infer<typeof TicketSchema>;
+
+/**
+ * Zod schema for TicketRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const TicketRequestSchema: z.ZodObject<{
+    user: z.ZodInt;
+    subject: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<typeof TicketRequestStatus>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type TicketRequest = z.infer<typeof TicketRequestSchema>;
+
+/**
+ * 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_Message = Message;
+type index$1_MessageCreate = MessageCreate;
+type index$1_MessageCreateRequest = MessageCreateRequest;
+declare const index$1_MessageCreateRequestSchema: typeof MessageCreateRequestSchema;
+declare const index$1_MessageCreateSchema: typeof MessageCreateSchema;
+type index$1_MessageRequest = MessageRequest;
+declare const index$1_MessageRequestSchema: typeof MessageRequestSchema;
+declare const index$1_MessageSchema: typeof MessageSchema;
+type index$1_PaginatedMessageList = PaginatedMessageList;
+declare const index$1_PaginatedMessageListSchema: typeof PaginatedMessageListSchema;
+type index$1_PaginatedTicketList = PaginatedTicketList;
+declare const index$1_PaginatedTicketListSchema: typeof PaginatedTicketListSchema;
+type index$1_PatchedMessageRequest = PatchedMessageRequest;
+declare const index$1_PatchedMessageRequestSchema: typeof PatchedMessageRequestSchema;
+type index$1_PatchedTicketRequest = PatchedTicketRequest;
+declare const index$1_PatchedTicketRequestSchema: typeof PatchedTicketRequestSchema;
+type index$1_Sender = Sender;
+declare const index$1_SenderSchema: typeof SenderSchema;
+type index$1_Ticket = Ticket;
+type index$1_TicketRequest = TicketRequest;
+declare const index$1_TicketRequestSchema: typeof TicketRequestSchema;
+declare const index$1_TicketSchema: typeof TicketSchema;
+declare namespace index$1 {
+  export { type index$1_Message as Message, type index$1_MessageCreate as MessageCreate, type index$1_MessageCreateRequest as MessageCreateRequest, index$1_MessageCreateRequestSchema as MessageCreateRequestSchema, index$1_MessageCreateSchema as MessageCreateSchema, type index$1_MessageRequest as MessageRequest, index$1_MessageRequestSchema as MessageRequestSchema, index$1_MessageSchema as MessageSchema, type index$1_PaginatedMessageList as PaginatedMessageList, index$1_PaginatedMessageListSchema as PaginatedMessageListSchema, type index$1_PaginatedTicketList as PaginatedTicketList, index$1_PaginatedTicketListSchema as PaginatedTicketListSchema, type index$1_PatchedMessageRequest as PatchedMessageRequest, index$1_PatchedMessageRequestSchema as PatchedMessageRequestSchema, type index$1_PatchedTicketRequest as PatchedTicketRequest, index$1_PatchedTicketRequestSchema as PatchedTicketRequestSchema, type index$1_Sender as Sender, index$1_SenderSchema as SenderSchema, type index$1_Ticket as Ticket, type index$1_TicketRequest as TicketRequest, index$1_TicketRequestSchema as TicketRequestSchema, index$1_TicketSchema as TicketSchema };
+}
+
+/**
+ * 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;
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/
+ */
+declare function getSupportTicketsList(params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedTicketList>;
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/support/tickets/
+ */
+declare function createSupportTicketsCreate(data: TicketRequest, client?: any): Promise<Ticket>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/
+ */
+declare function getSupportTicketsMessagesList(ticket_uuid: string, params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedMessageList>;
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/
+ */
+declare function createSupportTicketsMessagesCreate(ticket_uuid: string, data: MessageCreateRequest, client?: any): Promise<MessageCreate>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+declare function getSupportTicketsMessagesRetrieve(ticket_uuid: string, uuid: string, client?: any): Promise<Message>;
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+declare function updateSupportTicketsMessagesUpdate(ticket_uuid: string, uuid: string, data: MessageRequest, client?: any): Promise<Message>;
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+declare function partialUpdateSupportTicketsMessagesPartialUpdate(ticket_uuid: string, uuid: string, data?: PatchedMessageRequest, client?: any): Promise<Message>;
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+declare function deleteSupportTicketsMessagesDestroy(ticket_uuid: string, uuid: string, client?: any): Promise<void>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/{uuid}/
+ */
+declare function getSupportTicketsRetrieve(uuid: string, client?: any): Promise<Ticket>;
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/support/tickets/{uuid}/
+ */
+declare function updateSupportTicketsUpdate(uuid: string, data: TicketRequest, client?: any): Promise<Ticket>;
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/support/tickets/{uuid}/
+ */
+declare function partialUpdateSupportTicketsPartialUpdate(uuid: string, data?: PatchedTicketRequest, client?: any): Promise<Ticket>;
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/support/tickets/{uuid}/
+ */
+declare function deleteSupportTicketsDestroy(uuid: string, client?: any): Promise<void>;
+
+/**
+ * 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_createSupportTicketsCreate: typeof createSupportTicketsCreate;
+declare const index_createSupportTicketsMessagesCreate: typeof createSupportTicketsMessagesCreate;
+declare const index_deleteSupportTicketsDestroy: typeof deleteSupportTicketsDestroy;
+declare const index_deleteSupportTicketsMessagesDestroy: typeof deleteSupportTicketsMessagesDestroy;
+declare const index_getSupportTicketsList: typeof getSupportTicketsList;
+declare const index_getSupportTicketsMessagesList: typeof getSupportTicketsMessagesList;
+declare const index_getSupportTicketsMessagesRetrieve: typeof getSupportTicketsMessagesRetrieve;
+declare const index_getSupportTicketsRetrieve: typeof getSupportTicketsRetrieve;
+declare const index_partialUpdateSupportTicketsMessagesPartialUpdate: typeof partialUpdateSupportTicketsMessagesPartialUpdate;
+declare const index_partialUpdateSupportTicketsPartialUpdate: typeof partialUpdateSupportTicketsPartialUpdate;
+declare const index_updateSupportTicketsMessagesUpdate: typeof updateSupportTicketsMessagesUpdate;
+declare const index_updateSupportTicketsUpdate: typeof updateSupportTicketsUpdate;
+declare namespace index {
+  export { index_createSupportTicketsCreate as createSupportTicketsCreate, index_createSupportTicketsMessagesCreate as createSupportTicketsMessagesCreate, index_deleteSupportTicketsDestroy as deleteSupportTicketsDestroy, index_deleteSupportTicketsMessagesDestroy as deleteSupportTicketsMessagesDestroy, index_getSupportTicketsList as getSupportTicketsList, index_getSupportTicketsMessagesList as getSupportTicketsMessagesList, index_getSupportTicketsMessagesRetrieve as getSupportTicketsMessagesRetrieve, index_getSupportTicketsRetrieve as getSupportTicketsRetrieve, index_partialUpdateSupportTicketsMessagesPartialUpdate as partialUpdateSupportTicketsMessagesPartialUpdate, index_partialUpdateSupportTicketsPartialUpdate as partialUpdateSupportTicketsPartialUpdate, index_updateSupportTicketsMessagesUpdate as updateSupportTicketsMessagesUpdate, index_updateSupportTicketsUpdate as updateSupportTicketsUpdate };
+}
+
+/**
+ * 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_support_support: ExtSupportSupport;
+    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;
+}
+
+/**
+ * Support Extension API
+ *
+ * Pre-configured API instance with shared authentication
+ */
+
+declare const apiSupport: API;
+
+/**
+ * Support Layout
+ * Modern support layout with resizable panels for desktop and mobile-optimized view
+ */
+
+interface SupportLayoutProps {
+    children?: React.ReactNode;
+}
+declare const SupportLayout: React.FC<SupportLayoutProps>;
+
+/**
+ * Support Layout Types
+ * UI state types for SupportLayout
+ */
+interface SupportUIState {
+    selectedTicketUuid: string | null;
+    isCreateDialogOpen: boolean;
+    viewMode: 'list' | 'grid';
+}
+interface TicketFormData {
+    subject: string;
+    message: string;
+}
+
+/**
+ * Support Layout Events
+ * Event system for SupportLayout
+ */
+declare const SUPPORT_LAYOUT_EVENTS: {
+    readonly OPEN_CREATE_DIALOG: "support-layout:open-create-dialog";
+    readonly CLOSE_CREATE_DIALOG: "support-layout:close-create-dialog";
+    readonly TICKET_SELECTED: "support-layout:ticket-selected";
+    readonly TICKET_CREATED: "support-layout:ticket-created";
+    readonly MESSAGE_SENT: "support-layout:message-sent";
+};
+declare const openCreateTicketDialog: () => void;
+declare const closeCreateTicketDialog: () => void;
+
+/**
+ * Support extension configuration
+ */
+declare const extensionConfig: _djangocfg_ext_base.ExtensionMetadata;
+
+export { API, APIClient, APIError, APILogger, type APIOptions, CookieStorageAdapter, DEFAULT_RETRY_CONFIG, enums as Enums, type ErrorLog, models as ExtSupportSupportTypes, type FailedAttemptInfo, FetchAdapter, index as Fetchers, type HttpClientAdapter, type HttpRequest, type HttpResponse, LocalStorageAdapter, type LoggerConfig, MemoryStorageAdapter, type Message, type MessageCreate, type MessageCreateRequest, MessageCreateRequestSchema, MessageCreateSchema, type MessageRequest, MessageRequestSchema, MessageSchema, NetworkError, type PaginatedMessageList, PaginatedMessageListSchema, type PaginatedTicketList, PaginatedTicketListSchema, type PatchedMessageRequest, PatchedMessageRequestSchema, type PatchedTicketRequest, PatchedTicketRequestSchema, REFRESH_TOKEN_KEY, type RequestLog, type ResponseLog, type RetryConfig, SUPPORT_LAYOUT_EVENTS, index$1 as Schemas, type Sender, SenderSchema, type StorageAdapter, SupportLayout, type SupportLayoutProps, type SupportUIState, TOKEN_KEY, type Ticket, type TicketFormData, type TicketRequest, TicketRequestSchema, TicketSchema, type ValidationErrorDetail, type ValidationErrorEvent, apiSupport, clearAPITokens, closeCreateTicketDialog, configureAPI, createSupportTicketsCreate, createSupportTicketsMessagesCreate, deleteSupportTicketsDestroy, deleteSupportTicketsMessagesDestroy, dispatchValidationError, extensionConfig, formatZodError, getAPIInstance, getSupportTicketsList, getSupportTicketsMessagesList, getSupportTicketsMessagesRetrieve, getSupportTicketsRetrieve, isAPIConfigured, onValidationError, openCreateTicketDialog, partialUpdateSupportTicketsMessagesPartialUpdate, partialUpdateSupportTicketsPartialUpdate, reconfigureAPI, resetAPI, shouldRetry, updateSupportTicketsMessagesUpdate, updateSupportTicketsUpdate, withRetry };