@djangocfg/ext-support 1.0.0

package/dist/chunk-AZ4LWZB7.js

@@ -0,0 +1,2630 @@
+import { createConsola, consola } from 'consola';
+import pRetry, { AbortError } from 'p-retry';
+import { z } from 'zod';
+import { createExtensionAPI } from '@djangocfg/ext-base/api';
+import React7, { createContext, useContext, useState, useCallback, useEffect, useRef } from 'react';
+import useSWR, { useSWRConfig } from 'swr';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useAuth } from '@djangocfg/api/auth';
+import useSWRInfinite from 'swr/infinite';
+import { Card, cn, CardContent, Badge, Skeleton, ScrollArea, Button, useToast, Textarea, Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription, Form, FormField, FormItem, FormLabel, FormControl, Input, FormMessage, Avatar, AvatarImage, AvatarFallback, ResizablePanelGroup, ResizablePanel, ResizableHandle } from '@djangocfg/ui-nextjs';
+import { Clock, MessageSquare, Loader2, Send, Plus, Headphones, User, ArrowLeft, LifeBuoy } from 'lucide-react';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api/generated/ext_support/ext_support__support/client.ts
+var ExtSupportSupport = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsList(...args) {
+    const isParamsObject = args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0]);
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { page: args[0], page_size: args[1] };
+    }
+    const response = await this.client.request("GET", "/cfg/support/tickets/", { params });
+    return response;
+  }
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsCreate(data) {
+    const response = await this.client.request("POST", "/cfg/support/tickets/", { body: data });
+    return response;
+  }
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesList(...args) {
+    const ticket_uuid = args[0];
+    const isParamsObject = args.length === 2 && typeof args[1] === "object" && args[1] !== null && !Array.isArray(args[1]);
+    let params;
+    if (isParamsObject) {
+      params = args[1];
+    } else {
+      params = { page: args[1], page_size: args[2] };
+    }
+    const response = await this.client.request("GET", `/cfg/support/tickets/${ticket_uuid}/messages/`, { params });
+    return response;
+  }
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesCreate(ticket_uuid, data) {
+    const response = await this.client.request("POST", `/cfg/support/tickets/${ticket_uuid}/messages/`, { body: data });
+    return response;
+  }
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesRetrieve(ticket_uuid, uuid) {
+    const response = await this.client.request("GET", `/cfg/support/tickets/${ticket_uuid}/messages/${uuid}/`);
+    return response;
+  }
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesUpdate(ticket_uuid, uuid, data) {
+    const response = await this.client.request("PUT", `/cfg/support/tickets/${ticket_uuid}/messages/${uuid}/`, { body: data });
+    return response;
+  }
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesPartialUpdate(ticket_uuid, uuid, data) {
+    const response = await this.client.request("PATCH", `/cfg/support/tickets/${ticket_uuid}/messages/${uuid}/`, { body: data });
+    return response;
+  }
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesDestroy(ticket_uuid, uuid) {
+    await this.client.request("DELETE", `/cfg/support/tickets/${ticket_uuid}/messages/${uuid}/`);
+    return;
+  }
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsRetrieve(uuid) {
+    const response = await this.client.request("GET", `/cfg/support/tickets/${uuid}/`);
+    return response;
+  }
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsUpdate(uuid, data) {
+    const response = await this.client.request("PUT", `/cfg/support/tickets/${uuid}/`, { body: data });
+    return response;
+  }
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsPartialUpdate(uuid, data) {
+    const response = await this.client.request("PATCH", `/cfg/support/tickets/${uuid}/`, { body: data });
+    return response;
+  }
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsDestroy(uuid) {
+    await this.client.request("DELETE", `/cfg/support/tickets/${uuid}/`);
+    return;
+  }
+};
+
+// src/api/generated/ext_support/ext_support__support/models.ts
+var models_exports = {};
+
+// src/api/generated/ext_support/http.ts
+var FetchAdapter = class {
+  async request(request) {
+    const { method, url, headers, body, params, formData } = request;
+    let finalUrl = url;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== null && value !== void 0) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        finalUrl = url.includes("?") ? `${url}&${queryString}` : `${url}?${queryString}`;
+      }
+    }
+    const finalHeaders = { ...headers };
+    let requestBody;
+    if (formData) {
+      requestBody = formData;
+    } else if (body) {
+      finalHeaders["Content-Type"] = "application/json";
+      requestBody = JSON.stringify(body);
+    }
+    const response = await fetch(finalUrl, {
+      method,
+      headers: finalHeaders,
+      body: requestBody,
+      credentials: "include"
+      // Include Django session cookies
+    });
+    let data = null;
+    const contentType = response.headers.get("content-type");
+    if (response.status !== 204 && contentType?.includes("application/json")) {
+      data = await response.json();
+    } else if (response.status !== 204) {
+      data = await response.text();
+    }
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    return {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders
+    };
+  }
+};
+
+// src/api/generated/ext_support/errors.ts
+var APIError = class extends Error {
+  constructor(statusCode, statusText, response, url, message) {
+    super(message || `HTTP ${statusCode}: ${statusText}`);
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+    this.response = response;
+    this.url = url;
+    this.name = "APIError";
+  }
+  /**
+   * Get error details from response.
+   * DRF typically returns: { "detail": "Error message" } or { "field": ["error1", "error2"] }
+   */
+  get details() {
+    if (typeof this.response === "object" && this.response !== null) {
+      return this.response;
+    }
+    return null;
+  }
+  /**
+   * Get field-specific validation errors from DRF.
+   * Returns: { "field_name": ["error1", "error2"], ... }
+   */
+  get fieldErrors() {
+    const details = this.details;
+    if (!details) return null;
+    const fieldErrors = {};
+    for (const [key, value] of Object.entries(details)) {
+      if (Array.isArray(value)) {
+        fieldErrors[key] = value;
+      }
+    }
+    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
+  }
+  /**
+   * Get single error message from DRF.
+   * Checks for "detail", "message", or first field error.
+   */
+  get errorMessage() {
+    const details = this.details;
+    if (!details) return this.message;
+    if (details.detail) {
+      return Array.isArray(details.detail) ? details.detail.join(", ") : String(details.detail);
+    }
+    if (details.message) {
+      return String(details.message);
+    }
+    const fieldErrors = this.fieldErrors;
+    if (fieldErrors) {
+      const firstField = Object.keys(fieldErrors)[0];
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(", ")}`;
+      }
+    }
+    return this.message;
+  }
+  // Helper methods for common HTTP status codes
+  get isValidationError() {
+    return this.statusCode === 400;
+  }
+  get isAuthError() {
+    return this.statusCode === 401;
+  }
+  get isPermissionError() {
+    return this.statusCode === 403;
+  }
+  get isNotFoundError() {
+    return this.statusCode === 404;
+  }
+  get isServerError() {
+    return this.statusCode >= 500 && this.statusCode < 600;
+  }
+};
+var NetworkError = class extends Error {
+  constructor(message, url, originalError) {
+    super(message);
+    this.url = url;
+    this.originalError = originalError;
+    this.name = "NetworkError";
+  }
+};
+var DEFAULT_CONFIG = {
+  enabled: process.env.NODE_ENV !== "production",
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false
+};
+var SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-csrf-token"
+];
+var APILogger = class {
+  config;
+  consola;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.consola = config.consola || createConsola({
+      level: this.config.enabled ? 4 : 0
+    });
+  }
+  /**
+   * Enable logging
+   */
+  enable() {
+    this.config.enabled = true;
+  }
+  /**
+   * Disable logging
+   */
+  disable() {
+    this.config.enabled = false;
+  }
+  /**
+   * Update configuration
+   */
+  setConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Filter sensitive headers
+   */
+  filterHeaders(headers) {
+    if (!headers) return {};
+    const filtered = {};
+    Object.keys(headers).forEach((key) => {
+      const lowerKey = key.toLowerCase();
+      if (SENSITIVE_HEADERS.includes(lowerKey)) {
+        filtered[key] = "***";
+      } else {
+        filtered[key] = headers[key] || "";
+      }
+    });
+    return filtered;
+  }
+  /**
+   * Log request
+   */
+  logRequest(request) {
+    if (!this.config.enabled || !this.config.logRequests) return;
+    const { method, url, headers, body } = request;
+    this.consola.start(`${method} ${url}`);
+    if (this.config.logHeaders && headers) {
+      this.consola.debug("Headers:", this.filterHeaders(headers));
+    }
+    if (this.config.logBodies && body) {
+      this.consola.debug("Body:", body);
+    }
+  }
+  /**
+   * Log response
+   */
+  logResponse(request, response) {
+    if (!this.config.enabled || !this.config.logResponses) return;
+    const { method, url } = request;
+    const { status, statusText, data, duration } = response;
+    this.consola.success(
+      `${method} ${url} ${status} ${statusText} (${duration}ms)`
+    );
+    if (this.config.logBodies && data) {
+      this.consola.debug("Response:", data);
+    }
+  }
+  /**
+   * Log error
+   */
+  logError(request, error) {
+    if (!this.config.enabled || !this.config.logErrors) return;
+    const { method, url } = request;
+    const { message, statusCode, fieldErrors, duration } = error;
+    this.consola.error(
+      `${method} ${url} ${statusCode || "Network"} Error (${duration}ms)`
+    );
+    this.consola.error("Message:", message);
+    if (fieldErrors && Object.keys(fieldErrors).length > 0) {
+      this.consola.error("Field Errors:");
+      Object.entries(fieldErrors).forEach(([field, errors]) => {
+        errors.forEach((err) => {
+          this.consola.error(`  \u2022 ${field}: ${err}`);
+        });
+      });
+    }
+  }
+  /**
+   * Log general info
+   */
+  info(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.info(message, ...args);
+  }
+  /**
+   * Log warning
+   */
+  warn(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.warn(message, ...args);
+  }
+  /**
+   * Log error
+   */
+  error(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.error(message, ...args);
+  }
+  /**
+   * Log debug
+   */
+  debug(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.debug(message, ...args);
+  }
+  /**
+   * Log success
+   */
+  success(message, ...args) {
+    if (!this.config.enabled) return;
+    this.consola.success(message, ...args);
+  }
+  /**
+   * Create a sub-logger with prefix
+   */
+  withTag(tag) {
+    return this.consola.withTag(tag);
+  }
+};
+new APILogger();
+var DEFAULT_RETRY_CONFIG = {
+  retries: 3,
+  factor: 2,
+  minTimeout: 1e3,
+  maxTimeout: 6e4,
+  randomize: true,
+  onFailedAttempt: () => {
+  }
+};
+function shouldRetry(error) {
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  if (error instanceof APIError) {
+    const status = error.statusCode;
+    if (status >= 500 && status < 600) {
+      return true;
+    }
+    if (status === 429) {
+      return true;
+    }
+    return false;
+  }
+  return true;
+}
+async function withRetry(fn, config) {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+  return pRetry(
+    async () => {
+      try {
+        return await fn();
+      } catch (error) {
+        if (!shouldRetry(error)) {
+          throw new AbortError(error);
+        }
+        throw error;
+      }
+    },
+    {
+      retries: finalConfig.retries,
+      factor: finalConfig.factor,
+      minTimeout: finalConfig.minTimeout,
+      maxTimeout: finalConfig.maxTimeout,
+      randomize: finalConfig.randomize,
+      onFailedAttempt: finalConfig.onFailedAttempt ? (error) => {
+        const pRetryError = error;
+        finalConfig.onFailedAttempt({
+          error: pRetryError,
+          attemptNumber: pRetryError.attemptNumber,
+          retriesLeft: pRetryError.retriesLeft
+        });
+      } : void 0
+    }
+  );
+}
+
+// src/api/generated/ext_support/client.ts
+var APIClient = class {
+  baseUrl;
+  httpClient;
+  logger = null;
+  retryConfig = null;
+  // Sub-clients
+  ext_support_support;
+  constructor(baseUrl, options) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.httpClient = options?.httpClient || new FetchAdapter();
+    if (options?.loggerConfig !== void 0) {
+      this.logger = new APILogger(options.loggerConfig);
+    }
+    if (options?.retryConfig !== void 0) {
+      this.retryConfig = options.retryConfig;
+    }
+    this.ext_support_support = new ExtSupportSupport(this);
+  }
+  /**
+   * Get CSRF token from cookies (for SessionAuthentication).
+   *
+   * Returns null if cookie doesn't exist (JWT-only auth).
+   */
+  getCsrfToken() {
+    const name = "csrftoken";
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+      return parts.pop()?.split(";").shift() || null;
+    }
+    return null;
+  }
+  /**
+   * Make HTTP request with Django CSRF and session handling.
+   * Automatically retries on network errors and 5xx server errors.
+   */
+  async request(method, path, options) {
+    if (this.retryConfig) {
+      return withRetry(() => this._makeRequest(method, path, options), {
+        ...this.retryConfig,
+        onFailedAttempt: (info) => {
+          if (this.logger) {
+            this.logger.warn(
+              `Retry attempt ${info.attemptNumber}/${info.retriesLeft + info.attemptNumber} for ${method} ${path}: ${info.error.message}`
+            );
+          }
+          this.retryConfig?.onFailedAttempt?.(info);
+        }
+      });
+    }
+    return this._makeRequest(method, path, options);
+  }
+  /**
+   * Internal request method (without retry wrapper).
+   * Used by request() method with optional retry logic.
+   */
+  async _makeRequest(method, path, options) {
+    const url = this.baseUrl ? `${this.baseUrl}${path}` : path;
+    const startTime = Date.now();
+    const headers = {
+      ...options?.headers || {}
+    };
+    if (!options?.formData && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (this.logger) {
+      this.logger.logRequest({
+        method,
+        url,
+        headers,
+        body: options?.formData || options?.body,
+        timestamp: startTime
+      });
+    }
+    try {
+      const response = await this.httpClient.request({
+        method,
+        url,
+        headers,
+        params: options?.params,
+        body: options?.body,
+        formData: options?.formData
+      });
+      const duration = Date.now() - startTime;
+      if (response.status >= 400) {
+        const error = new APIError(
+          response.status,
+          response.statusText,
+          response.data,
+          url
+        );
+        if (this.logger) {
+          this.logger.logError(
+            {
+              method,
+              url,
+              headers,
+              body: options?.formData || options?.body,
+              timestamp: startTime
+            },
+            {
+              message: error.message,
+              statusCode: response.status,
+              duration,
+              timestamp: Date.now()
+            }
+          );
+        }
+        throw error;
+      }
+      if (this.logger) {
+        this.logger.logResponse(
+          {
+            method,
+            url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime
+          },
+          {
+            status: response.status,
+            statusText: response.statusText,
+            data: response.data,
+            duration,
+            timestamp: Date.now()
+          }
+        );
+      }
+      return response.data;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      if (error instanceof APIError) {
+        throw error;
+      }
+      const isCORSError = error instanceof TypeError && (error.message.toLowerCase().includes("cors") || error.message.toLowerCase().includes("failed to fetch") || error.message.toLowerCase().includes("network request failed"));
+      if (this.logger) {
+        if (isCORSError) {
+          this.logger.error(`\u{1F6AB} CORS Error: ${method} ${url}`);
+          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
+          this.logger.error(`  \u2192 Configure security_domains parameter on the server`);
+        } else {
+          this.logger.error(`\u26A0\uFE0F  Network Error: ${method} ${url}`);
+          this.logger.error(`  \u2192 ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      if (typeof window !== "undefined") {
+        try {
+          if (isCORSError) {
+            window.dispatchEvent(new CustomEvent("cors-error", {
+              detail: {
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              bubbles: true,
+              cancelable: false
+            }));
+          } else {
+            window.dispatchEvent(new CustomEvent("network-error", {
+              detail: {
+                url,
+                method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              bubbles: true,
+              cancelable: false
+            }));
+          }
+        } catch (eventError) {
+        }
+      }
+      const networkError = error instanceof Error ? new NetworkError(error.message, url, error) : new NetworkError("Unknown error", url);
+      if (this.logger) {
+        this.logger.logError(
+          {
+            method,
+            url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime
+          },
+          {
+            message: networkError.message,
+            duration,
+            timestamp: Date.now()
+          }
+        );
+      }
+      throw networkError;
+    }
+  }
+};
+
+// src/api/generated/ext_support/storage.ts
+var LocalStorageAdapter = class {
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  getItem(key) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const value = localStorage.getItem(key);
+        this.logger?.debug(`LocalStorage.getItem("${key}"): ${value ? "found" : "not found"}`);
+        return value;
+      }
+      this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+    } catch (error) {
+      this.logger?.error("LocalStorage.getItem failed:", error);
+    }
+    return null;
+  }
+  setItem(key, value) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        localStorage.setItem(key, value);
+        this.logger?.debug(`LocalStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+      }
+    } catch (error) {
+      this.logger?.error("LocalStorage.setItem failed:", error);
+    }
+  }
+  removeItem(key) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        localStorage.removeItem(key);
+        this.logger?.debug(`LocalStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn("LocalStorage not available: window.localStorage is undefined");
+      }
+    } catch (error) {
+      this.logger?.error("LocalStorage.removeItem failed:", error);
+    }
+  }
+};
+var CookieStorageAdapter = class {
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  getItem(key) {
+    try {
+      if (typeof document === "undefined") {
+        this.logger?.warn("Cookies not available: document is undefined (SSR context?)");
+        return null;
+      }
+      const value = `; ${document.cookie}`;
+      const parts = value.split(`; ${key}=`);
+      if (parts.length === 2) {
+        const result = parts.pop()?.split(";").shift() || null;
+        this.logger?.debug(`CookieStorage.getItem("${key}"): ${result ? "found" : "not found"}`);
+        return result;
+      }
+      this.logger?.debug(`CookieStorage.getItem("${key}"): not found`);
+    } catch (error) {
+      this.logger?.error("CookieStorage.getItem failed:", error);
+    }
+    return null;
+  }
+  setItem(key, value) {
+    try {
+      if (typeof document !== "undefined") {
+        document.cookie = `${key}=${value}; path=/; max-age=31536000`;
+        this.logger?.debug(`CookieStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn("Cookies not available: document is undefined (SSR context?)");
+      }
+    } catch (error) {
+      this.logger?.error("CookieStorage.setItem failed:", error);
+    }
+  }
+  removeItem(key) {
+    try {
+      if (typeof document !== "undefined") {
+        document.cookie = `${key}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+        this.logger?.debug(`CookieStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn("Cookies not available: document is undefined (SSR context?)");
+      }
+    } catch (error) {
+      this.logger?.error("CookieStorage.removeItem failed:", error);
+    }
+  }
+};
+var MemoryStorageAdapter = class {
+  storage = /* @__PURE__ */ new Map();
+  logger;
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  getItem(key) {
+    const value = this.storage.get(key) || null;
+    this.logger?.debug(`MemoryStorage.getItem("${key}"): ${value ? "found" : "not found"}`);
+    return value;
+  }
+  setItem(key, value) {
+    this.storage.set(key, value);
+    this.logger?.debug(`MemoryStorage.setItem("${key}"): success`);
+  }
+  removeItem(key) {
+    this.storage.delete(key);
+    this.logger?.debug(`MemoryStorage.removeItem("${key}"): success`);
+  }
+};
+
+// src/api/generated/ext_support/enums.ts
+var enums_exports = {};
+__export(enums_exports, {
+  PatchedTicketRequestStatus: () => PatchedTicketRequestStatus,
+  TicketRequestStatus: () => TicketRequestStatus,
+  TicketStatus: () => TicketStatus
+});
+var PatchedTicketRequestStatus = /* @__PURE__ */ ((PatchedTicketRequestStatus2) => {
+  PatchedTicketRequestStatus2["OPEN"] = "open";
+  PatchedTicketRequestStatus2["WAITING_FOR_USER"] = "waiting_for_user";
+  PatchedTicketRequestStatus2["WAITING_FOR_ADMIN"] = "waiting_for_admin";
+  PatchedTicketRequestStatus2["RESOLVED"] = "resolved";
+  PatchedTicketRequestStatus2["CLOSED"] = "closed";
+  return PatchedTicketRequestStatus2;
+})(PatchedTicketRequestStatus || {});
+var TicketStatus = /* @__PURE__ */ ((TicketStatus2) => {
+  TicketStatus2["OPEN"] = "open";
+  TicketStatus2["WAITING_FOR_USER"] = "waiting_for_user";
+  TicketStatus2["WAITING_FOR_ADMIN"] = "waiting_for_admin";
+  TicketStatus2["RESOLVED"] = "resolved";
+  TicketStatus2["CLOSED"] = "closed";
+  return TicketStatus2;
+})(TicketStatus || {});
+var TicketRequestStatus = /* @__PURE__ */ ((TicketRequestStatus2) => {
+  TicketRequestStatus2["OPEN"] = "open";
+  TicketRequestStatus2["WAITING_FOR_USER"] = "waiting_for_user";
+  TicketRequestStatus2["WAITING_FOR_ADMIN"] = "waiting_for_admin";
+  TicketRequestStatus2["RESOLVED"] = "resolved";
+  TicketRequestStatus2["CLOSED"] = "closed";
+  return TicketRequestStatus2;
+})(TicketRequestStatus || {});
+
+// src/api/generated/ext_support/_utils/schemas/index.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  MessageCreateRequestSchema: () => MessageCreateRequestSchema,
+  MessageCreateSchema: () => MessageCreateSchema,
+  MessageRequestSchema: () => MessageRequestSchema,
+  MessageSchema: () => MessageSchema,
+  PaginatedMessageListSchema: () => PaginatedMessageListSchema,
+  PaginatedTicketListSchema: () => PaginatedTicketListSchema,
+  PatchedMessageRequestSchema: () => PatchedMessageRequestSchema,
+  PatchedTicketRequestSchema: () => PatchedTicketRequestSchema,
+  SenderSchema: () => SenderSchema,
+  TicketRequestSchema: () => TicketRequestSchema,
+  TicketSchema: () => TicketSchema
+});
+var SenderSchema = z.object({
+  id: z.int(),
+  display_username: z.string(),
+  email: z.email(),
+  avatar: z.string().nullable(),
+  initials: z.string(),
+  is_staff: z.boolean(),
+  is_superuser: z.boolean()
+});
+
+// src/api/generated/ext_support/_utils/schemas/Message.schema.ts
+var MessageSchema = z.object({
+  uuid: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  ticket: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  sender: SenderSchema,
+  is_from_author: z.boolean(),
+  text: z.string(),
+  created_at: z.iso.datetime()
+});
+var MessageCreateSchema = z.object({
+  text: z.string()
+});
+var MessageCreateRequestSchema = z.object({
+  text: z.string().min(1)
+});
+var MessageRequestSchema = z.object({
+  text: z.string().min(1)
+});
+var PaginatedMessageListSchema = z.object({
+  count: z.int(),
+  page: z.int(),
+  pages: z.int(),
+  page_size: z.int(),
+  has_next: z.boolean(),
+  has_previous: z.boolean(),
+  next_page: z.int().nullable().optional(),
+  previous_page: z.int().nullable().optional(),
+  results: z.array(MessageSchema)
+});
+var TicketSchema = z.object({
+  uuid: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  user: z.int(),
+  subject: z.string().max(255),
+  status: z.nativeEnum(TicketStatus).optional(),
+  created_at: z.iso.datetime(),
+  unanswered_messages_count: z.int()
+});
+
+// src/api/generated/ext_support/_utils/schemas/PaginatedTicketList.schema.ts
+var PaginatedTicketListSchema = z.object({
+  count: z.int(),
+  page: z.int(),
+  pages: z.int(),
+  page_size: z.int(),
+  has_next: z.boolean(),
+  has_previous: z.boolean(),
+  next_page: z.int().nullable().optional(),
+  previous_page: z.int().nullable().optional(),
+  results: z.array(TicketSchema)
+});
+var PatchedMessageRequestSchema = z.object({
+  text: z.string().min(1).optional()
+});
+var PatchedTicketRequestSchema = z.object({
+  user: z.int().optional(),
+  subject: z.string().min(1).max(255).optional(),
+  status: z.nativeEnum(PatchedTicketRequestStatus).optional()
+});
+var TicketRequestSchema = z.object({
+  user: z.int(),
+  subject: z.string().min(1).max(255),
+  status: z.nativeEnum(TicketRequestStatus).optional()
+});
+
+// src/api/generated/ext_support/validation-events.ts
+function dispatchValidationError(detail) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    const event = new CustomEvent("zod-validation-error", {
+      detail,
+      bubbles: true,
+      cancelable: false
+    });
+    window.dispatchEvent(event);
+  } catch (error) {
+    console.warn("Failed to dispatch validation error event:", error);
+  }
+}
+function onValidationError(callback) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const handler = (event) => {
+    if (event instanceof CustomEvent) {
+      callback(event.detail);
+    }
+  };
+  window.addEventListener("zod-validation-error", handler);
+  return () => {
+    window.removeEventListener("zod-validation-error", handler);
+  };
+}
+function formatZodError(error) {
+  const issues = error.issues.map((issue, index) => {
+    const path = issue.path.join(".") || "root";
+    const parts = [`${index + 1}. ${path}: ${issue.message}`];
+    if ("expected" in issue && issue.expected) {
+      parts.push(`   Expected: ${issue.expected}`);
+    }
+    if ("received" in issue && issue.received) {
+      parts.push(`   Received: ${issue.received}`);
+    }
+    return parts.join("\n");
+  });
+  return issues.join("\n");
+}
+
+// src/api/generated/ext_support/_utils/fetchers/index.ts
+var fetchers_exports = {};
+__export(fetchers_exports, {
+  createSupportTicketsCreate: () => createSupportTicketsCreate,
+  createSupportTicketsMessagesCreate: () => createSupportTicketsMessagesCreate,
+  deleteSupportTicketsDestroy: () => deleteSupportTicketsDestroy,
+  deleteSupportTicketsMessagesDestroy: () => deleteSupportTicketsMessagesDestroy,
+  getSupportTicketsList: () => getSupportTicketsList,
+  getSupportTicketsMessagesList: () => getSupportTicketsMessagesList,
+  getSupportTicketsMessagesRetrieve: () => getSupportTicketsMessagesRetrieve,
+  getSupportTicketsRetrieve: () => getSupportTicketsRetrieve,
+  partialUpdateSupportTicketsMessagesPartialUpdate: () => partialUpdateSupportTicketsMessagesPartialUpdate,
+  partialUpdateSupportTicketsPartialUpdate: () => partialUpdateSupportTicketsPartialUpdate,
+  updateSupportTicketsMessagesUpdate: () => updateSupportTicketsMessagesUpdate,
+  updateSupportTicketsUpdate: () => updateSupportTicketsUpdate
+});
+
+// src/api/generated/ext_support/api-instance.ts
+var globalAPI = null;
+function getAPIInstance() {
+  if (!globalAPI) {
+    throw new Error(
+      'API not configured. Call configureAPI() with your base URL before using fetchers or hooks.\n\nExample:\n  import { configureAPI } from "./api-instance"\n  configureAPI({ baseUrl: "https://api.example.com" })'
+    );
+  }
+  return globalAPI;
+}
+function isAPIConfigured() {
+  return globalAPI !== null;
+}
+function configureAPI(config) {
+  globalAPI = new API(config.baseUrl, config.options);
+  if (config.token) {
+    globalAPI.setToken(config.token, config.refreshToken);
+  }
+  return globalAPI;
+}
+function reconfigureAPI(updates) {
+  const instance = getAPIInstance();
+  if (updates.baseUrl) {
+    instance.setBaseUrl(updates.baseUrl);
+  }
+  if (updates.token) {
+    instance.setToken(updates.token, updates.refreshToken);
+  }
+  return instance;
+}
+function clearAPITokens() {
+  const instance = getAPIInstance();
+  instance.clearTokens();
+}
+function resetAPI() {
+  if (globalAPI) {
+    globalAPI.clearTokens();
+  }
+  globalAPI = null;
+}
+
+// src/api/generated/ext_support/_utils/fetchers/ext_support__support.ts
+async function getSupportTicketsList(params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsList(params?.page, params?.page_size);
+  try {
+    return PaginatedTicketListSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`getSupportTicketsList
+Path: /cfg/support/tickets/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getSupportTicketsList",
+            path: "/cfg/support/tickets/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function createSupportTicketsCreate(data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsCreate(data);
+  try {
+    return TicketSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`createSupportTicketsCreate
+Path: /cfg/support/tickets/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createSupportTicketsCreate",
+            path: "/cfg/support/tickets/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getSupportTicketsMessagesList(ticket_uuid, params, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsMessagesList(ticket_uuid, params?.page, params?.page_size);
+  try {
+    return PaginatedMessageListSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`getSupportTicketsMessagesList
+Path: /cfg/support/tickets/{ticket_uuid}/messages/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getSupportTicketsMessagesList",
+            path: "/cfg/support/tickets/{ticket_uuid}/messages/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function createSupportTicketsMessagesCreate(ticket_uuid, data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsMessagesCreate(ticket_uuid, data);
+  try {
+    return MessageCreateSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`createSupportTicketsMessagesCreate
+Path: /cfg/support/tickets/{ticket_uuid}/messages/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "createSupportTicketsMessagesCreate",
+            path: "/cfg/support/tickets/{ticket_uuid}/messages/",
+            method: "POST",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function getSupportTicketsMessagesRetrieve(ticket_uuid, uuid, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsMessagesRetrieve(ticket_uuid, uuid);
+  try {
+    return MessageSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`getSupportTicketsMessagesRetrieve
+Path: /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getSupportTicketsMessagesRetrieve",
+            path: "/cfg/support/tickets/{ticket_uuid}/messages/{uuid}/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function updateSupportTicketsMessagesUpdate(ticket_uuid, uuid, data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsMessagesUpdate(ticket_uuid, uuid, data);
+  try {
+    return MessageSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`updateSupportTicketsMessagesUpdate
+Path: /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+Method: PUT`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "updateSupportTicketsMessagesUpdate",
+            path: "/cfg/support/tickets/{ticket_uuid}/messages/{uuid}/",
+            method: "PUT",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function partialUpdateSupportTicketsMessagesPartialUpdate(ticket_uuid, uuid, data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsMessagesPartialUpdate(ticket_uuid, uuid, data);
+  try {
+    return MessageSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`partialUpdateSupportTicketsMessagesPartialUpdate
+Path: /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+Method: PATCH`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "partialUpdateSupportTicketsMessagesPartialUpdate",
+            path: "/cfg/support/tickets/{ticket_uuid}/messages/{uuid}/",
+            method: "PATCH",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function deleteSupportTicketsMessagesDestroy(ticket_uuid, uuid, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsMessagesDestroy(ticket_uuid, uuid);
+  return response;
+}
+async function getSupportTicketsRetrieve(uuid, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsRetrieve(uuid);
+  try {
+    return TicketSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`getSupportTicketsRetrieve
+Path: /cfg/support/tickets/{uuid}/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "getSupportTicketsRetrieve",
+            path: "/cfg/support/tickets/{uuid}/",
+            method: "GET",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function updateSupportTicketsUpdate(uuid, data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsUpdate(uuid, data);
+  try {
+    return TicketSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`updateSupportTicketsUpdate
+Path: /cfg/support/tickets/{uuid}/
+Method: PUT`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "updateSupportTicketsUpdate",
+            path: "/cfg/support/tickets/{uuid}/",
+            method: "PUT",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function partialUpdateSupportTicketsPartialUpdate(uuid, data, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsPartialUpdate(uuid, data);
+  try {
+    return TicketSchema.parse(response);
+  } catch (error) {
+    consola.error("\u274C Zod Validation Failed");
+    consola.box(`partialUpdateSupportTicketsPartialUpdate
+Path: /cfg/support/tickets/{uuid}/
+Method: PATCH`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.error("Response data:", response);
+    if (typeof window !== "undefined" && error instanceof Error && "issues" in error) {
+      try {
+        const event = new CustomEvent("zod-validation-error", {
+          detail: {
+            operation: "partialUpdateSupportTicketsPartialUpdate",
+            path: "/cfg/support/tickets/{uuid}/",
+            method: "PATCH",
+            error,
+            response,
+            timestamp: /* @__PURE__ */ new Date()
+          },
+          bubbles: true,
+          cancelable: false
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        consola.warn("Failed to dispatch validation error event:", eventError);
+      }
+    }
+    throw error;
+  }
+}
+async function deleteSupportTicketsDestroy(uuid, client) {
+  const api = client || getAPIInstance();
+  const response = await api.ext_support_support.ticketsDestroy(uuid);
+  return response;
+}
+
+// src/api/generated/ext_support/index.ts
+var TOKEN_KEY = "auth_token";
+var REFRESH_TOKEN_KEY = "refresh_token";
+var API = class {
+  baseUrl;
+  _client;
+  _token = null;
+  _refreshToken = null;
+  storage;
+  options;
+  // Sub-clients
+  ext_support_support;
+  constructor(baseUrl, options) {
+    this.baseUrl = baseUrl;
+    this.options = options;
+    const logger2 = options?.loggerConfig ? new APILogger(options.loggerConfig) : void 0;
+    this.storage = options?.storage || new LocalStorageAdapter(logger2);
+    this._loadTokensFromStorage();
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
+    });
+    this._injectAuthHeader();
+    this.ext_support_support = this._client.ext_support_support;
+  }
+  _loadTokensFromStorage() {
+    this._token = this.storage.getItem(TOKEN_KEY);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+  _reinitClients() {
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig
+    });
+    this._injectAuthHeader();
+    this.ext_support_support = this._client.ext_support_support;
+  }
+  _injectAuthHeader() {
+    const originalRequest = this._client.request.bind(this._client);
+    this._client.request = async (method, path, options) => {
+      const token = this.getToken();
+      const mergedOptions = {
+        ...options,
+        headers: {
+          ...options?.headers || {},
+          ...token ? { "Authorization": `Bearer ${token}` } : {}
+        }
+      };
+      return originalRequest(method, path, mergedOptions);
+    };
+  }
+  /**
+   * Get current JWT token
+   */
+  getToken() {
+    return this.storage.getItem(TOKEN_KEY);
+  }
+  /**
+   * Get current refresh token
+   */
+  getRefreshToken() {
+    return this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+  /**
+   * Set JWT token and refresh token
+   * @param token - JWT access token
+   * @param refreshToken - JWT refresh token (optional)
+   */
+  setToken(token, refreshToken) {
+    this._token = token;
+    this.storage.setItem(TOKEN_KEY, token);
+    if (refreshToken) {
+      this._refreshToken = refreshToken;
+      this.storage.setItem(REFRESH_TOKEN_KEY, refreshToken);
+    }
+    this._reinitClients();
+  }
+  /**
+   * Clear all tokens
+   */
+  clearTokens() {
+    this._token = null;
+    this._refreshToken = null;
+    this.storage.removeItem(TOKEN_KEY);
+    this.storage.removeItem(REFRESH_TOKEN_KEY);
+    this._reinitClients();
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return !!this.getToken();
+  }
+  /**
+   * Update base URL and reinitialize clients
+   * @param url - New base URL
+   */
+  setBaseUrl(url) {
+    this.baseUrl = url;
+    this._reinitClients();
+  }
+  /**
+   * Get current base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * 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() {
+    return "./schema.json";
+  }
+};
+var apiSupport = createExtensionAPI(API);
+function useSupportTicketsList(params, client) {
+  return useSWR(
+    params ? ["cfg-support-tickets", params] : "cfg-support-tickets",
+    () => getSupportTicketsList(params, client)
+  );
+}
+function useCreateSupportTicketsCreate() {
+  const { mutate } = useSWRConfig();
+  return async (data, client) => {
+    const result = await createSupportTicketsCreate(data, client);
+    mutate("cfg-support-tickets");
+    return result;
+  };
+}
+function useSupportTicketsMessagesList(ticket_uuid, params, client) {
+  return useSWR(
+    ["cfg-support-tickets-messages", ticket_uuid],
+    () => getSupportTicketsMessagesList(ticket_uuid, params, client)
+  );
+}
+function useCreateSupportTicketsMessagesCreate() {
+  const { mutate } = useSWRConfig();
+  return async (ticket_uuid, data, client) => {
+    const result = await createSupportTicketsMessagesCreate(ticket_uuid, data, client);
+    mutate("cfg-support-tickets-messages");
+    return result;
+  };
+}
+function useSupportTicketsMessagesRetrieve(ticket_uuid, uuid, client) {
+  return useSWR(
+    ["cfg-support-tickets-message", ticket_uuid],
+    () => getSupportTicketsMessagesRetrieve(ticket_uuid, uuid, client)
+  );
+}
+function useUpdateSupportTicketsMessagesUpdate() {
+  const { mutate } = useSWRConfig();
+  return async (ticket_uuid, uuid, data, client) => {
+    const result = await updateSupportTicketsMessagesUpdate(ticket_uuid, uuid, data, client);
+    mutate("cfg-support-tickets-messages");
+    mutate("cfg-support-tickets-message");
+    return result;
+  };
+}
+function usePartialUpdateSupportTicketsMessagesPartialUpdate() {
+  const { mutate } = useSWRConfig();
+  return async (ticket_uuid, uuid, data, client) => {
+    const result = await partialUpdateSupportTicketsMessagesPartialUpdate(ticket_uuid, uuid, data, client);
+    mutate("cfg-support-tickets-messages-partial");
+    return result;
+  };
+}
+function useDeleteSupportTicketsMessagesDestroy() {
+  const { mutate } = useSWRConfig();
+  return async (ticket_uuid, uuid, client) => {
+    const result = await deleteSupportTicketsMessagesDestroy(ticket_uuid, uuid, client);
+    mutate("cfg-support-tickets-messages");
+    mutate("cfg-support-tickets-message");
+    return result;
+  };
+}
+function useSupportTicketsRetrieve(uuid, client) {
+  return useSWR(
+    ["cfg-support-ticket", uuid],
+    () => getSupportTicketsRetrieve(uuid, client)
+  );
+}
+function useUpdateSupportTicketsUpdate() {
+  const { mutate } = useSWRConfig();
+  return async (uuid, data, client) => {
+    const result = await updateSupportTicketsUpdate(uuid, data, client);
+    mutate("cfg-support-tickets");
+    mutate("cfg-support-ticket");
+    return result;
+  };
+}
+function usePartialUpdateSupportTicketsPartialUpdate() {
+  const { mutate } = useSWRConfig();
+  return async (uuid, data, client) => {
+    const result = await partialUpdateSupportTicketsPartialUpdate(uuid, data, client);
+    mutate("cfg-support-tickets-partial");
+    return result;
+  };
+}
+function useDeleteSupportTicketsDestroy() {
+  const { mutate } = useSWRConfig();
+  return async (uuid, client) => {
+    const result = await deleteSupportTicketsDestroy(uuid, client);
+    mutate("cfg-support-tickets");
+    mutate("cfg-support-ticket");
+    return result;
+  };
+}
+var SupportContext = createContext(void 0);
+function SupportProvider({ children }) {
+  const {
+    data: ticketsData,
+    error: ticketsError,
+    isLoading: isLoadingTickets,
+    mutate: mutateTickets
+  } = useSupportTicketsList({ page: 1, page_size: 1 });
+  const refreshTickets = async () => {
+    await mutateTickets();
+  };
+  const createTicketMutation = useCreateSupportTicketsCreate();
+  const updateTicketMutation = useUpdateSupportTicketsUpdate();
+  usePartialUpdateSupportTicketsPartialUpdate();
+  const deleteTicketMutation = useDeleteSupportTicketsDestroy();
+  const createMessageMutation = useCreateSupportTicketsMessagesCreate();
+  const updateMessageMutation = useUpdateSupportTicketsMessagesUpdate();
+  usePartialUpdateSupportTicketsMessagesPartialUpdate();
+  const deleteMessageMutation = useDeleteSupportTicketsMessagesDestroy();
+  const getTicket = async (uuid) => {
+    const { data } = useSupportTicketsRetrieve(uuid);
+    return data;
+  };
+  const createTicket = async (data) => {
+    const result = await createTicketMutation(data);
+    await refreshTickets();
+    return result;
+  };
+  const updateTicket = async (uuid, data) => {
+    const result = await updateTicketMutation(uuid, data);
+    await refreshTickets();
+    return result;
+  };
+  const partialUpdateTicket = async (uuid, data) => {
+    const result = await updateTicketMutation(uuid, data);
+    await refreshTickets();
+    return result;
+  };
+  const deleteTicket = async (uuid) => {
+    await deleteTicketMutation(uuid);
+    await refreshTickets();
+  };
+  const getMessages = async (ticketUuid) => {
+    const { data } = useSupportTicketsMessagesList(ticketUuid, { page: 1, page_size: 100 });
+    return data?.results;
+  };
+  const getMessage = async (ticketUuid, messageUuid) => {
+    const { data } = useSupportTicketsMessagesRetrieve(
+      ticketUuid,
+      messageUuid
+    );
+    return data;
+  };
+  const createMessage = async (ticketUuid, data) => {
+    const result = await createMessageMutation(ticketUuid, data);
+    return result;
+  };
+  const updateMessage = async (ticketUuid, messageUuid, data) => {
+    const result = await updateMessageMutation(
+      ticketUuid,
+      messageUuid,
+      data
+    );
+    return result;
+  };
+  const partialUpdateMessage = async (ticketUuid, messageUuid, data) => {
+    const result = await updateMessageMutation(
+      ticketUuid,
+      messageUuid,
+      data
+    );
+    return result;
+  };
+  const deleteMessage = async (ticketUuid, messageUuid) => {
+    await deleteMessageMutation(ticketUuid, messageUuid);
+  };
+  const refreshMessages = async (ticketUuid) => {
+    await refreshTickets();
+  };
+  const value = {
+    tickets: ticketsData?.results,
+    isLoadingTickets,
+    ticketsError,
+    refreshTickets,
+    getTicket,
+    createTicket,
+    updateTicket,
+    partialUpdateTicket,
+    deleteTicket,
+    getMessages,
+    getMessage,
+    createMessage,
+    updateMessage,
+    partialUpdateMessage,
+    deleteMessage,
+    refreshMessages
+  };
+  return /* @__PURE__ */ jsx(SupportContext.Provider, { value, children });
+}
+function useSupportContext() {
+  const context = useContext(SupportContext);
+  if (!context) {
+    throw new Error("useSupportContext must be used within SupportProvider");
+  }
+  return context;
+}
+
+// src/layouts/SupportLayout/events.ts
+var SUPPORT_LAYOUT_EVENTS = {
+  // Dialog events
+  OPEN_CREATE_DIALOG: "support-layout:open-create-dialog",
+  CLOSE_CREATE_DIALOG: "support-layout:close-create-dialog",
+  // Ticket events
+  TICKET_SELECTED: "support-layout:ticket-selected",
+  TICKET_CREATED: "support-layout:ticket-created",
+  // Message events
+  MESSAGE_SENT: "support-layout:message-sent"
+};
+var openCreateTicketDialog = () => {
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent(SUPPORT_LAYOUT_EVENTS.OPEN_CREATE_DIALOG));
+  }
+};
+var closeCreateTicketDialog = () => {
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent(SUPPORT_LAYOUT_EVENTS.CLOSE_CREATE_DIALOG));
+  }
+};
+var PAGE_SIZE = 20;
+function useInfiniteTickets() {
+  const getKey = (pageIndex, previousPageData) => {
+    if (previousPageData && !previousPageData.has_next) return null;
+    if (pageIndex === 0) return ["cfg-support-tickets-infinite", 1, PAGE_SIZE];
+    return ["cfg-support-tickets-infinite", pageIndex + 1, PAGE_SIZE];
+  };
+  const fetcher = async ([, page, pageSize]) => {
+    return getSupportTicketsList(
+      { page, page_size: pageSize }
+    );
+  };
+  const {
+    data,
+    error,
+    isLoading,
+    isValidating,
+    size,
+    setSize,
+    mutate
+  } = useSWRInfinite(getKey, fetcher, {
+    revalidateFirstPage: false,
+    parallel: false
+  });
+  const tickets = data ? data.flatMap((page) => page.results) : [];
+  const hasMore = data && data[data.length - 1]?.has_next;
+  const totalCount = data && data[data.length - 1]?.count;
+  const isLoadingMore = isValidating && data && typeof data[size - 1] !== "undefined";
+  const loadMore = () => {
+    if (hasMore && !isLoadingMore) {
+      setSize(size + 1);
+    }
+  };
+  const refresh = async () => {
+    await mutate();
+  };
+  return {
+    tickets,
+    isLoading,
+    isLoadingMore: isLoadingMore || false,
+    error,
+    hasMore: hasMore || false,
+    totalCount: totalCount || 0,
+    loadMore,
+    refresh
+  };
+}
+var PAGE_SIZE2 = 20;
+function useInfiniteMessages(ticketUuid) {
+  const getKey = (pageIndex, previousPageData) => {
+    if (!ticketUuid) return null;
+    if (previousPageData && !previousPageData.has_next) return null;
+    if (pageIndex === 0) return ["cfg-support-messages-infinite", ticketUuid, 1, PAGE_SIZE2];
+    return ["cfg-support-messages-infinite", ticketUuid, pageIndex + 1, PAGE_SIZE2];
+  };
+  const fetcher = async ([, ticket_uuid, page, pageSize]) => {
+    return getSupportTicketsMessagesList(
+      ticket_uuid,
+      { page, page_size: pageSize }
+    );
+  };
+  const {
+    data,
+    error,
+    isLoading,
+    isValidating,
+    size,
+    setSize,
+    mutate
+  } = useSWRInfinite(getKey, fetcher, {
+    revalidateFirstPage: false,
+    parallel: false
+  });
+  const messages = data ? data.flatMap((page) => page.results) : [];
+  const hasMore = data && data[data.length - 1]?.has_next;
+  const totalCount = data && data[data.length - 1]?.count;
+  const isLoadingMore = !!(isValidating && data && typeof data[size - 1] !== "undefined");
+  const loadMore = () => {
+    if (hasMore && !isLoadingMore) {
+      setSize(size + 1);
+    }
+  };
+  const refresh = async () => {
+    await mutate();
+  };
+  const addMessage = (message) => {
+    if (!data || !data[0]) return;
+    const newData = [...data];
+    const firstPage = newData[0];
+    if (firstPage) {
+      newData[0] = {
+        ...firstPage,
+        results: [message, ...firstPage.results],
+        count: firstPage.count + 1,
+        page: firstPage.page || 1,
+        pages: firstPage.pages || 1
+      };
+    }
+    mutate(newData, false);
+  };
+  return {
+    messages,
+    isLoading,
+    isLoadingMore: isLoadingMore || false,
+    error,
+    hasMore: hasMore || false,
+    totalCount: totalCount || 0,
+    loadMore,
+    refresh,
+    addMessage
+  };
+}
+var SupportLayoutContext = createContext(void 0);
+function SupportLayoutProvider({ children }) {
+  const support = useSupportContext();
+  const { user } = useAuth();
+  const [uiState, setUIState] = useState({
+    selectedTicketUuid: null,
+    isCreateDialogOpen: false,
+    viewMode: "list"
+  });
+  const selectedTicket = support.tickets?.find((t) => t.uuid === uiState.selectedTicketUuid);
+  const {
+    messages: selectedTicketMessages,
+    isLoading: isLoadingMessages,
+    isLoadingMore: isLoadingMoreMessages,
+    hasMore: hasMoreMessages,
+    totalCount: totalMessagesCount,
+    loadMore: loadMoreMessages,
+    refresh: refreshMessages,
+    addMessage: addMessageOptimistically
+  } = useInfiniteMessages(selectedTicket?.uuid || null);
+  const selectTicket = useCallback(async (ticket) => {
+    setUIState((prev) => ({ ...prev, selectedTicketUuid: ticket?.uuid || null }));
+    if (ticket?.uuid) {
+      window.dispatchEvent(
+        new CustomEvent(SUPPORT_LAYOUT_EVENTS.TICKET_SELECTED, { detail: { ticket } })
+      );
+    }
+  }, []);
+  const createTicket = useCallback(async (data) => {
+    if (!user?.id) {
+      throw new Error("User must be authenticated to create tickets");
+    }
+    const ticket = await support.createTicket({
+      user: user.id,
+      subject: data.subject
+    });
+    if (ticket.uuid && data.message) {
+      await support.createMessage(ticket.uuid, {
+        text: data.message
+      });
+    }
+    setUIState((prev) => ({ ...prev, isCreateDialogOpen: false }));
+    await support.refreshTickets();
+    window.dispatchEvent(
+      new CustomEvent(SUPPORT_LAYOUT_EVENTS.TICKET_CREATED, { detail: { ticket } })
+    );
+    setUIState((prev) => ({ ...prev, selectedTicketUuid: ticket.uuid }));
+    window.dispatchEvent(
+      new CustomEvent(SUPPORT_LAYOUT_EVENTS.TICKET_SELECTED, { detail: { ticket } })
+    );
+  }, [support, user]);
+  const sendMessage = useCallback(async (message) => {
+    if (!selectedTicket?.uuid) return;
+    const messageData = {
+      text: message
+    };
+    const newMessage = await support.createMessage(selectedTicket.uuid, messageData);
+    if (newMessage) {
+      const fullMessage = {
+        uuid: newMessage.uuid || `temp-${Date.now()}`,
+        ticket: selectedTicket.uuid,
+        sender: {
+          id: user?.id || 0,
+          display_username: user?.display_username || "",
+          email: user?.email || "",
+          avatar: user?.avatar || null,
+          initials: user?.initials || "",
+          is_staff: user?.is_staff || false,
+          is_superuser: user?.is_superuser || false
+        },
+        is_from_author: true,
+        text: message,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      addMessageOptimistically(fullMessage);
+    }
+    await refreshMessages();
+    window.dispatchEvent(
+      new CustomEvent(SUPPORT_LAYOUT_EVENTS.MESSAGE_SENT, { detail: { message: newMessage } })
+    );
+  }, [selectedTicket, support, user, addMessageOptimistically, refreshMessages]);
+  const openCreateDialog = useCallback(() => {
+    setUIState((prev) => ({ ...prev, isCreateDialogOpen: true }));
+  }, []);
+  const closeCreateDialog = useCallback(() => {
+    setUIState((prev) => ({ ...prev, isCreateDialogOpen: false }));
+  }, []);
+  const getUnreadCount = useCallback(() => {
+    return support.tickets?.reduce((count, ticket) => count + (ticket.unanswered_messages_count || 0), 0) || 0;
+  }, [support.tickets]);
+  useEffect(() => {
+    const handleOpenDialog = () => openCreateDialog();
+    const handleCloseDialog = () => closeCreateDialog();
+    window.addEventListener(SUPPORT_LAYOUT_EVENTS.OPEN_CREATE_DIALOG, handleOpenDialog);
+    window.addEventListener(SUPPORT_LAYOUT_EVENTS.CLOSE_CREATE_DIALOG, handleCloseDialog);
+    return () => {
+      window.removeEventListener(SUPPORT_LAYOUT_EVENTS.OPEN_CREATE_DIALOG, handleOpenDialog);
+      window.removeEventListener(SUPPORT_LAYOUT_EVENTS.CLOSE_CREATE_DIALOG, handleCloseDialog);
+    };
+  }, [openCreateDialog, closeCreateDialog]);
+  const value = {
+    tickets: support.tickets,
+    isLoadingTickets: support.isLoadingTickets,
+    ticketsError: support.ticketsError,
+    selectedTicket,
+    selectedTicketMessages,
+    isLoadingMessages,
+    isLoadingMoreMessages,
+    hasMoreMessages,
+    totalMessagesCount,
+    loadMoreMessages,
+    uiState,
+    selectTicket,
+    createTicket,
+    sendMessage,
+    refreshTickets: support.refreshTickets,
+    refreshMessages,
+    openCreateDialog,
+    closeCreateDialog,
+    getUnreadCount
+  };
+  return /* @__PURE__ */ jsx(SupportLayoutContext.Provider, { value, children });
+}
+function useSupportLayoutContext() {
+  const context = useContext(SupportLayoutContext);
+  if (!context) {
+    throw new Error("useSupportLayoutContext must be used within SupportLayoutProvider");
+  }
+  return context;
+}
+var getStatusBadgeVariant = (status) => {
+  switch (status) {
+    case "open":
+      return "default";
+    case "waiting_for_user":
+      return "secondary";
+    case "waiting_for_admin":
+      return "outline";
+    case "resolved":
+      return "outline";
+    case "closed":
+      return "secondary";
+    default:
+      return "default";
+  }
+};
+var formatRelativeTime = (date) => {
+  if (!date) return "N/A";
+  const now = /* @__PURE__ */ new Date();
+  const messageDate = new Date(date);
+  const diffInSeconds = Math.floor((now.getTime() - messageDate.getTime()) / 1e3);
+  if (diffInSeconds < 60) return "Just now";
+  if (diffInSeconds < 3600) return `${Math.floor(diffInSeconds / 60)}m ago`;
+  if (diffInSeconds < 86400) return `${Math.floor(diffInSeconds / 3600)}h ago`;
+  if (diffInSeconds < 604800) return `${Math.floor(diffInSeconds / 86400)}d ago`;
+  return new Date(date).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+};
+var TicketCard = ({ ticket, isSelected, onClick }) => {
+  return /* @__PURE__ */ jsx(
+    Card,
+    {
+      className: cn(
+        "cursor-pointer transition-all duration-200 ease-out",
+        "hover:bg-accent/50 hover:shadow-md hover:scale-[1.02]",
+        "active:scale-[0.98]",
+        isSelected && "bg-accent border-primary shadow-sm"
+      ),
+      onClick,
+      children: /* @__PURE__ */ jsxs(CardContent, { className: "p-4", children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between mb-2", children: [
+          /* @__PURE__ */ jsx("h3", { className: "font-semibold text-sm line-clamp-2 flex-1", children: ticket.subject }),
+          (ticket.unanswered_messages_count || 0) > 0 && /* @__PURE__ */ jsx(
+            Badge,
+            {
+              variant: "destructive",
+              className: "ml-2 shrink-0 animate-pulse",
+              children: ticket.unanswered_messages_count
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "flex items-center justify-between text-xs text-muted-foreground", children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+          /* @__PURE__ */ jsx(Badge, { variant: getStatusBadgeVariant(ticket.status || "open"), className: "text-xs", children: ticket.status || "open" }),
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1", children: [
+            /* @__PURE__ */ jsx(Clock, { className: "h-3 w-3" }),
+            /* @__PURE__ */ jsx("span", { children: formatRelativeTime(ticket.created_at) })
+          ] })
+        ] }) })
+      ] })
+    }
+  );
+};
+var TicketList = () => {
+  const { selectedTicket, selectTicket } = useSupportLayoutContext();
+  const {
+    tickets,
+    isLoading,
+    isLoadingMore,
+    hasMore,
+    loadMore,
+    totalCount,
+    refresh
+  } = useInfiniteTickets();
+  const scrollRef = useRef(null);
+  const observerRef = useRef(null);
+  const loadMoreRef = useRef(null);
+  useEffect(() => {
+    const handleTicketCreated = () => {
+      refresh();
+    };
+    window.addEventListener(SUPPORT_LAYOUT_EVENTS.TICKET_CREATED, handleTicketCreated);
+    return () => {
+      window.removeEventListener(SUPPORT_LAYOUT_EVENTS.TICKET_CREATED, handleTicketCreated);
+    };
+  }, [refresh]);
+  useEffect(() => {
+    if (observerRef.current) {
+      observerRef.current.disconnect();
+    }
+    observerRef.current = new IntersectionObserver(
+      (entries) => {
+        if (entries[0]?.isIntersecting && hasMore && !isLoadingMore) {
+          loadMore();
+        }
+      },
+      { threshold: 0.1 }
+    );
+    if (loadMoreRef.current) {
+      observerRef.current.observe(loadMoreRef.current);
+    }
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+    };
+  }, [hasMore, isLoadingMore, loadMore]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsx("div", { className: "p-4 space-y-2", children: [1, 2, 3, 4, 5].map((i) => /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(
+      Skeleton,
+      {
+        className: "h-24 w-full animate-pulse",
+        style: { animationDelay: `${i * 100}ms` }
+      }
+    ) }, i)) });
+  }
+  if (!tickets || tickets.length === 0) {
+    return /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center justify-center h-full p-8 text-center animate-in fade-in zoom-in-95 duration-300", children: [
+      /* @__PURE__ */ jsx(MessageSquare, { className: "h-16 w-16 text-muted-foreground mb-4 animate-bounce" }),
+      /* @__PURE__ */ jsx("h3", { className: "text-lg font-semibold mb-2", children: "No tickets yet" }),
+      /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground max-w-sm", children: "Create your first support ticket to get help from our team" })
+    ] });
+  }
+  return /* @__PURE__ */ jsx(ScrollArea, { className: "h-full", viewportRef: scrollRef, children: /* @__PURE__ */ jsxs("div", { className: "p-4 space-y-2", children: [
+    tickets.map((ticket, index) => /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "animate-in fade-in slide-in-from-left-2 duration-300",
+        style: { animationDelay: `${Math.min(index, 10) * 50}ms` },
+        children: /* @__PURE__ */ jsx(
+          TicketCard,
+          {
+            ticket,
+            isSelected: selectedTicket?.uuid === ticket.uuid,
+            onClick: () => selectTicket(ticket)
+          }
+        )
+      },
+      ticket.uuid
+    )),
+    /* @__PURE__ */ jsx("div", { ref: loadMoreRef, className: "h-2" }),
+    isLoadingMore && /* @__PURE__ */ jsx("div", { className: "flex justify-center py-4", children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-muted-foreground", children: [
+      /* @__PURE__ */ jsx(Loader2, { className: "h-4 w-4 animate-spin" }),
+      /* @__PURE__ */ jsx("span", { className: "text-sm", children: "Loading more tickets..." })
+    ] }) }),
+    hasMore && !isLoadingMore && /* @__PURE__ */ jsx("div", { className: "flex justify-center pt-2 pb-4", children: /* @__PURE__ */ jsxs(
+      Button,
+      {
+        variant: "outline",
+        size: "sm",
+        onClick: loadMore,
+        className: "text-xs",
+        children: [
+          "Load more (",
+          totalCount > 0 ? `${tickets.length}/${totalCount}` : "",
+          ")"
+        ]
+      }
+    ) }),
+    !hasMore && tickets.length > 0 && /* @__PURE__ */ jsxs("div", { className: "text-center py-4 text-sm text-muted-foreground", children: [
+      "All ",
+      totalCount,
+      " tickets loaded"
+    ] })
+  ] }) });
+};
+var formatTime = (date) => {
+  if (!date) return "";
+  return new Date(date).toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+};
+var formatDate = (date) => {
+  if (!date) return "";
+  return new Date(date).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+};
+var MessageBubble = ({ message, isFromUser, currentUser }) => {
+  const sender = message.sender;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `flex gap-3 ${isFromUser ? "justify-end" : "justify-start"}
+                 animate-in fade-in slide-in-from-bottom-2 duration-300`,
+      children: [
+        !isFromUser && /* @__PURE__ */ jsx(Avatar, { className: "h-8 w-8 shrink-0", children: sender?.avatar ? /* @__PURE__ */ jsx(AvatarImage, { src: sender.avatar, alt: sender.display_username || "Support" }) : /* @__PURE__ */ jsx(AvatarFallback, { className: "bg-primary text-primary-foreground", children: sender?.is_staff ? /* @__PURE__ */ jsx(Headphones, { className: "h-4 w-4" }) : sender?.display_username?.charAt(0)?.toUpperCase() || sender?.initials || "S" }) }),
+        /* @__PURE__ */ jsxs("div", { className: `flex flex-col gap-1 flex-1 max-w-[80%] ${isFromUser ? "items-end" : "items-start"}`, children: [
+          !isFromUser && sender && /* @__PURE__ */ jsxs("span", { className: "text-xs text-muted-foreground px-1", children: [
+            sender.display_username || sender.email || "Support Team",
+            sender.is_staff && " (Staff)"
+          ] }),
+          /* @__PURE__ */ jsx(
+            Card,
+            {
+              className: `${isFromUser ? "bg-primary text-primary-foreground" : "bg-muted"} transition-all duration-200 hover:shadow-md`,
+              children: /* @__PURE__ */ jsx(CardContent, { className: "p-3", children: /* @__PURE__ */ jsx("p", { className: "text-sm whitespace-pre-wrap break-words", children: message.text }) })
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground px-1", children: formatTime(message.created_at) })
+        ] }),
+        isFromUser && /* @__PURE__ */ jsx(Avatar, { className: "h-8 w-8 shrink-0", children: currentUser?.avatar ? /* @__PURE__ */ jsx(AvatarImage, { src: currentUser.avatar, alt: currentUser.display_username || currentUser.email || "You" }) : /* @__PURE__ */ jsx(AvatarFallback, { className: "bg-primary/10 text-primary font-semibold", children: currentUser?.display_username?.charAt(0)?.toUpperCase() || currentUser?.email?.charAt(0)?.toUpperCase() || currentUser?.initials || /* @__PURE__ */ jsx(User, { className: "h-4 w-4" }) }) })
+      ]
+    }
+  );
+};
+var MessageList = () => {
+  const { selectedTicket } = useSupportLayoutContext();
+  const { user } = useAuth();
+  const {
+    messages,
+    isLoading,
+    isLoadingMore,
+    hasMore,
+    totalCount,
+    loadMore
+  } = useInfiniteMessages(selectedTicket?.uuid || null);
+  const scrollRef = useRef(null);
+  const scrollAreaRef = useRef(null);
+  const observerRef = useRef(null);
+  const loadMoreRef = useRef(null);
+  const firstRender = useRef(true);
+  useEffect(() => {
+    if (observerRef.current) {
+      observerRef.current.disconnect();
+    }
+    observerRef.current = new IntersectionObserver(
+      (entries) => {
+        if (entries[0]?.isIntersecting && hasMore && !isLoadingMore) {
+          loadMore();
+        }
+      },
+      { threshold: 0.1 }
+    );
+    if (loadMoreRef.current) {
+      observerRef.current.observe(loadMoreRef.current);
+    }
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+    };
+  }, [hasMore, isLoadingMore, loadMore]);
+  useEffect(() => {
+    if (firstRender.current && messages.length > 0) {
+      const scrollContainer = scrollAreaRef.current?.querySelector("[data-radix-scroll-area-viewport]");
+      if (scrollContainer) {
+        scrollContainer.scrollTop = scrollContainer.scrollHeight;
+      }
+      firstRender.current = false;
+    }
+  }, [messages]);
+  const handleLoadMore = useCallback(() => {
+    const scrollContainer = scrollAreaRef.current?.querySelector("[data-radix-scroll-area-viewport]");
+    const previousHeight = scrollContainer?.scrollHeight || 0;
+    loadMore();
+    setTimeout(() => {
+      if (scrollContainer) {
+        const newHeight = scrollContainer.scrollHeight;
+        scrollContainer.scrollTop = newHeight - previousHeight;
+      }
+    }, 100);
+  }, [loadMore]);
+  if (!selectedTicket) {
+    return /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center justify-center h-full p-8 text-center animate-in fade-in zoom-in-95 duration-300", children: [
+      /* @__PURE__ */ jsx(MessageSquare, { className: "h-16 w-16 text-muted-foreground mb-4 animate-bounce" }),
+      /* @__PURE__ */ jsx("h3", { className: "text-lg font-semibold mb-2", children: "No ticket selected" }),
+      /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground max-w-sm", children: "Select a ticket from the list to view the conversation" })
+    ] });
+  }
+  if (isLoading) {
+    return /* @__PURE__ */ jsx("div", { className: "p-6 space-y-4", children: [1, 2, 3].map((i) => /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "flex gap-3 animate-pulse",
+        style: { animationDelay: `${i * 100}ms` },
+        children: [
+          /* @__PURE__ */ jsx(Skeleton, { className: "h-8 w-8 rounded-full" }),
+          /* @__PURE__ */ jsx(Skeleton, { className: "h-16 flex-1 max-w-[70%]" })
+        ]
+      },
+      i
+    )) });
+  }
+  if (!messages || messages.length === 0) {
+    return /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center justify-center h-full p-8 text-center animate-in fade-in zoom-in-95 duration-300", children: [
+      /* @__PURE__ */ jsx(MessageSquare, { className: "h-16 w-16 text-muted-foreground mb-4 animate-bounce" }),
+      /* @__PURE__ */ jsx("h3", { className: "text-lg font-semibold mb-2", children: "No messages yet" }),
+      /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground max-w-sm", children: "Start the conversation by sending a message below" })
+    ] });
+  }
+  return /* @__PURE__ */ jsx(ScrollArea, { className: "h-full bg-muted/50", viewportRef: scrollAreaRef, children: /* @__PURE__ */ jsxs("div", { className: "p-6 space-y-4", ref: scrollRef, children: [
+    /* @__PURE__ */ jsx("div", { ref: loadMoreRef, className: "h-2" }),
+    isLoadingMore && /* @__PURE__ */ jsx("div", { className: "flex justify-center py-4", children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-muted-foreground", children: [
+      /* @__PURE__ */ jsx(Loader2, { className: "h-4 w-4 animate-spin" }),
+      /* @__PURE__ */ jsx("span", { className: "text-sm", children: "Loading older messages..." })
+    ] }) }),
+    hasMore && !isLoadingMore && /* @__PURE__ */ jsx("div", { className: "flex justify-center pt-2 pb-4", children: /* @__PURE__ */ jsxs(
+      Button,
+      {
+        variant: "outline",
+        size: "sm",
+        onClick: handleLoadMore,
+        className: "text-xs",
+        children: [
+          "Load older messages (",
+          totalCount > 0 ? `${messages.length}/${totalCount}` : "",
+          ")"
+        ]
+      }
+    ) }),
+    messages.length > 0 && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3 my-4", children: [
+      /* @__PURE__ */ jsx("div", { className: "flex-1 h-px bg-border" }),
+      /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: formatDate(messages[0]?.created_at) }),
+      /* @__PURE__ */ jsx("div", { className: "flex-1 h-px bg-border" })
+    ] }),
+    messages.map((message, index) => {
+      const isFromUser = message.sender?.id && user?.id && String(message.sender.id) === String(user.id) || message.sender?.email && user?.email && message.sender.email === user.email || message.is_from_author && selectedTicket?.user && user?.id && String(selectedTicket.user) === String(user.id);
+      const previousMessage = index > 0 ? messages[index - 1] : null;
+      const showDateSeparator = previousMessage && new Date(previousMessage.created_at || "").toDateString() !== new Date(message.created_at || "").toDateString();
+      return /* @__PURE__ */ jsxs(React7.Fragment, { children: [
+        showDateSeparator && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3 my-4", children: [
+          /* @__PURE__ */ jsx("div", { className: "flex-1 h-px bg-border" }),
+          /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: formatDate(message.created_at) }),
+          /* @__PURE__ */ jsx("div", { className: "flex-1 h-px bg-border" })
+        ] }),
+        /* @__PURE__ */ jsx("div", { style: { animationDelay: `${Math.min(index, 10) * 50}ms` }, children: /* @__PURE__ */ jsx(
+          MessageBubble,
+          {
+            message,
+            isFromUser: !!isFromUser,
+            currentUser: user
+          }
+        ) })
+      ] }, message.uuid);
+    })
+  ] }) });
+};
+var isDevelopment = process.env.NODE_ENV === "development";
+var showLogs = isDevelopment;
+var logger = createConsola({
+  level: showLogs ? 4 : 1
+}).withTag("ext-support");
+var supportLogger = logger;
+var MessageInput = () => {
+  const { selectedTicket, sendMessage } = useSupportLayoutContext();
+  const { toast } = useToast();
+  const [message, setMessage] = useState("");
+  const [isSending, setIsSending] = useState(false);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!message.trim() || !selectedTicket) return;
+    setIsSending(true);
+    try {
+      await sendMessage(message.trim());
+      setMessage("");
+      toast({
+        title: "Success",
+        description: "Message sent successfully"
+      });
+    } catch (error) {
+      supportLogger.error("Failed to send message:", error);
+      toast({
+        title: "Error",
+        description: "Failed to send message",
+        variant: "destructive"
+      });
+    } finally {
+      setIsSending(false);
+    }
+  };
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      handleSubmit(e);
+    }
+  };
+  if (!selectedTicket) {
+    return null;
+  }
+  const canSendMessage = selectedTicket.status !== "closed";
+  return /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, className: "p-4 border-t bg-background/50 backdrop-blur-sm flex-shrink-0", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+      /* @__PURE__ */ jsx(
+        Textarea,
+        {
+          value: message,
+          onChange: (e) => setMessage(e.target.value),
+          onKeyDown: handleKeyDown,
+          placeholder: canSendMessage ? "Type your message... (Shift+Enter for new line)" : "This ticket is closed",
+          className: "min-h-[60px] max-h-[200px] transition-all duration-200 \n                     focus:ring-2 focus:ring-primary/20",
+          disabled: !canSendMessage || isSending
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          type: "submit",
+          size: "icon",
+          disabled: !message.trim() || !canSendMessage || isSending,
+          className: "shrink-0 transition-all duration-200 \n                     hover:scale-110 active:scale-95 disabled:scale-100",
+          children: /* @__PURE__ */ jsx(Send, { className: "h-4 w-4" })
+        }
+      )
+    ] }),
+    !canSendMessage && /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground mt-2 animate-in fade-in slide-in-from-top-1 duration-200", children: "This ticket is closed. You cannot send new messages." })
+  ] });
+};
+var createTicketSchema = z.object({
+  subject: z.string().min(1, "Subject is required").max(200, "Subject too long"),
+  message: z.string().min(1, "Message is required").max(5e3, "Message too long")
+});
+var CreateTicketDialog = () => {
+  const { uiState, createTicket, closeCreateDialog } = useSupportLayoutContext();
+  const { toast } = useToast();
+  const [isSubmitting, setIsSubmitting] = React7.useState(false);
+  const form = useForm({
+    resolver: zodResolver(createTicketSchema),
+    defaultValues: {
+      subject: "",
+      message: ""
+    }
+  });
+  const onSubmit = async (data) => {
+    setIsSubmitting(true);
+    try {
+      await createTicket(data);
+      form.reset();
+      toast({
+        title: "Success",
+        description: "Support ticket created successfully"
+      });
+    } catch (error) {
+      supportLogger.error("Failed to create ticket:", error);
+      toast({
+        title: "Error",
+        description: "Failed to create ticket. Please try again.",
+        variant: "destructive"
+      });
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  const handleClose = () => {
+    form.reset();
+    closeCreateDialog();
+  };
+  return /* @__PURE__ */ jsx(Dialog, { open: uiState.isCreateDialogOpen, onOpenChange: (open) => !open && handleClose(), children: /* @__PURE__ */ jsxs(DialogContent, { className: "sm:max-w-[600px] animate-in fade-in slide-in-from-bottom-4 duration-300", children: [
+    /* @__PURE__ */ jsxs(DialogHeader, { children: [
+      /* @__PURE__ */ jsxs(DialogTitle, { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx(Plus, { className: "h-5 w-5" }),
+        "Create Support Ticket"
+      ] }),
+      /* @__PURE__ */ jsx(DialogDescription, { children: "Describe your issue and we'll help you resolve it as quickly as possible." })
+    ] }),
+    /* @__PURE__ */ jsx(Form, { ...form, children: /* @__PURE__ */ jsxs("form", { onSubmit: form.handleSubmit(onSubmit), className: "space-y-6", children: [
+      /* @__PURE__ */ jsx(
+        FormField,
+        {
+          control: form.control,
+          name: "subject",
+          render: ({ field }) => /* @__PURE__ */ jsxs(FormItem, { children: [
+            /* @__PURE__ */ jsx(FormLabel, { children: "Subject" }),
+            /* @__PURE__ */ jsx(FormControl, { children: /* @__PURE__ */ jsx(Input, { placeholder: "Brief description of your issue...", ...field }) }),
+            /* @__PURE__ */ jsx(FormMessage, {})
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        FormField,
+        {
+          control: form.control,
+          name: "message",
+          render: ({ field }) => /* @__PURE__ */ jsxs(FormItem, { children: [
+            /* @__PURE__ */ jsx(FormLabel, { children: "Message" }),
+            /* @__PURE__ */ jsx(FormControl, { children: /* @__PURE__ */ jsx(
+              Textarea,
+              {
+                placeholder: "Describe your issue in detail. Include any error messages, steps to reproduce, or relevant information...",
+                className: "min-h-[120px]",
+                ...field
+              }
+            ) }),
+            /* @__PURE__ */ jsx(FormMessage, {})
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "flex justify-end gap-3 pt-4", children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            variant: "outline",
+            onClick: handleClose,
+            disabled: isSubmitting,
+            children: "Cancel"
+          }
+        ),
+        /* @__PURE__ */ jsx(Button, { type: "submit", disabled: isSubmitting, children: isSubmitting ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Loader2, { className: "h-4 w-4 mr-2 animate-spin" }),
+          "Creating..."
+        ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Plus, { className: "h-4 w-4 mr-2" }),
+          "Create Ticket"
+        ] }) })
+      ] })
+    ] }) })
+  ] }) });
+};
+var SupportLayoutContent = () => {
+  const { selectedTicket, selectTicket, openCreateDialog, getUnreadCount } = useSupportLayoutContext();
+  const [isMobile, setIsMobile] = React7.useState(false);
+  React7.useEffect(() => {
+    const checkMobile = () => setIsMobile(window.innerWidth <= 768);
+    checkMobile();
+    window.addEventListener("resize", checkMobile);
+    return () => window.removeEventListener("resize", checkMobile);
+  }, []);
+  const unreadCount = getUnreadCount();
+  if (isMobile) {
+    return /* @__PURE__ */ jsxs("div", { className: "h-screen flex flex-col overflow-hidden", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between p-4 border-b bg-background flex-shrink-0", children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+          selectedTicket ? /* @__PURE__ */ jsx(
+            Button,
+            {
+              variant: "ghost",
+              size: "sm",
+              onClick: () => selectTicket(null),
+              className: "p-1",
+              children: /* @__PURE__ */ jsx(ArrowLeft, { className: "h-5 w-5" })
+            }
+          ) : /* @__PURE__ */ jsx(LifeBuoy, { className: "h-6 w-6 text-primary" }),
+          /* @__PURE__ */ jsx("h1", { className: "text-xl font-semibold", children: selectedTicket ? selectedTicket.subject : "Support" }),
+          unreadCount > 0 && !selectedTicket && /* @__PURE__ */ jsx("div", { className: "h-5 w-5 bg-red-500 text-white text-xs rounded-full flex items-center justify-center", children: unreadCount })
+        ] }),
+        !selectedTicket && /* @__PURE__ */ jsxs(Button, { onClick: openCreateDialog, size: "sm", children: [
+          /* @__PURE__ */ jsx(Plus, { className: "h-4 w-4 mr-2" }),
+          "New Ticket"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "flex-1 min-h-0 overflow-hidden", children: selectedTicket ? (
+        // Show messages when ticket is selected
+        /* @__PURE__ */ jsxs("div", { className: "h-full flex flex-col", children: [
+          /* @__PURE__ */ jsx("div", { className: "flex-1 min-h-0 overflow-hidden", children: /* @__PURE__ */ jsx(MessageList, {}) }),
+          /* @__PURE__ */ jsx("div", { className: "flex-shrink-0", children: /* @__PURE__ */ jsx(MessageInput, {}) })
+        ] })
+      ) : (
+        // Show ticket list when no ticket is selected
+        /* @__PURE__ */ jsx(TicketList, {})
+      ) }),
+      /* @__PURE__ */ jsx(CreateTicketDialog, {})
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "h-screen flex flex-col overflow-hidden", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between p-6 border-b bg-background flex-shrink-0", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsx(LifeBuoy, { className: "h-7 w-7 text-primary" }),
+        /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx("h1", { className: "text-2xl font-bold", children: "Support Center" }),
+          /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: "Get help from our support team" })
+        ] }),
+        unreadCount > 0 && /* @__PURE__ */ jsx("div", { className: "h-6 w-6 bg-red-500 text-white text-sm rounded-full flex items-center justify-center", children: unreadCount })
+      ] }),
+      /* @__PURE__ */ jsxs(Button, { onClick: openCreateDialog, children: [
+        /* @__PURE__ */ jsx(Plus, { className: "h-4 w-4 mr-2" }),
+        "New Ticket"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "flex-1 min-h-0 overflow-hidden", children: /* @__PURE__ */ jsxs(ResizablePanelGroup, { direction: "horizontal", className: "h-full", children: [
+      /* @__PURE__ */ jsx(ResizablePanel, { defaultSize: 35, minSize: 25, maxSize: 50, children: /* @__PURE__ */ jsx("div", { className: "h-full border-r overflow-hidden", children: /* @__PURE__ */ jsx(TicketList, {}) }) }),
+      /* @__PURE__ */ jsx(ResizableHandle, { withHandle: true, className: "hover:bg-accent transition-colors" }),
+      /* @__PURE__ */ jsx(ResizablePanel, { defaultSize: 65, minSize: 50, children: /* @__PURE__ */ jsxs("div", { className: "h-full flex flex-col overflow-hidden", children: [
+        /* @__PURE__ */ jsx("div", { className: "flex-1 min-h-0 overflow-hidden", children: /* @__PURE__ */ jsx(MessageList, {}) }),
+        /* @__PURE__ */ jsx("div", { className: "flex-shrink-0", children: /* @__PURE__ */ jsx(MessageInput, {}) })
+      ] }) })
+    ] }) }),
+    /* @__PURE__ */ jsx(CreateTicketDialog, {})
+  ] });
+};
+var SupportLayout = () => {
+  return /* @__PURE__ */ jsx("div", { className: "h-screen w-full overflow-hidden", children: /* @__PURE__ */ jsx(SupportProvider, { children: /* @__PURE__ */ jsx(SupportLayoutProvider, { children: /* @__PURE__ */ jsx(SupportLayoutContent, {}) }) }) });
+};
+
+export { API, APIClient, APIError, APILogger, CookieStorageAdapter, CreateTicketDialog, DEFAULT_RETRY_CONFIG, FetchAdapter, LocalStorageAdapter, MemoryStorageAdapter, MessageCreateRequestSchema, MessageCreateSchema, MessageInput, MessageList, MessageRequestSchema, MessageSchema, NetworkError, PaginatedMessageListSchema, PaginatedTicketListSchema, PatchedMessageRequestSchema, PatchedTicketRequestSchema, REFRESH_TOKEN_KEY, SUPPORT_LAYOUT_EVENTS, SenderSchema, SupportLayout, SupportLayoutProvider, SupportProvider, TOKEN_KEY, TicketCard, TicketList, TicketRequestSchema, TicketSchema, apiSupport, clearAPITokens, closeCreateTicketDialog, configureAPI, createSupportTicketsCreate, createSupportTicketsMessagesCreate, deleteSupportTicketsDestroy, deleteSupportTicketsMessagesDestroy, dispatchValidationError, enums_exports, fetchers_exports, formatZodError, getAPIInstance, getSupportTicketsList, getSupportTicketsMessagesList, getSupportTicketsMessagesRetrieve, getSupportTicketsRetrieve, isAPIConfigured, models_exports, onValidationError, openCreateTicketDialog, partialUpdateSupportTicketsMessagesPartialUpdate, partialUpdateSupportTicketsPartialUpdate, reconfigureAPI, resetAPI, schemas_exports, shouldRetry, updateSupportTicketsMessagesUpdate, updateSupportTicketsUpdate, useCreateSupportTicketsCreate, useCreateSupportTicketsMessagesCreate, useDeleteSupportTicketsDestroy, useDeleteSupportTicketsMessagesDestroy, useInfiniteMessages, useInfiniteTickets, usePartialUpdateSupportTicketsMessagesPartialUpdate, usePartialUpdateSupportTicketsPartialUpdate, useSupportContext, useSupportLayoutContext, useSupportTicketsList, useSupportTicketsMessagesList, useSupportTicketsMessagesRetrieve, useSupportTicketsRetrieve, useUpdateSupportTicketsMessagesUpdate, useUpdateSupportTicketsUpdate, withRetry };