@djangocfg/api 1.0.1

package/src/cfg/generated/_utils/hooks/cfg__payments__webhooks.ts

@@ -0,0 +1,100 @@
+/**
+ * SWR Hooks for Webhooks
+ *
+ * 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/cfg__payments__webhooks'
+import type { API } from '../../index'
+import type { SupportedProviders } from '../schemas/SupportedProviders.schema'
+import type { WebhookHealth } from '../schemas/WebhookHealth.schema'
+import type { WebhookResponse } from '../schemas/WebhookResponse.schema'
+import type { WebhookResponseRequest } from '../schemas/WebhookResponseRequest.schema'
+import type { WebhookStats } from '../schemas/WebhookStats.schema'
+
+/**
+ * Webhook Endpoint Info
+ *
+ * @method GET
+ * @path /cfg/payments/webhooks/{provider}/
+ */
+export function usePaymentsWebhooksRetrieve(provider: string, client?: API): ReturnType<typeof useSWR<WebhookResponse>> {
+  return useSWR<WebhookResponse>(
+    ['cfg-payments-webhook', provider],
+    () => Fetchers.getPaymentsWebhooksRetrieve(provider, client)
+  )
+}
+
+
+/**
+ * Process Webhook
+ *
+ * @method POST
+ * @path /cfg/payments/webhooks/{provider}/
+ */
+export function useCreatePaymentsWebhooksCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (provider: string, data: WebhookResponseRequest, client?: API): Promise<WebhookResponse> => {
+    const result = await Fetchers.createPaymentsWebhooksCreate(provider, data, client)
+    // Revalidate related queries
+    mutate('cfg-payments-webhooks')
+    return result
+  }
+}
+
+
+/**
+ * Webhook Health Check
+ *
+ * @method GET
+ * @path /cfg/payments/webhooks/health/
+ */
+export function usePaymentsWebhooksHealthRetrieve(client?: API): ReturnType<typeof useSWR<WebhookHealth>> {
+  return useSWR<WebhookHealth>(
+    'cfg-payments-webhooks-health',
+    () => Fetchers.getPaymentsWebhooksHealthRetrieve(client)
+  )
+}
+
+
+/**
+ * Supported Webhook Providers
+ *
+ * @method GET
+ * @path /cfg/payments/webhooks/providers/
+ */
+export function usePaymentsWebhooksProvidersRetrieve(client?: API): ReturnType<typeof useSWR<SupportedProviders>> {
+  return useSWR<SupportedProviders>(
+    'cfg-payments-webhooks-provider',
+    () => Fetchers.getPaymentsWebhooksProvidersRetrieve(client)
+  )
+}
+
+
+/**
+ * Webhook Statistics
+ *
+ * @method GET
+ * @path /cfg/payments/webhooks/stats/
+ */
+export function usePaymentsWebhooksStatsRetrieve(params?: { days?: number }, client?: API): ReturnType<typeof useSWR<WebhookStats>> {
+  return useSWR<WebhookStats>(
+    params ? ['cfg-payments-webhooks-stat', params] : 'cfg-payments-webhooks-stat',
+    () => Fetchers.getPaymentsWebhooksStatsRetrieve(params, client)
+  )
+}
+
+

package/src/cfg/generated/_utils/hooks/cfg__support.ts

@@ -0,0 +1,235 @@
+/**
+ * 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/cfg__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/cfg/generated/_utils/hooks/cfg__tasks.ts

@@ -0,0 +1,193 @@
+/**
+ * SWR Hooks for Tasks
+ *
+ * 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/cfg__tasks'
+import type { API } from '../../index'
+import type { APIResponse } from '../schemas/APIResponse.schema'
+import type { APIResponseRequest } from '../schemas/APIResponseRequest.schema'
+import type { QueueAction } from '../schemas/QueueAction.schema'
+import type { QueueActionRequest } from '../schemas/QueueActionRequest.schema'
+import type { QueueStatus } from '../schemas/QueueStatus.schema'
+import type { TaskStatistics } from '../schemas/TaskStatistics.schema'
+import type { WorkerAction } from '../schemas/WorkerAction.schema'
+import type { WorkerActionRequest } from '../schemas/WorkerActionRequest.schema'
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/clear/
+ */
+export function useCreateTasksApiClearCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: APIResponseRequest, client?: API): Promise<APIResponse> => {
+    const result = await Fetchers.createTasksApiClearCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-tasks-api-clear')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/clear-queues/
+ */
+export function useCreateTasksApiClearQueuesCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: APIResponseRequest, client?: API): Promise<APIResponse> => {
+    const result = await Fetchers.createTasksApiClearQueuesCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-tasks-api-clear-queues')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/purge-failed/
+ */
+export function useCreateTasksApiPurgeFailedCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: APIResponseRequest, client?: API): Promise<APIResponse> => {
+    const result = await Fetchers.createTasksApiPurgeFailedCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-tasks-api-purge-failed')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/queues/manage/
+ */
+export function useCreateTasksApiQueuesManageCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: QueueActionRequest, client?: API): Promise<QueueAction> => {
+    const result = await Fetchers.createTasksApiQueuesManageCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-tasks-api-queues-manage')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/tasks/api/queues/status/
+ */
+export function useTasksApiQueuesStatusRetrieve(client?: API): ReturnType<typeof useSWR<QueueStatus>> {
+  return useSWR<QueueStatus>(
+    'cfg-tasks-api-queues-statu',
+    () => Fetchers.getTasksApiQueuesStatusRetrieve(client)
+  )
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/simulate/
+ */
+export function useCreateTasksApiSimulateCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: APIResponseRequest, client?: API): Promise<APIResponse> => {
+    const result = await Fetchers.createTasksApiSimulateCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-tasks-api-simulate')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/tasks/api/tasks/list/
+ */
+export function useTasksApiTasksListRetrieve(client?: API): ReturnType<typeof useSWR<APIResponse>> {
+  return useSWR<APIResponse>(
+    'cfg-tasks-api-task',
+    () => Fetchers.getTasksApiTasksListRetrieve(client)
+  )
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/tasks/api/tasks/stats/
+ */
+export function useTasksApiTasksStatsRetrieve(client?: API): ReturnType<typeof useSWR<TaskStatistics>> {
+  return useSWR<TaskStatistics>(
+    'cfg-tasks-api-tasks-stat',
+    () => Fetchers.getTasksApiTasksStatsRetrieve(client)
+  )
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/tasks/api/workers/list/
+ */
+export function useTasksApiWorkersListRetrieve(client?: API): ReturnType<typeof useSWR<APIResponse>> {
+  return useSWR<APIResponse>(
+    'cfg-tasks-api-worker',
+    () => Fetchers.getTasksApiWorkersListRetrieve(client)
+  )
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/workers/manage/
+ */
+export function useCreateTasksApiWorkersManageCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: WorkerActionRequest, client?: API): Promise<WorkerAction> => {
+    const result = await Fetchers.createTasksApiWorkersManageCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-tasks-api-workers-manage')
+    return result
+  }
+}
+
+

package/src/cfg/generated/_utils/hooks/index.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 './cfg__accounts__auth'
+export * from './cfg__newsletter__bulk_email'
+export * from './cfg__newsletter__campaigns'
+export * from './cfg__leads__lead_submission'
+export * from './cfg__newsletter__logs'
+export * from './cfg__newsletter__newsletters'
+export * from './cfg__newsletter__subscriptions'
+export * from './cfg__newsletter__testing'
+export * from './cfg__accounts__user_profile'
+export * from './cfg__payments__webhooks'
+export * from './cfg__accounts'
+export * from './cfg__endpoints'
+export * from './cfg__health'
+export * from './cfg__leads'
+export * from './cfg__newsletter'
+export * from './cfg__payments'
+export * from './cfg__support'
+export * from './cfg__tasks'

package/src/cfg/generated/_utils/schemas/APIKeyCreate.schema.ts

@@ -0,0 +1,24 @@
+/**
+ * Zod schema for APIKeyCreate
+ *
+ * This schema provides runtime validation and type inference.
+ *  * API key creation serializer with service integration.
+
+Creates new API keys and returns the full key value (only once).
+ *  */
+import { z } from 'zod'
+
+/**
+ * API key creation serializer with service integration.
+
+Creates new API keys and returns the full key value (only once).
+ */
+export const APIKeyCreateSchema = z.object({
+  name: z.string().max(100),
+  expires_in_days: z.int().min(1.0).max(365.0).nullable().optional(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type APIKeyCreate = z.infer<typeof APIKeyCreateSchema>

package/src/cfg/generated/_utils/schemas/APIKeyCreateRequest.schema.ts

@@ -0,0 +1,24 @@
+/**
+ * Zod schema for APIKeyCreateRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * API key creation serializer with service integration.
+
+Creates new API keys and returns the full key value (only once).
+ *  */
+import { z } from 'zod'
+
+/**
+ * API key creation serializer with service integration.
+
+Creates new API keys and returns the full key value (only once).
+ */
+export const APIKeyCreateRequestSchema = z.object({
+  name: z.string().min(1).max(100),
+  expires_in_days: z.int().min(1.0).max(365.0).nullable().optional(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type APIKeyCreateRequest = z.infer<typeof APIKeyCreateRequestSchema>

package/src/cfg/generated/_utils/schemas/APIKeyDetail.schema.ts

@@ -0,0 +1,35 @@
+/**
+ * Zod schema for APIKeyDetail
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Complete API key serializer with full details.
+
+Used for API key detail views (no key value for security).
+ *  */
+import { z } from 'zod'
+
+/**
+ * Complete API key serializer with full details.
+
+Used for API key detail views (no key value for security).
+ */
+export const APIKeyDetailSchema = z.object({
+  id: z.uuid(),
+  user: z.string(),
+  name: z.string(),
+  key_preview: z.string(),
+  is_active: z.boolean(),
+  is_expired: z.boolean(),
+  is_valid: z.boolean(),
+  days_until_expiry: z.int(),
+  total_requests: z.int(),
+  last_used_at: z.iso.datetime().nullable(),
+  expires_at: z.iso.datetime().nullable(),
+  created_at: z.iso.datetime(),
+  updated_at: z.iso.datetime(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type APIKeyDetail = z.infer<typeof APIKeyDetailSchema>

package/src/cfg/generated/_utils/schemas/APIKeyList.schema.ts

@@ -0,0 +1,32 @@
+/**
+ * Zod schema for APIKeyList
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Lightweight API key serializer for lists.
+
+Optimized for API key lists with minimal data (no key value).
+ *  */
+import { z } from 'zod'
+
+/**
+ * Lightweight API key serializer for lists.
+
+Optimized for API key lists with minimal data (no key value).
+ */
+export const APIKeyListSchema = z.object({
+  id: z.uuid(),
+  user: z.string(),
+  name: z.string(),
+  is_active: z.boolean(),
+  is_expired: z.boolean(),
+  is_valid: z.boolean(),
+  total_requests: z.int(),
+  last_used_at: z.iso.datetime().nullable(),
+  expires_at: z.iso.datetime().nullable(),
+  created_at: z.iso.datetime(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type APIKeyList = z.infer<typeof APIKeyListSchema>