@djangocfg/api 1.0.1

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

@@ -0,0 +1,109 @@
+/**
+ * Typed fetchers for Webhooks
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { SupportedProvidersSchema, type SupportedProviders } from '../schemas/SupportedProviders.schema'
+import { WebhookHealthSchema, type WebhookHealth } from '../schemas/WebhookHealth.schema'
+import { WebhookResponseSchema, type WebhookResponse } from '../schemas/WebhookResponse.schema'
+import { WebhookResponseRequestSchema, type WebhookResponseRequest } from '../schemas/WebhookResponseRequest.schema'
+import { WebhookStatsSchema, type WebhookStats } from '../schemas/WebhookStats.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * Webhook Endpoint Info
+ *
+ * @method GET
+ * @path /cfg/payments/webhooks/{provider}/
+ */
+export async function getPaymentsWebhooksRetrieve(  provider: string,  client?: API
+): Promise<WebhookResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_webhooks.paymentsWebhooksRetrieve(provider)
+  return WebhookResponseSchema.parse(response)
+}
+
+
+/**
+ * Process Webhook
+ *
+ * @method POST
+ * @path /cfg/payments/webhooks/{provider}/
+ */
+export async function createPaymentsWebhooksCreate(  provider: string, data: WebhookResponseRequest,  client?: API
+): Promise<WebhookResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_webhooks.paymentsWebhooksCreate(provider, data)
+  return WebhookResponseSchema.parse(response)
+}
+
+
+/**
+ * Webhook Health Check
+ *
+ * @method GET
+ * @path /cfg/payments/webhooks/health/
+ */
+export async function getPaymentsWebhooksHealthRetrieve(  client?: API
+): Promise<WebhookHealth> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_webhooks.paymentsWebhooksHealthRetrieve()
+  return WebhookHealthSchema.parse(response)
+}
+
+
+/**
+ * Supported Webhook Providers
+ *
+ * @method GET
+ * @path /cfg/payments/webhooks/providers/
+ */
+export async function getPaymentsWebhooksProvidersRetrieve(  client?: API
+): Promise<SupportedProviders> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_webhooks.paymentsWebhooksProvidersRetrieve()
+  return SupportedProvidersSchema.parse(response)
+}
+
+
+/**
+ * Webhook Statistics
+ *
+ * @method GET
+ * @path /cfg/payments/webhooks/stats/
+ */
+export async function getPaymentsWebhooksStatsRetrieve(  params?: { days?: number },  client?: API
+): Promise<WebhookStats> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_webhooks.paymentsWebhooksStatsRetrieve(params?.days)
+  return WebhookStatsSchema.parse(response)
+}
+
+

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

@@ -0,0 +1,212 @@
+/**
+ * Typed fetchers for Support
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { MessageSchema, type Message } from '../schemas/Message.schema'
+import { MessageCreateSchema, type MessageCreate } from '../schemas/MessageCreate.schema'
+import { MessageCreateRequestSchema, type MessageCreateRequest } from '../schemas/MessageCreateRequest.schema'
+import { MessageRequestSchema, type MessageRequest } from '../schemas/MessageRequest.schema'
+import { PaginatedMessageListSchema, type PaginatedMessageList } from '../schemas/PaginatedMessageList.schema'
+import { PaginatedTicketListSchema, type PaginatedTicketList } from '../schemas/PaginatedTicketList.schema'
+import { PatchedMessageRequestSchema, type PatchedMessageRequest } from '../schemas/PatchedMessageRequest.schema'
+import { PatchedTicketRequestSchema, type PatchedTicketRequest } from '../schemas/PatchedTicketRequest.schema'
+import { TicketSchema, type Ticket } from '../schemas/Ticket.schema'
+import { TicketRequestSchema, type TicketRequest } from '../schemas/TicketRequest.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/
+ */
+export async function getSupportTicketsList(  params?: { page?: number; page_size?: number },  client?: API
+): Promise<PaginatedTicketList> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsList(params?.page, params?.page_size)
+  return PaginatedTicketListSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/support/tickets/
+ */
+export async function createSupportTicketsCreate(  data: TicketRequest,  client?: API
+): Promise<Ticket> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsCreate(data)
+  return TicketSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/
+ */
+export async function getSupportTicketsMessagesList(  ticket_uuid: string, params?: { page?: number; page_size?: number },  client?: API
+): Promise<PaginatedMessageList> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsMessagesList(ticket_uuid, params?.page, params?.page_size)
+  return PaginatedMessageListSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/
+ */
+export async function createSupportTicketsMessagesCreate(  ticket_uuid: string, data: MessageCreateRequest,  client?: API
+): Promise<MessageCreate> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsMessagesCreate(ticket_uuid, data)
+  return MessageCreateSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+export async function getSupportTicketsMessagesRetrieve(  ticket_uuid: string, uuid: string,  client?: API
+): Promise<Message> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsMessagesRetrieve(ticket_uuid, uuid)
+  return MessageSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+export async function updateSupportTicketsMessagesUpdate(  ticket_uuid: string, uuid: string, data: MessageRequest,  client?: API
+): Promise<Message> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsMessagesUpdate(ticket_uuid, uuid, data)
+  return MessageSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+export async function partialUpdateSupportTicketsMessagesPartialUpdate(  ticket_uuid: string, uuid: string, data?: PatchedMessageRequest,  client?: API
+): Promise<Message> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsMessagesPartialUpdate(ticket_uuid, uuid, data)
+  return MessageSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/support/tickets/{ticket_uuid}/messages/{uuid}/
+ */
+export async function deleteSupportTicketsMessagesDestroy(  ticket_uuid: string, uuid: string,  client?: API
+): Promise<void> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsMessagesDestroy(ticket_uuid, uuid)
+  return response
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/support/tickets/{uuid}/
+ */
+export async function getSupportTicketsRetrieve(  uuid: string,  client?: API
+): Promise<Ticket> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsRetrieve(uuid)
+  return TicketSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/support/tickets/{uuid}/
+ */
+export async function updateSupportTicketsUpdate(  uuid: string, data: TicketRequest,  client?: API
+): Promise<Ticket> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsUpdate(uuid, data)
+  return TicketSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/support/tickets/{uuid}/
+ */
+export async function partialUpdateSupportTicketsPartialUpdate(  uuid: string, data?: PatchedTicketRequest,  client?: API
+): Promise<Ticket> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsPartialUpdate(uuid, data)
+  return TicketSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/support/tickets/{uuid}/
+ */
+export async function deleteSupportTicketsDestroy(  uuid: string,  client?: API
+): Promise<void> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_support.ticketsDestroy(uuid)
+  return response
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__tasks.ts

@@ -0,0 +1,182 @@
+/**
+ * Typed fetchers for Tasks
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { APIResponseSchema, type APIResponse } from '../schemas/APIResponse.schema'
+import { APIResponseRequestSchema, type APIResponseRequest } from '../schemas/APIResponseRequest.schema'
+import { QueueActionSchema, type QueueAction } from '../schemas/QueueAction.schema'
+import { QueueActionRequestSchema, type QueueActionRequest } from '../schemas/QueueActionRequest.schema'
+import { QueueStatusSchema, type QueueStatus } from '../schemas/QueueStatus.schema'
+import { TaskStatisticsSchema, type TaskStatistics } from '../schemas/TaskStatistics.schema'
+import { WorkerActionSchema, type WorkerAction } from '../schemas/WorkerAction.schema'
+import { WorkerActionRequestSchema, type WorkerActionRequest } from '../schemas/WorkerActionRequest.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/clear/
+ */
+export async function createTasksApiClearCreate(  data: APIResponseRequest,  client?: API
+): Promise<APIResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_tasks.apiClearCreate(data)
+  return APIResponseSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/clear-queues/
+ */
+export async function createTasksApiClearQueuesCreate(  data: APIResponseRequest,  client?: API
+): Promise<APIResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_tasks.apiClearQueuesCreate(data)
+  return APIResponseSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/purge-failed/
+ */
+export async function createTasksApiPurgeFailedCreate(  data: APIResponseRequest,  client?: API
+): Promise<APIResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_tasks.apiPurgeFailedCreate(data)
+  return APIResponseSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/queues/manage/
+ */
+export async function createTasksApiQueuesManageCreate(  data: QueueActionRequest,  client?: API
+): Promise<QueueAction> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_tasks.apiQueuesManageCreate(data)
+  return QueueActionSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/tasks/api/queues/status/
+ */
+export async function getTasksApiQueuesStatusRetrieve(  client?: API
+): Promise<QueueStatus> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_tasks.apiQueuesStatusRetrieve()
+  return QueueStatusSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/simulate/
+ */
+export async function createTasksApiSimulateCreate(  data: APIResponseRequest,  client?: API
+): Promise<APIResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_tasks.apiSimulateCreate(data)
+  return APIResponseSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/tasks/api/tasks/list/
+ */
+export async function getTasksApiTasksListRetrieve(  client?: API
+): Promise<APIResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_tasks.apiTasksListRetrieve()
+  return APIResponseSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/tasks/api/tasks/stats/
+ */
+export async function getTasksApiTasksStatsRetrieve(  client?: API
+): Promise<TaskStatistics> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_tasks.apiTasksStatsRetrieve()
+  return TaskStatisticsSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/tasks/api/workers/list/
+ */
+export async function getTasksApiWorkersListRetrieve(  client?: API
+): Promise<APIResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_tasks.apiWorkersListRetrieve()
+  return APIResponseSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/tasks/api/workers/manage/
+ */
+export async function createTasksApiWorkersManageCreate(  data: WorkerActionRequest,  client?: API
+): Promise<WorkerAction> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_tasks.apiWorkersManageCreate(data)
+  return WorkerActionSchema.parse(response)
+}
+
+

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

@@ -0,0 +1,45 @@
+/**
+ * Typed Fetchers - Universal API functions
+ *
+ * Auto-generated from OpenAPI specification.
+ * These functions work in any JavaScript environment.
+ *
+ * Features:
+ * - Runtime validation with Zod
+ * - Type-safe parameters and responses
+ * - Works with any data-fetching library (SWR, React Query, etc)
+ * - Server Component compatible
+ *
+ * Usage:
+ * ```typescript
+ * import * as fetchers from './fetchers'
+ *
+ * // Direct usage
+ * const user = await fetchers.getUser(1)
+ *
+ * // With SWR
+ * const { data } = useSWR('user-1', () => fetchers.getUser(1))
+ *
+ * // With React Query
+ * const { data } = useQuery(['user', 1], () => fetchers.getUser(1))
+ * ```
+ */
+
+export * from './cfg__accounts'
+export * from './cfg__accounts__auth'
+export * from './cfg__accounts__user_profile'
+export * from './cfg__endpoints'
+export * from './cfg__health'
+export * from './cfg__leads'
+export * from './cfg__leads__lead_submission'
+export * from './cfg__newsletter'
+export * from './cfg__newsletter__bulk_email'
+export * from './cfg__newsletter__campaigns'
+export * from './cfg__newsletter__logs'
+export * from './cfg__newsletter__newsletters'
+export * from './cfg__newsletter__subscriptions'
+export * from './cfg__newsletter__testing'
+export * from './cfg__payments'
+export * from './cfg__payments__webhooks'
+export * from './cfg__support'
+export * from './cfg__tasks'

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

@@ -0,0 +1,61 @@
+/**
+ * SWR Hooks for Accounts
+ *
+ * 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__accounts'
+import type { API } from '../../index'
+import type { OTPRequestRequest } from '../schemas/OTPRequestRequest.schema'
+import type { OTPRequestResponse } from '../schemas/OTPRequestResponse.schema'
+import type { OTPVerifyRequest } from '../schemas/OTPVerifyRequest.schema'
+import type { OTPVerifyResponse } from '../schemas/OTPVerifyResponse.schema'
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/accounts/otp/request/
+ */
+export function useCreateAccountsOtpRequestCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: OTPRequestRequest, client?: API): Promise<OTPRequestResponse> => {
+    const result = await Fetchers.createAccountsOtpRequestCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-accounts-otp-request')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/accounts/otp/verify/
+ */
+export function useCreateAccountsOtpVerifyCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: OTPVerifyRequest, client?: API): Promise<OTPVerifyResponse> => {
+    const result = await Fetchers.createAccountsOtpVerifyCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-accounts-otp-verify')
+    return result
+  }
+}
+
+

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

@@ -0,0 +1,41 @@
+/**
+ * SWR Hooks for Auth
+ *
+ * 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__accounts__auth'
+import type { API } from '../../index'
+import type { TokenRefresh } from '../schemas/TokenRefresh.schema'
+import type { TokenRefreshRequest } from '../schemas/TokenRefreshRequest.schema'
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/accounts/token/refresh/
+ */
+export function useCreateAccountsTokenRefreshCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: TokenRefreshRequest, client?: API): Promise<TokenRefresh> => {
+    const result = await Fetchers.createAccountsTokenRefreshCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-accounts-token-refresh')
+    return result
+  }
+}
+
+