@djangocfg/ext-support 1.0.0

package/src/api/generated/ext_support/_utils/hooks/ext_support__support.ts

@@ -0,0 +1,237 @@
+'use client';
+
+/**
+ * SWR Hooks for Support
+ *
+ * React hooks powered by SWR for data fetching with automatic caching,
+ * revalidation, and optimistic updates.
+ *
+ * Usage:
+ * ```typescript
+ * // Query hooks (GET)
+ * const { data, error, isLoading } = useUsers({ page: 1 })
+ *
+ * // Mutation hooks (POST/PUT/PATCH/DELETE)
+ * const createUser = useCreateUser()
+ * await createUser({ name: 'John', email: 'john@example.com' })
+ * ```
+ */
+import useSWR from 'swr'
+import { useSWRConfig } from 'swr'
+import * as Fetchers from '../fetchers/ext_support__support'
+import type { API } from '../../index'
+import type { Message } from '../schemas/Message.schema'
+import type { MessageCreate } from '../schemas/MessageCreate.schema'
+import type { MessageCreateRequest } from '../schemas/MessageCreateRequest.schema'
+import type { MessageRequest } from '../schemas/MessageRequest.schema'
+import type { PaginatedMessageList } from '../schemas/PaginatedMessageList.schema'
+import type { PaginatedTicketList } from '../schemas/PaginatedTicketList.schema'
+import type { PatchedMessageRequest } from '../schemas/PatchedMessageRequest.schema'
+import type { PatchedTicketRequest } from '../schemas/PatchedTicketRequest.schema'
+import type { Ticket } from '../schemas/Ticket.schema'
+import type { TicketRequest } from '../schemas/TicketRequest.schema'
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/
+ */
+export function useSupportTicketsList(params?: { page?: number; page_size?: number }, client?: API): ReturnType<typeof useSWR<PaginatedTicketList>> {
+  return useSWR<PaginatedTicketList>(
+    params ? ['cfg-support-tickets', params] : 'cfg-support-tickets',
+    () => Fetchers.getSupportTicketsList(params, client)
+  )
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/support/tickets/
+ */
+export function useCreateSupportTicketsCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: TicketRequest, client?: API): Promise<Ticket> => {
+    const result = await Fetchers.createSupportTicketsCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-support-tickets')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/
+ */
+export function useSupportTicketsMessagesList(ticket_uuid: string, params?: { page?: number; page_size?: number }, client?: API): ReturnType<typeof useSWR<PaginatedMessageList>> {
+  return useSWR<PaginatedMessageList>(
+    ['cfg-support-tickets-messages', ticket_uuid],
+    () => Fetchers.getSupportTicketsMessagesList(ticket_uuid, params, client)
+  )
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/
+ */
+export function useCreateSupportTicketsMessagesCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (ticket_uuid: string, data: MessageCreateRequest, client?: API): Promise<MessageCreate> => {
+    const result = await Fetchers.createSupportTicketsMessagesCreate(ticket_uuid, data, client)
+    // Revalidate related queries
+    mutate('cfg-support-tickets-messages')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+export function useSupportTicketsMessagesRetrieve(ticket_uuid: string, uuid: string, client?: API): ReturnType<typeof useSWR<Message>> {
+  return useSWR<Message>(
+    ['cfg-support-tickets-message', ticket_uuid],
+    () => Fetchers.getSupportTicketsMessagesRetrieve(ticket_uuid, uuid, client)
+  )
+}
+
+
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+export function useUpdateSupportTicketsMessagesUpdate() {
+  const { mutate } = useSWRConfig()
+
+  return async (ticket_uuid: string, uuid: string, data: MessageRequest, client?: API): Promise<Message> => {
+    const result = await Fetchers.updateSupportTicketsMessagesUpdate(ticket_uuid, uuid, data, client)
+    // Revalidate related queries
+    mutate('cfg-support-tickets-messages')
+    mutate('cfg-support-tickets-message')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+export function usePartialUpdateSupportTicketsMessagesPartialUpdate() {
+  const { mutate } = useSWRConfig()
+
+  return async (ticket_uuid: string, uuid: string, data?: PatchedMessageRequest, client?: API): Promise<Message> => {
+    const result = await Fetchers.partialUpdateSupportTicketsMessagesPartialUpdate(ticket_uuid, uuid, data, client)
+    // Revalidate related queries
+    mutate('cfg-support-tickets-messages-partial')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+export function useDeleteSupportTicketsMessagesDestroy() {
+  const { mutate } = useSWRConfig()
+
+  return async (ticket_uuid: string, uuid: string, client?: API): Promise<void> => {
+    const result = await Fetchers.deleteSupportTicketsMessagesDestroy(ticket_uuid, uuid, client)
+    // Revalidate related queries
+    mutate('cfg-support-tickets-messages')
+    mutate('cfg-support-tickets-message')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/{uuid}/
+ */
+export function useSupportTicketsRetrieve(uuid: string, client?: API): ReturnType<typeof useSWR<Ticket>> {
+  return useSWR<Ticket>(
+    ['cfg-support-ticket', uuid],
+    () => Fetchers.getSupportTicketsRetrieve(uuid, client)
+  )
+}
+
+
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/support/tickets/{uuid}/
+ */
+export function useUpdateSupportTicketsUpdate() {
+  const { mutate } = useSWRConfig()
+
+  return async (uuid: string, data: TicketRequest, client?: API): Promise<Ticket> => {
+    const result = await Fetchers.updateSupportTicketsUpdate(uuid, data, client)
+    // Revalidate related queries
+    mutate('cfg-support-tickets')
+    mutate('cfg-support-ticket')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/support/tickets/{uuid}/
+ */
+export function usePartialUpdateSupportTicketsPartialUpdate() {
+  const { mutate } = useSWRConfig()
+
+  return async (uuid: string, data?: PatchedTicketRequest, client?: API): Promise<Ticket> => {
+    const result = await Fetchers.partialUpdateSupportTicketsPartialUpdate(uuid, data, client)
+    // Revalidate related queries
+    mutate('cfg-support-tickets-partial')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/support/tickets/{uuid}/
+ */
+export function useDeleteSupportTicketsDestroy() {
+  const { mutate } = useSWRConfig()
+
+  return async (uuid: string, client?: API): Promise<void> => {
+    const result = await Fetchers.deleteSupportTicketsDestroy(uuid, client)
+    // Revalidate related queries
+    mutate('cfg-support-tickets')
+    mutate('cfg-support-ticket')
+    return result
+  }
+}
+
+

package/src/api/generated/ext_support/_utils/hooks/index.ts

@@ -0,0 +1,28 @@
+'use client';
+
+/**
+ * SWR Hooks - React data fetching hooks
+ *
+ * Auto-generated from OpenAPI specification.
+ * Powered by SWR for automatic caching and revalidation.
+ *
+ * Features:
+ * - Automatic caching and deduplication
+ * - Revalidation on focus/reconnect
+ * - Optimistic updates
+ * - Type-safe parameters and responses
+ *
+ * Usage:
+ * ```typescript
+ * import * as hooks from './hooks'
+ *
+ * // Query hooks (GET)
+ * const { data, error, isLoading } = hooks.useUsers({ page: 1 })
+ *
+ * // Mutation hooks (POST/PUT/PATCH/DELETE)
+ * const createUser = hooks.useCreateUser()
+ * await createUser({ name: 'John' })
+ * ```
+ */
+
+export * from './ext_support__support'

package/src/api/generated/ext_support/_utils/schemas/Message.schema.ts

@@ -0,0 +1,21 @@
+/**
+ * Zod schema for Message
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+import { SenderSchema } from './Sender.schema'
+
+export const MessageSchema = z.object({
+  uuid: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  ticket: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  sender: SenderSchema,
+  is_from_author: z.boolean(),
+  text: z.string(),
+  created_at: z.iso.datetime(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type Message = z.infer<typeof MessageSchema>

package/src/api/generated/ext_support/_utils/schemas/MessageCreate.schema.ts

@@ -0,0 +1,15 @@
+/**
+ * Zod schema for MessageCreate
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+
+export const MessageCreateSchema = z.object({
+  text: z.string(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type MessageCreate = z.infer<typeof MessageCreateSchema>

package/src/api/generated/ext_support/_utils/schemas/MessageCreateRequest.schema.ts

@@ -0,0 +1,15 @@
+/**
+ * Zod schema for MessageCreateRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+
+export const MessageCreateRequestSchema = z.object({
+  text: z.string().min(1),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type MessageCreateRequest = z.infer<typeof MessageCreateRequestSchema>

package/src/api/generated/ext_support/_utils/schemas/MessageRequest.schema.ts

@@ -0,0 +1,15 @@
+/**
+ * Zod schema for MessageRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+
+export const MessageRequestSchema = z.object({
+  text: z.string().min(1),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type MessageRequest = z.infer<typeof MessageRequestSchema>

package/src/api/generated/ext_support/_utils/schemas/PaginatedMessageList.schema.ts

@@ -0,0 +1,24 @@
+/**
+ * Zod schema for PaginatedMessageList
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+import { MessageSchema } from './Message.schema'
+
+export const PaginatedMessageListSchema = z.object({
+  count: z.int(),
+  page: z.int(),
+  pages: z.int(),
+  page_size: z.int(),
+  has_next: z.boolean(),
+  has_previous: z.boolean(),
+  next_page: z.int().nullable().optional(),
+  previous_page: z.int().nullable().optional(),
+  results: z.array(MessageSchema),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type PaginatedMessageList = z.infer<typeof PaginatedMessageListSchema>

package/src/api/generated/ext_support/_utils/schemas/PaginatedTicketList.schema.ts

@@ -0,0 +1,24 @@
+/**
+ * Zod schema for PaginatedTicketList
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+import { TicketSchema } from './Ticket.schema'
+
+export const PaginatedTicketListSchema = z.object({
+  count: z.int(),
+  page: z.int(),
+  pages: z.int(),
+  page_size: z.int(),
+  has_next: z.boolean(),
+  has_previous: z.boolean(),
+  next_page: z.int().nullable().optional(),
+  previous_page: z.int().nullable().optional(),
+  results: z.array(TicketSchema),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type PaginatedTicketList = z.infer<typeof PaginatedTicketListSchema>

package/src/api/generated/ext_support/_utils/schemas/PatchedMessageRequest.schema.ts

@@ -0,0 +1,15 @@
+/**
+ * Zod schema for PatchedMessageRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+
+export const PatchedMessageRequestSchema = z.object({
+  text: z.string().min(1).optional(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type PatchedMessageRequest = z.infer<typeof PatchedMessageRequestSchema>

package/src/api/generated/ext_support/_utils/schemas/PatchedTicketRequest.schema.ts

@@ -0,0 +1,18 @@
+/**
+ * Zod schema for PatchedTicketRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+import * as Enums from '../../enums'
+
+export const PatchedTicketRequestSchema = z.object({
+  user: z.int().optional(),
+  subject: z.string().min(1).max(255).optional(),
+  status: z.nativeEnum(Enums.PatchedTicketRequestStatus).optional(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type PatchedTicketRequest = z.infer<typeof PatchedTicketRequestSchema>

package/src/api/generated/ext_support/_utils/schemas/Sender.schema.ts

@@ -0,0 +1,21 @@
+/**
+ * Zod schema for Sender
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+
+export const SenderSchema = z.object({
+  id: z.int(),
+  display_username: z.string(),
+  email: z.email(),
+  avatar: z.string().nullable(),
+  initials: z.string(),
+  is_staff: z.boolean(),
+  is_superuser: z.boolean(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type Sender = z.infer<typeof SenderSchema>

package/src/api/generated/ext_support/_utils/schemas/Ticket.schema.ts

@@ -0,0 +1,21 @@
+/**
+ * Zod schema for Ticket
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+import * as Enums from '../../enums'
+
+export const TicketSchema = z.object({
+  uuid: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  user: z.int(),
+  subject: z.string().max(255),
+  status: z.nativeEnum(Enums.TicketStatus).optional(),
+  created_at: z.iso.datetime(),
+  unanswered_messages_count: z.int(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type Ticket = z.infer<typeof TicketSchema>

package/src/api/generated/ext_support/_utils/schemas/TicketRequest.schema.ts

@@ -0,0 +1,18 @@
+/**
+ * Zod schema for TicketRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+import * as Enums from '../../enums'
+
+export const TicketRequestSchema = z.object({
+  user: z.int(),
+  subject: z.string().min(1).max(255),
+  status: z.nativeEnum(Enums.TicketRequestStatus).optional(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type TicketRequest = z.infer<typeof TicketRequestSchema>

package/src/api/generated/ext_support/_utils/schemas/index.ts

@@ -0,0 +1,29 @@
+/**
+ * Zod Schemas - Runtime validation and type inference
+ *
+ * Auto-generated from OpenAPI specification.
+ * Provides runtime validation for API requests and responses.
+ *
+ * Usage:
+ * ```typescript
+ * import { UserSchema } from './schemas'
+ *
+ * // Validate data
+ * const user = UserSchema.parse(data)
+ *
+ * // Type inference
+ * type User = z.infer<typeof UserSchema>
+ * ```
+ */
+
+export * from './Message.schema'
+export * from './MessageCreate.schema'
+export * from './MessageCreateRequest.schema'
+export * from './MessageRequest.schema'
+export * from './PaginatedMessageList.schema'
+export * from './PaginatedTicketList.schema'
+export * from './PatchedMessageRequest.schema'
+export * from './PatchedTicketRequest.schema'
+export * from './Sender.schema'
+export * from './Ticket.schema'
+export * from './TicketRequest.schema'

package/src/api/generated/ext_support/api-instance.ts

@@ -0,0 +1,131 @@
+/**
+ * Global API Instance - Singleton configuration
+ *
+ * This module provides a global API instance that can be configured once
+ * and used throughout your application.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure once (e.g., in your app entry point)
+ * import { configureAPI } from './api-instance'
+ *
+ * configureAPI({
+ *   baseUrl: 'https://api.example.com',
+ *   token: 'your-jwt-token'
+ * })
+ *
+ * // Then use fetchers and hooks anywhere without configuration
+ * import { getUsers } from './fetchers'
+ * const users = await getUsers({ page: 1 })
+ * ```
+ *
+ * For SSR or multiple instances:
+ * ```typescript
+ * import { API } from './index'
+ * import { getUsers } from './fetchers'
+ *
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+
+import { API, type APIOptions } from './index'
+
+let globalAPI: API | null = null
+
+/**
+ * Get the global API instance
+ * @throws Error if API is not configured
+ */
+export function getAPIInstance(): API {
+  if (!globalAPI) {
+    throw new Error(
+      'API not configured. Call configureAPI() with your base URL before using fetchers or hooks.\n\n' +
+      'Example:\n' +
+      '  import { configureAPI } from "./api-instance"\n' +
+      '  configureAPI({ baseUrl: "https://api.example.com" })'
+    )
+  }
+  return globalAPI
+}
+
+/**
+ * Check if API is configured
+ */
+export function isAPIConfigured(): boolean {
+  return globalAPI !== null
+}
+
+/**
+ * Configure the global API instance
+ *
+ * @param baseUrl - Base URL for the API
+ * @param options - Optional configuration (storage, retry, logger)
+ *
+ * @example
+ * ```typescript
+ * configureAPI({
+ *   baseUrl: 'https://api.example.com',
+ *   token: 'jwt-token',
+ *   options: {
+ *     retryConfig: { maxRetries: 3 },
+ *     loggerConfig: { enabled: true }
+ *   }
+ * })
+ * ```
+ */
+export function configureAPI(config: {
+  baseUrl: string
+  token?: string
+  refreshToken?: string
+  options?: APIOptions
+}): API {
+  globalAPI = new API(config.baseUrl, config.options)
+
+  if (config.token) {
+    globalAPI.setToken(config.token, config.refreshToken)
+  }
+
+  return globalAPI
+}
+
+/**
+ * Reconfigure the global API instance with new settings
+ * Useful for updating tokens or base URL
+ */
+export function reconfigureAPI(updates: {
+  baseUrl?: string
+  token?: string
+  refreshToken?: string
+}): API {
+  const instance = getAPIInstance()
+
+  if (updates.baseUrl) {
+    instance.setBaseUrl(updates.baseUrl)
+  }
+
+  if (updates.token) {
+    instance.setToken(updates.token, updates.refreshToken)
+  }
+
+  return instance
+}
+
+/**
+ * Clear tokens from the global API instance
+ */
+export function clearAPITokens(): void {
+  const instance = getAPIInstance()
+  instance.clearTokens()
+}
+
+/**
+ * Reset the global API instance
+ * Useful for testing or logout scenarios
+ */
+export function resetAPI(): void {
+  if (globalAPI) {
+    globalAPI.clearTokens()
+  }
+  globalAPI = null
+}