@djangocfg/ext-support 1.0.2 → 1.0.4

package/dist/hooks.cjs

@@ -0,0 +1,2842 @@
+'use strict';
+
+var consola = require('consola');
+var pRetry = require('p-retry');
+var zod = require('zod');
+var api = require('@djangocfg/ext-base/api');
+var React7 = require('react');
+var useSWR = require('swr');
+var jsxRuntime = require('react/jsx-runtime');
+var auth = require('@djangocfg/api/auth');
+var useSWRInfinite = require('swr/infinite');
+var uiNextjs = require('@djangocfg/ui-nextjs');
+var lucideReact = require('lucide-react');
+var reactHookForm = require('react-hook-form');
+var zod$1 = require('@hookform/resolvers/zod');
+var extBase = require('@djangocfg/ext-base');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pRetry__default = /*#__PURE__*/_interopDefault(pRetry);
+var React7__default = /*#__PURE__*/_interopDefault(React7);
+var useSWR__default = /*#__PURE__*/_interopDefault(useSWR);
+var useSWRInfinite__default = /*#__PURE__*/_interopDefault(useSWRInfinite);
+
+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 || 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__default.default(
+    async () => {
+      try {
+        return await fn();
+      } catch (error) {
+        if (!shouldRetry(error)) {
+          throw new pRetry.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 = zod.z.object({
+  id: zod.z.int(),
+  display_username: zod.z.string(),
+  email: zod.z.email(),
+  avatar: zod.z.string().nullable(),
+  initials: zod.z.string(),
+  is_staff: zod.z.boolean(),
+  is_superuser: zod.z.boolean()
+});
+
+// src/api/generated/ext_support/_utils/schemas/Message.schema.ts
+var MessageSchema = zod.z.object({
+  uuid: zod.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: zod.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: zod.z.boolean(),
+  text: zod.z.string(),
+  created_at: zod.z.iso.datetime()
+});
+var MessageCreateSchema = zod.z.object({
+  text: zod.z.string()
+});
+var MessageCreateRequestSchema = zod.z.object({
+  text: zod.z.string().min(1)
+});
+var MessageRequestSchema = zod.z.object({
+  text: zod.z.string().min(1)
+});
+var PaginatedMessageListSchema = zod.z.object({
+  count: zod.z.int(),
+  page: zod.z.int(),
+  pages: zod.z.int(),
+  page_size: zod.z.int(),
+  has_next: zod.z.boolean(),
+  has_previous: zod.z.boolean(),
+  next_page: zod.z.int().nullable().optional(),
+  previous_page: zod.z.int().nullable().optional(),
+  results: zod.z.array(MessageSchema)
+});
+var TicketSchema = zod.z.object({
+  uuid: zod.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: zod.z.int(),
+  subject: zod.z.string().max(255),
+  status: zod.z.nativeEnum(TicketStatus).optional(),
+  created_at: zod.z.iso.datetime(),
+  unanswered_messages_count: zod.z.int()
+});
+
+// src/api/generated/ext_support/_utils/schemas/PaginatedTicketList.schema.ts
+var PaginatedTicketListSchema = zod.z.object({
+  count: zod.z.int(),
+  page: zod.z.int(),
+  pages: zod.z.int(),
+  page_size: zod.z.int(),
+  has_next: zod.z.boolean(),
+  has_previous: zod.z.boolean(),
+  next_page: zod.z.int().nullable().optional(),
+  previous_page: zod.z.int().nullable().optional(),
+  results: zod.z.array(TicketSchema)
+});
+var PatchedMessageRequestSchema = zod.z.object({
+  text: zod.z.string().min(1).optional()
+});
+var PatchedTicketRequestSchema = zod.z.object({
+  user: zod.z.int().optional(),
+  subject: zod.z.string().min(1).max(255).optional(),
+  status: zod.z.nativeEnum(PatchedTicketRequestStatus).optional()
+});
+var TicketRequestSchema = zod.z.object({
+  user: zod.z.int(),
+  subject: zod.z.string().min(1).max(255),
+  status: zod.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.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getSupportTicketsList
+Path: /cfg/support/tickets/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.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.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.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createSupportTicketsCreate
+Path: /cfg/support/tickets/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.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.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.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getSupportTicketsMessagesList
+Path: /cfg/support/tickets/{ticket_uuid}/messages/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.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.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.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`createSupportTicketsMessagesCreate
+Path: /cfg/support/tickets/{ticket_uuid}/messages/
+Method: POST`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.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.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.consola.error("\u274C Zod Validation Failed");
+    consola.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.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.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.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.consola.error("\u274C Zod Validation Failed");
+    consola.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.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.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.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.consola.error("\u274C Zod Validation Failed");
+    consola.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.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.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.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.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`getSupportTicketsRetrieve
+Path: /cfg/support/tickets/{uuid}/
+Method: GET`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.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.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.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`updateSupportTicketsUpdate
+Path: /cfg/support/tickets/{uuid}/
+Method: PUT`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.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.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.consola.error("\u274C Zod Validation Failed");
+    consola.consola.box(`partialUpdateSupportTicketsPartialUpdate
+Path: /cfg/support/tickets/{uuid}/
+Method: PATCH`);
+    if (error instanceof Error && "issues" in error && Array.isArray(error.issues)) {
+      consola.consola.error("Validation Issues:");
+      error.issues.forEach((issue, index) => {
+        consola.consola.error(`  ${index + 1}. ${issue.path.join(".") || "root"}`);
+        consola.consola.error(`     \u251C\u2500 Message: ${issue.message}`);
+        if (issue.expected) consola.consola.error(`     \u251C\u2500 Expected: ${issue.expected}`);
+        if (issue.received) consola.consola.error(`     \u2514\u2500 Received: ${issue.received}`);
+      });
+    }
+    consola.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.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 = api.createExtensionAPI(API);
+function useSupportTicketsList(params, client) {
+  return useSWR__default.default(
+    params ? ["cfg-support-tickets", params] : "cfg-support-tickets",
+    () => getSupportTicketsList(params, client)
+  );
+}
+function useCreateSupportTicketsCreate() {
+  const { mutate } = useSWR.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__default.default(
+    ["cfg-support-tickets-messages", ticket_uuid],
+    () => getSupportTicketsMessagesList(ticket_uuid, params, client)
+  );
+}
+function useCreateSupportTicketsMessagesCreate() {
+  const { mutate } = useSWR.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__default.default(
+    ["cfg-support-tickets-message", ticket_uuid],
+    () => getSupportTicketsMessagesRetrieve(ticket_uuid, uuid, client)
+  );
+}
+function useUpdateSupportTicketsMessagesUpdate() {
+  const { mutate } = useSWR.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 } = useSWR.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 } = useSWR.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__default.default(
+    ["cfg-support-ticket", uuid],
+    () => getSupportTicketsRetrieve(uuid, client)
+  );
+}
+function useUpdateSupportTicketsUpdate() {
+  const { mutate } = useSWR.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 } = useSWR.useSWRConfig();
+  return async (uuid, data, client) => {
+    const result = await partialUpdateSupportTicketsPartialUpdate(uuid, data, client);
+    mutate("cfg-support-tickets-partial");
+    return result;
+  };
+}
+function useDeleteSupportTicketsDestroy() {
+  const { mutate } = useSWR.useSWRConfig();
+  return async (uuid, client) => {
+    const result = await deleteSupportTicketsDestroy(uuid, client);
+    mutate("cfg-support-tickets");
+    mutate("cfg-support-ticket");
+    return result;
+  };
+}
+var SupportContext = React7.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__ */ jsxRuntime.jsx(SupportContext.Provider, { value, children });
+}
+function useSupportContext() {
+  const context = React7.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__default.default(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__default.default(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 = React7.createContext(void 0);
+function SupportLayoutProvider({ children }) {
+  const support = useSupportContext();
+  const { user } = auth.useAuth();
+  const [uiState, setUIState] = React7.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 = React7.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 = React7.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 = React7.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 = React7.useCallback(() => {
+    setUIState((prev) => ({ ...prev, isCreateDialogOpen: true }));
+  }, []);
+  const closeCreateDialog = React7.useCallback(() => {
+    setUIState((prev) => ({ ...prev, isCreateDialogOpen: false }));
+  }, []);
+  const getUnreadCount = React7.useCallback(() => {
+    return support.tickets?.reduce((count, ticket) => count + (ticket.unanswered_messages_count || 0), 0) || 0;
+  }, [support.tickets]);
+  React7.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__ */ jsxRuntime.jsx(SupportLayoutContext.Provider, { value, children });
+}
+function useSupportLayoutContext() {
+  const context = React7.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__ */ jsxRuntime.jsx(
+    uiNextjs.Card,
+    {
+      className: uiNextjs.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__ */ jsxRuntime.jsxs(uiNextjs.CardContent, { className: "p-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-start justify-between mb-2", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "font-semibold text-sm line-clamp-2 flex-1", children: ticket.subject }),
+          (ticket.unanswered_messages_count || 0) > 0 && /* @__PURE__ */ jsxRuntime.jsx(
+            uiNextjs.Badge,
+            {
+              variant: "destructive",
+              className: "ml-2 shrink-0 animate-pulse",
+              children: ticket.unanswered_messages_count
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-between text-xs text-muted-foreground", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Badge, { variant: getStatusBadgeVariant(ticket.status || "open"), className: "text-xs", children: ticket.status || "open" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Clock, { className: "h-3 w-3" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { children: formatRelativeTime(ticket.created_at) })
+          ] })
+        ] }) })
+      ] })
+    }
+  );
+};
+var TicketList = () => {
+  const { selectedTicket, selectTicket } = useSupportLayoutContext();
+  const {
+    tickets,
+    isLoading,
+    isLoadingMore,
+    hasMore,
+    loadMore,
+    totalCount,
+    refresh
+  } = useInfiniteTickets();
+  const scrollRef = React7.useRef(null);
+  const observerRef = React7.useRef(null);
+  const loadMoreRef = React7.useRef(null);
+  React7.useEffect(() => {
+    const handleTicketCreated = () => {
+      refresh();
+    };
+    window.addEventListener(SUPPORT_LAYOUT_EVENTS.TICKET_CREATED, handleTicketCreated);
+    return () => {
+      window.removeEventListener(SUPPORT_LAYOUT_EVENTS.TICKET_CREATED, handleTicketCreated);
+    };
+  }, [refresh]);
+  React7.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__ */ jsxRuntime.jsx("div", { className: "p-4 space-y-2", children: [1, 2, 3, 4, 5].map((i) => /* @__PURE__ */ jsxRuntime.jsx("div", { children: /* @__PURE__ */ jsxRuntime.jsx(
+      uiNextjs.Skeleton,
+      {
+        className: "h-24 w-full animate-pulse",
+        style: { animationDelay: `${i * 100}ms` }
+      }
+    ) }, i)) });
+  }
+  if (!tickets || tickets.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(lucideReact.MessageSquare, { className: "h-16 w-16 text-muted-foreground mb-4 animate-bounce" }),
+      /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-semibold mb-2", children: "No tickets yet" }),
+      /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(uiNextjs.ScrollArea, { className: "h-full", viewportRef: scrollRef, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-4 space-y-2", children: [
+    tickets.map((ticket, index) => /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: "animate-in fade-in slide-in-from-left-2 duration-300",
+        style: { animationDelay: `${Math.min(index, 10) * 50}ms` },
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          TicketCard,
+          {
+            ticket,
+            isSelected: selectedTicket?.uuid === ticket.uuid,
+            onClick: () => selectTicket(ticket)
+          }
+        )
+      },
+      ticket.uuid
+    )),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { ref: loadMoreRef, className: "h-2" }),
+    isLoadingMore && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex justify-center py-4", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-muted-foreground", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "h-4 w-4 animate-spin" }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm", children: "Loading more tickets..." })
+    ] }) }),
+    hasMore && !isLoadingMore && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex justify-center pt-2 pb-4", children: /* @__PURE__ */ jsxRuntime.jsxs(
+      uiNextjs.Button,
+      {
+        variant: "outline",
+        size: "sm",
+        onClick: loadMore,
+        className: "text-xs",
+        children: [
+          "Load more (",
+          totalCount > 0 ? `${tickets.length}/${totalCount}` : "",
+          ")"
+        ]
+      }
+    ) }),
+    !hasMore && tickets.length > 0 && /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.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__ */ jsxRuntime.jsx(uiNextjs.Avatar, { className: "h-8 w-8 shrink-0", children: sender?.avatar ? /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.AvatarImage, { src: sender.avatar, alt: sender.display_username || "Support" }) : /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.AvatarFallback, { className: "bg-primary text-primary-foreground", children: sender?.is_staff ? /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Headphones, { className: "h-4 w-4" }) : sender?.display_username?.charAt(0)?.toUpperCase() || sender?.initials || "S" }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `flex flex-col gap-1 flex-1 max-w-[80%] ${isFromUser ? "items-end" : "items-start"}`, children: [
+          !isFromUser && sender && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-xs text-muted-foreground px-1", children: [
+            sender.display_username || sender.email || "Support Team",
+            sender.is_staff && " (Staff)"
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            uiNextjs.Card,
+            {
+              className: `${isFromUser ? "bg-primary text-primary-foreground" : "bg-muted"} transition-all duration-200 hover:shadow-md`,
+              children: /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.CardContent, { className: "p-3", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm whitespace-pre-wrap break-words", children: message.text }) })
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-muted-foreground px-1", children: formatTime(message.created_at) })
+        ] }),
+        isFromUser && /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Avatar, { className: "h-8 w-8 shrink-0", children: currentUser?.avatar ? /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.AvatarImage, { src: currentUser.avatar, alt: currentUser.display_username || currentUser.email || "You" }) : /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.AvatarFallback, { className: "bg-primary/10 text-primary font-semibold", children: currentUser?.display_username?.charAt(0)?.toUpperCase() || currentUser?.email?.charAt(0)?.toUpperCase() || currentUser?.initials || /* @__PURE__ */ jsxRuntime.jsx(lucideReact.User, { className: "h-4 w-4" }) }) })
+      ]
+    }
+  );
+};
+var MessageList = () => {
+  const { selectedTicket } = useSupportLayoutContext();
+  const { user } = auth.useAuth();
+  const {
+    messages,
+    isLoading,
+    isLoadingMore,
+    hasMore,
+    totalCount,
+    loadMore
+  } = useInfiniteMessages(selectedTicket?.uuid || null);
+  const scrollRef = React7.useRef(null);
+  const scrollAreaRef = React7.useRef(null);
+  const observerRef = React7.useRef(null);
+  const loadMoreRef = React7.useRef(null);
+  const firstRender = React7.useRef(true);
+  React7.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]);
+  React7.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 = React7.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__ */ jsxRuntime.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__ */ jsxRuntime.jsx(lucideReact.MessageSquare, { className: "h-16 w-16 text-muted-foreground mb-4 animate-bounce" }),
+      /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-semibold mb-2", children: "No ticket selected" }),
+      /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx("div", { className: "p-6 space-y-4", children: [1, 2, 3].map((i) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: "flex gap-3 animate-pulse",
+        style: { animationDelay: `${i * 100}ms` },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-8 w-8 rounded-full" }),
+          /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Skeleton, { className: "h-16 flex-1 max-w-[70%]" })
+        ]
+      },
+      i
+    )) });
+  }
+  if (!messages || messages.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(lucideReact.MessageSquare, { className: "h-16 w-16 text-muted-foreground mb-4 animate-bounce" }),
+      /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "text-lg font-semibold mb-2", children: "No messages yet" }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground max-w-sm", children: "Start the conversation by sending a message below" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.ScrollArea, { className: "h-full bg-muted/50", viewportRef: scrollAreaRef, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "p-6 space-y-4", ref: scrollRef, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { ref: loadMoreRef, className: "h-2" }),
+    isLoadingMore && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex justify-center py-4", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-muted-foreground", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "h-4 w-4 animate-spin" }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-sm", children: "Loading older messages..." })
+    ] }) }),
+    hasMore && !isLoadingMore && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex justify-center pt-2 pb-4", children: /* @__PURE__ */ jsxRuntime.jsxs(
+      uiNextjs.Button,
+      {
+        variant: "outline",
+        size: "sm",
+        onClick: handleLoadMore,
+        className: "text-xs",
+        children: [
+          "Load older messages (",
+          totalCount > 0 ? `${messages.length}/${totalCount}` : "",
+          ")"
+        ]
+      }
+    ) }),
+    messages.length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3 my-4", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 h-px bg-border" }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-muted-foreground", children: formatDate(messages[0]?.created_at) }),
+      /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsxs(React7__default.default.Fragment, { children: [
+        showDateSeparator && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3 my-4", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 h-px bg-border" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-muted-foreground", children: formatDate(message.created_at) }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 h-px bg-border" })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { style: { animationDelay: `${Math.min(index, 10) * 50}ms` }, children: /* @__PURE__ */ jsxRuntime.jsx(
+          MessageBubble,
+          {
+            message,
+            isFromUser: !!isFromUser,
+            currentUser: user
+          }
+        ) })
+      ] }, message.uuid);
+    })
+  ] }) });
+};
+var isDevelopment = process.env.NODE_ENV === "development";
+var showLogs = isDevelopment;
+var logger = consola.createConsola({
+  level: showLogs ? 4 : 1
+}).withTag("ext-support");
+var supportLogger = logger;
+var MessageInput = () => {
+  const { selectedTicket, sendMessage } = useSupportLayoutContext();
+  const { toast } = uiNextjs.useToast();
+  const [message, setMessage] = React7.useState("");
+  const [isSending, setIsSending] = React7.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__ */ jsxRuntime.jsxs("form", { onSubmit: handleSubmit, className: "p-4 border-t bg-background/50 backdrop-blur-sm flex-shrink-0", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        uiNextjs.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__ */ jsxRuntime.jsx(
+        uiNextjs.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__ */ jsxRuntime.jsx(lucideReact.Send, { className: "h-4 w-4" })
+        }
+      )
+    ] }),
+    !canSendMessage && /* @__PURE__ */ jsxRuntime.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 = zod.z.object({
+  subject: zod.z.string().min(1, "Subject is required").max(200, "Subject too long"),
+  message: zod.z.string().min(1, "Message is required").max(5e3, "Message too long")
+});
+var CreateTicketDialog = () => {
+  const { uiState, createTicket, closeCreateDialog } = useSupportLayoutContext();
+  const { toast } = uiNextjs.useToast();
+  const [isSubmitting, setIsSubmitting] = React7__default.default.useState(false);
+  const form = reactHookForm.useForm({
+    resolver: zod$1.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__ */ jsxRuntime.jsx(uiNextjs.Dialog, { open: uiState.isCreateDialogOpen, onOpenChange: (open) => !open && handleClose(), children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogContent, { className: "sm:max-w-[600px] animate-in fade-in slide-in-from-bottom-4 duration-300", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogHeader, { children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.DialogTitle, { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { className: "h-5 w-5" }),
+        "Create Support Ticket"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.DialogDescription, { children: "Describe your issue and we'll help you resolve it as quickly as possible." })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Form, { ...form, children: /* @__PURE__ */ jsxRuntime.jsxs("form", { onSubmit: form.handleSubmit(onSubmit), className: "space-y-6", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        uiNextjs.FormField,
+        {
+          control: form.control,
+          name: "subject",
+          render: ({ field }) => /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.FormItem, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormLabel, { children: "Subject" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormControl, { children: /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Input, { placeholder: "Brief description of your issue...", ...field }) }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormMessage, {})
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        uiNextjs.FormField,
+        {
+          control: form.control,
+          name: "message",
+          render: ({ field }) => /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.FormItem, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormLabel, { children: "Message" }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormControl, { children: /* @__PURE__ */ jsxRuntime.jsx(
+              uiNextjs.Textarea,
+              {
+                placeholder: "Describe your issue in detail. Include any error messages, steps to reproduce, or relevant information...",
+                className: "min-h-[120px]",
+                ...field
+              }
+            ) }),
+            /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.FormMessage, {})
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex justify-end gap-3 pt-4", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          uiNextjs.Button,
+          {
+            type: "button",
+            variant: "outline",
+            onClick: handleClose,
+            disabled: isSubmitting,
+            children: "Cancel"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.Button, { type: "submit", disabled: isSubmitting, children: isSubmitting ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "h-4 w-4 mr-2 animate-spin" }),
+          "Creating..."
+        ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { className: "h-4 w-4 mr-2" }),
+          "Create Ticket"
+        ] }) })
+      ] })
+    ] }) })
+  ] }) });
+};
+var SupportLayoutContent = () => {
+  const { selectedTicket, selectTicket, openCreateDialog, getUnreadCount } = useSupportLayoutContext();
+  const [isMobile, setIsMobile] = React7__default.default.useState(false);
+  React7__default.default.useEffect(() => {
+    const checkMobile = () => setIsMobile(window.innerWidth <= 768);
+    checkMobile();
+    window.addEventListener("resize", checkMobile);
+    return () => window.removeEventListener("resize", checkMobile);
+  }, []);
+  const unreadCount = getUnreadCount();
+  if (isMobile) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "h-screen flex flex-col overflow-hidden", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between p-4 border-b bg-background flex-shrink-0", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", children: [
+          selectedTicket ? /* @__PURE__ */ jsxRuntime.jsx(
+            uiNextjs.Button,
+            {
+              variant: "ghost",
+              size: "sm",
+              onClick: () => selectTicket(null),
+              className: "p-1",
+              children: /* @__PURE__ */ jsxRuntime.jsx(lucideReact.ArrowLeft, { className: "h-5 w-5" })
+            }
+          ) : /* @__PURE__ */ jsxRuntime.jsx(lucideReact.LifeBuoy, { className: "h-6 w-6 text-primary" }),
+          /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "text-xl font-semibold", children: selectedTicket ? selectedTicket.subject : "Support" }),
+          unreadCount > 0 && !selectedTicket && /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsxs(uiNextjs.Button, { onClick: openCreateDialog, size: "sm", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { className: "h-4 w-4 mr-2" }),
+          "New Ticket"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 min-h-0 overflow-hidden", children: selectedTicket ? (
+        // Show messages when ticket is selected
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "h-full flex flex-col", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 min-h-0 overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsx(MessageList, {}) }),
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-shrink-0", children: /* @__PURE__ */ jsxRuntime.jsx(MessageInput, {}) })
+        ] })
+      ) : (
+        // Show ticket list when no ticket is selected
+        /* @__PURE__ */ jsxRuntime.jsx(TicketList, {})
+      ) }),
+      /* @__PURE__ */ jsxRuntime.jsx(CreateTicketDialog, {})
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "h-screen flex flex-col overflow-hidden", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between p-6 border-b bg-background flex-shrink-0", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.LifeBuoy, { className: "h-7 w-7 text-primary" }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "text-2xl font-bold", children: "Support Center" }),
+          /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm text-muted-foreground", children: "Get help from our support team" })
+        ] }),
+        unreadCount > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-6 w-6 bg-red-500 text-white text-sm rounded-full flex items-center justify-center", children: unreadCount })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.Button, { onClick: openCreateDialog, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Plus, { className: "h-4 w-4 mr-2" }),
+        "New Ticket"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 min-h-0 overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsxs(uiNextjs.ResizablePanelGroup, { direction: "horizontal", className: "h-full", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.ResizablePanel, { defaultSize: 35, minSize: 25, maxSize: 50, children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-full border-r overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsx(TicketList, {}) }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.ResizableHandle, { withHandle: true, className: "hover:bg-accent transition-colors" }),
+      /* @__PURE__ */ jsxRuntime.jsx(uiNextjs.ResizablePanel, { defaultSize: 65, minSize: 50, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "h-full flex flex-col overflow-hidden", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 min-h-0 overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsx(MessageList, {}) }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-shrink-0", children: /* @__PURE__ */ jsxRuntime.jsx(MessageInput, {}) })
+      ] }) })
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(CreateTicketDialog, {})
+  ] });
+};
+var SupportLayout = () => {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-screen w-full overflow-hidden", children: /* @__PURE__ */ jsxRuntime.jsx(SupportProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(SupportLayoutProvider, { children: /* @__PURE__ */ jsxRuntime.jsx(SupportLayoutContent, {}) }) }) });
+};
+
+// package.json
+var package_default = {
+  name: "@djangocfg/ext-support",
+  version: "1.0.4",
+  description: "Support ticket system extension for DjangoCFG",
+  keywords: [
+    "django",
+    "djangocfg",
+    "extension",
+    "support",
+    "tickets",
+    "helpdesk",
+    "customer-service",
+    "typescript",
+    "react"
+  ],
+  author: {
+    name: "DjangoCFG",
+    url: "https://djangocfg.com"
+  },
+  homepage: "https://hub.djangocfg.com/extensions/djangocfg-ext-support",
+  repository: {
+    type: "git",
+    url: "https://github.com/markolofsen/django-cfg.git",
+    directory: "extensions/support"
+  },
+  bugs: {
+    url: "https://github.com/markolofsen/django-cfg/issues"
+  },
+  license: "MIT",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./hooks": {
+      types: "./dist/hooks.d.ts",
+      import: "./dist/hooks.js",
+      require: "./dist/hooks.cjs"
+    },
+    "./config": {
+      types: "./dist/config.d.ts",
+      import: "./dist/config.js",
+      require: "./dist/config.cjs"
+    }
+  },
+  files: [
+    "dist",
+    "src",
+    "preview.png"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    check: "tsc --noEmit"
+  },
+  peerDependencies: {
+    "@djangocfg/api": "workspace:*",
+    "@djangocfg/ext-base": "workspace:*",
+    "@djangocfg/ui-nextjs": "workspace:*",
+    consola: "^3.4.2",
+    "lucide-react": "^0.545.0",
+    next: "^15.5.7",
+    "p-retry": "^7.0.0",
+    react: "^18 || ^19",
+    "react-hook-form": "7.65.0",
+    swr: "^2.3.7",
+    zod: "^4.1.13"
+  },
+  devDependencies: {
+    "@djangocfg/api": "workspace:*",
+    "@djangocfg/ext-base": "workspace:*",
+    "@djangocfg/typescript-config": "workspace:*",
+    "@types/node": "^24.7.2",
+    "@types/react": "^19.0.0",
+    consola: "^3.4.2",
+    "p-retry": "^7.0.0",
+    swr: "^2.3.7",
+    tsup: "^8.5.0",
+    typescript: "^5.9.3"
+  }
+};
+
+// src/config.ts
+var extensionConfig = extBase.createExtensionConfig(package_default, {
+  name: "support",
+  displayName: "Support & Tickets",
+  category: "support",
+  features: [
+    "Ticket management system",
+    "Live chat support",
+    "Knowledge base integration",
+    "Multi-channel support",
+    "Agent assignment",
+    "SLA tracking"
+  ],
+  minVersion: "2.0.0",
+  examples: [
+    {
+      title: "Support Ticket Widget",
+      description: "Add a support ticket system",
+      code: `import { TicketWidget, useTickets } from '@djangocfg/ext-support';
+
+export default function SupportPage() {
+  const { tickets, createTicket } = useTickets();
+
+  return (
+    <TicketWidget
+      onTicketCreate={(ticket) => {
+        console.log('Ticket created:', ticket.id);
+      }}
+    />
+  );
+}`,
+      language: "tsx"
+    }
+  ]
+});
+
+exports.API = API;
+exports.APIClient = APIClient;
+exports.APIError = APIError;
+exports.APILogger = APILogger;
+exports.CookieStorageAdapter = CookieStorageAdapter;
+exports.CreateTicketDialog = CreateTicketDialog;
+exports.DEFAULT_RETRY_CONFIG = DEFAULT_RETRY_CONFIG;
+exports.Enums = enums_exports;
+exports.ExtSupportSupportTypes = models_exports;
+exports.FetchAdapter = FetchAdapter;
+exports.Fetchers = fetchers_exports;
+exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.MemoryStorageAdapter = MemoryStorageAdapter;
+exports.MessageCreateRequestSchema = MessageCreateRequestSchema;
+exports.MessageCreateSchema = MessageCreateSchema;
+exports.MessageInput = MessageInput;
+exports.MessageList = MessageList;
+exports.MessageRequestSchema = MessageRequestSchema;
+exports.MessageSchema = MessageSchema;
+exports.NetworkError = NetworkError;
+exports.PaginatedMessageListSchema = PaginatedMessageListSchema;
+exports.PaginatedTicketListSchema = PaginatedTicketListSchema;
+exports.PatchedMessageRequestSchema = PatchedMessageRequestSchema;
+exports.PatchedTicketRequestSchema = PatchedTicketRequestSchema;
+exports.REFRESH_TOKEN_KEY = REFRESH_TOKEN_KEY;
+exports.SUPPORT_LAYOUT_EVENTS = SUPPORT_LAYOUT_EVENTS;
+exports.Schemas = schemas_exports;
+exports.SenderSchema = SenderSchema;
+exports.SupportLayout = SupportLayout;
+exports.SupportLayoutProvider = SupportLayoutProvider;
+exports.SupportProvider = SupportProvider;
+exports.TOKEN_KEY = TOKEN_KEY;
+exports.TicketCard = TicketCard;
+exports.TicketList = TicketList;
+exports.TicketRequestSchema = TicketRequestSchema;
+exports.TicketSchema = TicketSchema;
+exports.apiSupport = apiSupport;
+exports.clearAPITokens = clearAPITokens;
+exports.closeCreateTicketDialog = closeCreateTicketDialog;
+exports.configureAPI = configureAPI;
+exports.createSupportTicketsCreate = createSupportTicketsCreate;
+exports.createSupportTicketsMessagesCreate = createSupportTicketsMessagesCreate;
+exports.deleteSupportTicketsDestroy = deleteSupportTicketsDestroy;
+exports.deleteSupportTicketsMessagesDestroy = deleteSupportTicketsMessagesDestroy;
+exports.dispatchValidationError = dispatchValidationError;
+exports.extensionConfig = extensionConfig;
+exports.formatZodError = formatZodError;
+exports.getAPIInstance = getAPIInstance;
+exports.getSupportTicketsList = getSupportTicketsList;
+exports.getSupportTicketsMessagesList = getSupportTicketsMessagesList;
+exports.getSupportTicketsMessagesRetrieve = getSupportTicketsMessagesRetrieve;
+exports.getSupportTicketsRetrieve = getSupportTicketsRetrieve;
+exports.isAPIConfigured = isAPIConfigured;
+exports.onValidationError = onValidationError;
+exports.openCreateTicketDialog = openCreateTicketDialog;
+exports.partialUpdateSupportTicketsMessagesPartialUpdate = partialUpdateSupportTicketsMessagesPartialUpdate;
+exports.partialUpdateSupportTicketsPartialUpdate = partialUpdateSupportTicketsPartialUpdate;
+exports.reconfigureAPI = reconfigureAPI;
+exports.resetAPI = resetAPI;
+exports.shouldRetry = shouldRetry;
+exports.updateSupportTicketsMessagesUpdate = updateSupportTicketsMessagesUpdate;
+exports.updateSupportTicketsUpdate = updateSupportTicketsUpdate;
+exports.useCreateSupportTicketsCreate = useCreateSupportTicketsCreate;
+exports.useCreateSupportTicketsMessagesCreate = useCreateSupportTicketsMessagesCreate;
+exports.useDeleteSupportTicketsDestroy = useDeleteSupportTicketsDestroy;
+exports.useDeleteSupportTicketsMessagesDestroy = useDeleteSupportTicketsMessagesDestroy;
+exports.useInfiniteMessages = useInfiniteMessages;
+exports.useInfiniteTickets = useInfiniteTickets;
+exports.usePartialUpdateSupportTicketsMessagesPartialUpdate = usePartialUpdateSupportTicketsMessagesPartialUpdate;
+exports.usePartialUpdateSupportTicketsPartialUpdate = usePartialUpdateSupportTicketsPartialUpdate;
+exports.useSupportContext = useSupportContext;
+exports.useSupportLayoutContext = useSupportLayoutContext;
+exports.useSupportTicketsList = useSupportTicketsList;
+exports.useSupportTicketsMessagesList = useSupportTicketsMessagesList;
+exports.useSupportTicketsMessagesRetrieve = useSupportTicketsMessagesRetrieve;
+exports.useSupportTicketsRetrieve = useSupportTicketsRetrieve;
+exports.useUpdateSupportTicketsMessagesUpdate = useUpdateSupportTicketsMessagesUpdate;
+exports.useUpdateSupportTicketsUpdate = useUpdateSupportTicketsUpdate;
+exports.withRetry = withRetry;