@djangocfg/ext-support 1.0.25 → 1.0.26

package/dist/index-rR_XqXq1.d.ts

@@ -0,0 +1,838 @@
+import { ConsolaInstance } from 'consola';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { z } from 'zod';
+import { ReactNode } from 'react';
+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"
+}
+
+/**
+ *
+ * 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?: PatchedTicketRequestStatus;
+}
+/**
+ *
+ * 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?: PatchedTicketRequestStatus;
+    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 {
+    text: string;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface Message$1 {
+    uuid: string;
+    ticket: string;
+    sender: Sender;
+    /** 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 {
+    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;
+}
+
+/**
+ * API endpoints for Support.
+ */
+declare class ExtSupportSupport {
+    private client;
+    constructor(client: any);
+    ticketsList(ordering?: string, page?: number, page_size?: number, search?: string): Promise<PaginatedTicketList$1>;
+    ticketsList(params?: {
+        ordering?: string;
+        page?: number;
+        page_size?: number;
+        search?: string;
+    }): 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, ordering?: string, page?: number, page_size?: number, search?: string): Promise<PaginatedMessageList$1>;
+    ticketsMessagesList(ticket_uuid: string, params?: {
+        ordering?: string;
+        page?: number;
+        page_size?: number;
+        search?: string;
+    }): 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>;
+    /**
+     * 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>;
+}
+
+/**
+ * API Logger with Consola
+ * Beautiful console logging for API requests and responses
+ *
+ * Installation:
+ *   npm install consola
+ */
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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.ZodString;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type Message = z.infer<typeof MessageSchema>;
+
+/**
+ * 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.ZodString;
+    }, 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 PatchedTicketRequestStatus>>;
+        created_at: z.ZodString;
+        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 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 PatchedTicketRequestStatus>>;
+    created_at: z.ZodString;
+    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 PatchedTicketRequestStatus>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type TicketRequest = z.infer<typeof TicketRequestSchema>;
+
+/**
+ * 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();
+ * ```
+ */
+
+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 Page Component (Apple-style)
+ *
+ * Single page with support hero + ticket list.
+ * Uses adapter pattern - works with any SupportAdapter (API or Demo).
+ *
+ * Usage:
+ *   // Production (with API)
+ *   <SupportPage />
+ *
+ *   // Demo (with mocks, no backend needed)
+ *   <SupportPage isDemo />
+ */
+declare const SupportContent: () => react_jsx_runtime.JSX.Element;
+interface SupportPageProps {
+    /** Use demo adapter with mock data (no backend required) */
+    isDemo?: boolean;
+}
+/**
+ * Support Page - automatically selects adapter based on isDemo prop.
+ *
+ * @example
+ * // Production (with API)
+ * <SupportPage />
+ *
+ * @example
+ * // Demo (with mocks)
+ * <SupportPage isDemo />
+ */
+declare function SupportPage({ isDemo }: SupportPageProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Support Hero (Apple HIG)
+ *
+ * Clean header with stats pills and create action
+ */
+interface SupportHeroProps {
+    onCreateTicket?: () => void;
+    className?: string;
+}
+declare function SupportHero({ onCreateTicket, className }: SupportHeroProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Support Model Types
+ *
+ * Defines the abstract interface for support operations.
+ * Adapters (API, Demo) implement this interface.
+ */
+
+interface CreateTicketInput {
+    subject: string;
+    message: string;
+}
+interface SendMessageInput {
+    ticketUuid: string;
+    text: string;
+}
+interface TicketsResult {
+    tickets: Ticket[];
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    hasMore: boolean;
+    totalCount: number;
+    loadMore: () => void;
+    refresh: () => Promise<void>;
+}
+interface MessagesResult {
+    messages: Message[];
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    hasMore: boolean;
+    totalCount: number;
+    loadMore: () => void;
+    refresh: () => Promise<void>;
+    addOptimistic: (message: Message) => void;
+}
+interface SupportModel {
+    useTickets: () => TicketsResult;
+    useMessages: (ticketUuid: string | null) => MessagesResult;
+    createTicket: (input: CreateTicketInput) => Promise<Ticket>;
+    sendMessage: (input: SendMessageInput) => Promise<Message>;
+    getUnreadCount: (tickets: Ticket[]) => number;
+}
+type SupportAdapter = SupportModel;
+
+interface SupportContextValue {
+    adapter: SupportAdapter;
+}
+interface SupportProviderProps {
+    children: ReactNode;
+    adapter: SupportAdapter;
+}
+declare function SupportProvider({ children, adapter }: SupportProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook for tickets list with pagination
+ */
+declare function useTickets(): TicketsResult;
+/**
+ * Hook for messages of a specific ticket
+ */
+declare function useMessages(ticketUuid: string | null): MessagesResult;
+/**
+ * Hook for support operations (create ticket, send message)
+ */
+declare function useSupport(): {
+    tickets: {
+        uuid: string;
+        user: number;
+        subject: string;
+        created_at: string;
+        unanswered_messages_count: number;
+        status?: PatchedTicketRequestStatus;
+    }[];
+    isLoadingTickets: boolean;
+    refreshTickets: () => Promise<void>;
+    createTicket: (input: CreateTicketInput) => Promise<Ticket>;
+    sendMessage: (input: SendMessageInput) => Promise<Message>;
+    unreadCount: number;
+};
+/**
+ * Legacy hook - returns everything (for backwards compatibility)
+ * @deprecated Use useTickets, useMessages, useSupport separately
+ */
+declare function useSupportAll(): {
+    createTicket: (input: CreateTicketInput) => Promise<Ticket>;
+    sendMessage: (input: SendMessageInput) => Promise<Message>;
+    unreadCount: number;
+    isLoading: boolean;
+    tickets: Ticket[];
+    isLoadingMore: boolean;
+    hasMore: boolean;
+    totalCount: number;
+    loadMore: () => void;
+    refresh: () => Promise<void>;
+};
+
+interface TicketListProps {
+    onTicketClick?: (ticket: Ticket) => void;
+    className?: string;
+}
+declare function TicketList({ onTicketClick, className }: TicketListProps): react_jsx_runtime.JSX.Element;
+
+interface TicketItemProps {
+    ticket: Ticket;
+    onClick?: () => void;
+}
+declare function TicketItem({ ticket, onClick }: TicketItemProps): react_jsx_runtime.JSX.Element;
+
+interface TicketSheetProps {
+    ticket: Ticket | null;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+}
+declare function TicketSheet({ ticket, open, onOpenChange }: TicketSheetProps): react_jsx_runtime.JSX.Element;
+
+interface CreateTicketSheetProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSuccess?: (ticket: Ticket) => void;
+}
+declare function CreateTicketSheet({ open, onOpenChange, onSuccess }: CreateTicketSheetProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * API Adapter
+ *
+ * Implements SupportModel using real API calls.
+ * This is the production adapter.
+ */
+
+declare const apiAdapter: SupportAdapter;
+/**
+ * Creates API adapter instance
+ * Note: Operations (createTicket, sendMessage) need hooks, so they're
+ * provided through the context layer
+ */
+declare function createApiAdapter(): SupportAdapter;
+/**
+ * Hook to get full API adapter with operations
+ * Must be used inside a component
+ */
+declare function useApiAdapter(): SupportAdapter;
+
+/**
+ * Demo Adapter
+ *
+ * Implements SupportModel using mock data.
+ * Used for demos without backend.
+ */
+
+declare function createDemoAdapter(): SupportAdapter;
+declare function resetDemoData(): void;
+
+/**
+ * Support extension configuration
+ */
+declare const extensionConfig: _djangocfg_ext_base.ExtensionMetadata;
+
+export { API as A, apiAdapter as B, CreateTicketSheet as C, createDemoAdapter as D, resetDemoData as E, type PaginatedTicketList as F, type PaginatedMessageList as G, extensionConfig as H, type MessageCreateRequest as M, type PatchedMessageRequest as P, SupportProvider as S, type TicketRequest as T, type Ticket as a, type MessageRequest as b, type Message as c, type PatchedTicketRequest as d, useTickets as e, useMessages as f, apiSupport as g, SupportPage as h, SupportContent as i, type SupportPageProps as j, SupportHero as k, TicketList as l, TicketItem as m, TicketSheet as n, useSupportAll as o, type SupportContextValue as p, type SupportProviderProps as q, type SupportModel as r, type SupportAdapter as s, type CreateTicketInput as t, useSupport as u, type SendMessageInput as v, type TicketsResult as w, type MessagesResult as x, createApiAdapter as y, useApiAdapter as z };