@djangocfg/api 1.2.19 → 1.2.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@djangocfg/api",
-  "version": "1.2.19",
+  "version": "1.2.20",
   "author": {
     "name": "DjangoCFG",
     "url": "https://djangocfg.com"
@@ -68,7 +68,7 @@
     "@types/node": "^22.15.3",
     "@types/react": "19.2.2",
     "@types/react-dom": "19.2.1",
-    "@djangocfg/typescript-config": "^1.2.19",
+    "@djangocfg/typescript-config": "^1.2.20",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "tsup": "^8.5.0",

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

@@ -0,0 +1,105 @@
+/**
+ * Typed fetchers for RQ Jobs
+ *
+ * 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 { JobActionResponseSchema, type JobActionResponse } from '../schemas/JobActionResponse.schema'
+import { JobDetailSchema, type JobDetail } from '../schemas/JobDetail.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * List all jobs
+ *
+ * @method GET
+ * @path /cfg/rq/jobs/
+ */
+export async function getRqJobsList(  params?: { queue?: string; status?: string },  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_jobs.list(params?.queue, params?.status)
+  return response
+}
+
+
+/**
+ * Get job details
+ *
+ * @method GET
+ * @path /cfg/rq/jobs/{id}/
+ */
+export async function getRqJobsRetrieve(  id: string,  client?: any
+): Promise<JobDetail> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_jobs.retrieve(id)
+  return JobDetailSchema.parse(response)
+}
+
+
+/**
+ * Delete job
+ *
+ * @method DELETE
+ * @path /cfg/rq/jobs/{id}/
+ */
+export async function deleteRqJobsDestroy(  id: string,  client?: any
+): Promise<JobActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_jobs.destroy(id)
+  return JobActionResponseSchema.parse(response)
+}
+
+
+/**
+ * Cancel job
+ *
+ * @method POST
+ * @path /cfg/rq/jobs/{id}/cancel/
+ */
+export async function createRqJobsCancelCreate(  id: string,  client?: any
+): Promise<JobActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_jobs.cancelCreate(id)
+  return JobActionResponseSchema.parse(response)
+}
+
+
+/**
+ * Requeue job
+ *
+ * @method POST
+ * @path /cfg/rq/jobs/{id}/requeue/
+ */
+export async function createRqJobsRequeueCreate(  id: string,  client?: any
+): Promise<JobActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_jobs.requeueCreate(id)
+  return JobActionResponseSchema.parse(response)
+}
+
+

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

@@ -0,0 +1,77 @@
+/**
+ * Typed fetchers for RQ Monitoring
+ *
+ * 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 { HealthCheckSchema, type HealthCheck } from '../schemas/HealthCheck.schema'
+import { RQConfigSchema, type RQConfig } from '../schemas/RQConfig.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * Get RQ configuration
+ *
+ * @method GET
+ * @path /cfg/rq/monitor/config/
+ */
+export async function getRqMonitorConfigRetrieve(  client?: any
+): Promise<RQConfig> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_monitoring.rqMonitorConfigRetrieve()
+  return RQConfigSchema.parse(response)
+}
+
+
+/**
+ * Health check
+ *
+ * @method GET
+ * @path /cfg/rq/monitor/health/
+ */
+export async function getRqMonitorHealthRetrieve(  client?: any
+): Promise<HealthCheck> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_monitoring.rqMonitorHealthRetrieve()
+  return HealthCheckSchema.parse(response)
+}
+
+
+/**
+ * Prometheus metrics
+ *
+ * @method GET
+ * @path /cfg/rq/monitor/metrics/
+ */
+export async function getRqMonitorMetricsRetrieve(  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_monitoring.rqMonitorMetricsRetrieve()
+  return response
+}
+
+

package/src/cfg/generated/_utils/fetchers/{cfg__dashboard.ts → cfg__rq__rq_queues.ts}

@@ -1,5 +1,5 @@
 /**
- * Typed fetchers for Dashboard
+ * Typed fetchers for RQ Queues
  *
  * Universal functions that work in any environment:
  * - Next.js (App Router / Pages Router / Server Components)
@@ -29,60 +29,61 @@
  * const users = await getUsers({ page: 1 }, api)
  * ```
  */
+import { QueueDetailSchema, type QueueDetail } from '../schemas/QueueDetail.schema'
 import { getAPIInstance } from '../../api-instance'
 
 /**
- * API operation
+ * List all queues
  *
  * @method GET
- * @path /cfg/dashboard/api/django_q2/
+ * @path /cfg/rq/queues/
  */
-export async function getDashboardApiDjangoQ2Retrieve(  client?: any
+export async function getRqQueuesList(  params?: { name?: string },  client?: any
 ): Promise<any> {
   const api = client || getAPIInstance()
-  const response = await api.cfg_dashboard.apiDjangoQ2Retrieve()
+  const response = await api.cfg_rq_queues.list(params?.name)
   return response
 }
 
 
 /**
- * API operation
+ * Get queue details
  *
  * @method GET
- * @path /cfg/dashboard/api/django_q2/schedules/
+ * @path /cfg/rq/queues/{id}/
  */
-export async function getDashboardApiDjangoQ2SchedulesRetrieve(  client?: any
-): Promise<any> {
+export async function getRqQueuesRetrieve(  id: string,  client?: any
+): Promise<QueueDetail> {
   const api = client || getAPIInstance()
-  const response = await api.cfg_dashboard.apiDjangoQ2SchedulesRetrieve()
-  return response
+  const response = await api.cfg_rq_queues.retrieve(id)
+  return QueueDetailSchema.parse(response)
 }
 
 
 /**
- * API operation
+ * Empty queue
  *
- * @method GET
- * @path /cfg/dashboard/api/django_q2/status/
+ * @method POST
+ * @path /cfg/rq/queues/{id}/empty/
  */
-export async function getDashboardApiDjangoQ2StatusRetrieve(  client?: any
+export async function createRqQueuesEmptyCreate(  id: string,  client?: any
 ): Promise<any> {
   const api = client || getAPIInstance()
-  const response = await api.cfg_dashboard.apiDjangoQ2StatusRetrieve()
+  const response = await api.cfg_rq_queues.emptyCreate(id)
   return response
 }
 
 
 /**
- * API operation
+ * Get queue jobs
  *
  * @method GET
- * @path /cfg/dashboard/api/django_q2/tasks/
+ * @path /cfg/rq/queues/{id}/jobs/
  */
-export async function getDashboardApiDjangoQ2TasksRetrieve(  client?: any
+export async function getRqQueuesJobsRetrieve(  id: string, params?: { limit?: number; offset?: number },  client?: any
 ): Promise<any> {
   const api = client || getAPIInstance()
-  const response = await api.cfg_dashboard.apiDjangoQ2TasksRetrieve()
+  const response = await api.cfg_rq_queues.jobsRetrieve(id, params?.limit, params?.offset)
   return response
 }
 

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

@@ -0,0 +1,132 @@
+/**
+ * Typed fetchers for RQ Registries
+ *
+ * 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 { JobActionResponseSchema, type JobActionResponse } from '../schemas/JobActionResponse.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * List deferred jobs
+ *
+ * @method GET
+ * @path /cfg/rq/jobs/registries/deferred/
+ */
+export async function getRqJobsRegistriesDeferredList(  params?: { queue?: string },  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_registries.rqJobsRegistriesDeferredList(params?.queue)
+  return response
+}
+
+
+/**
+ * List failed jobs
+ *
+ * @method GET
+ * @path /cfg/rq/jobs/registries/failed/
+ */
+export async function getRqJobsRegistriesFailedList(  params?: { queue?: string },  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_registries.rqJobsRegistriesFailedList(params?.queue)
+  return response
+}
+
+
+/**
+ * Clear failed jobs registry
+ *
+ * @method POST
+ * @path /cfg/rq/jobs/registries/failed/clear/
+ */
+export async function createRqJobsRegistriesFailedClearCreate(  params: { queue: string },  client?: any
+): Promise<JobActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_registries.rqJobsRegistriesFailedClearCreate(params.queue)
+  return JobActionResponseSchema.parse(response)
+}
+
+
+/**
+ * Requeue all failed jobs
+ *
+ * @method POST
+ * @path /cfg/rq/jobs/registries/failed/requeue-all/
+ */
+export async function createRqJobsRegistriesFailedRequeueAllCreate(  params: { queue: string },  client?: any
+): Promise<JobActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_registries.rqJobsRegistriesFailedRequeueAllCreate(params.queue)
+  return JobActionResponseSchema.parse(response)
+}
+
+
+/**
+ * List finished jobs
+ *
+ * @method GET
+ * @path /cfg/rq/jobs/registries/finished/
+ */
+export async function getRqJobsRegistriesFinishedList(  params?: { queue?: string },  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_registries.rqJobsRegistriesFinishedList(params?.queue)
+  return response
+}
+
+
+/**
+ * Clear finished jobs registry
+ *
+ * @method POST
+ * @path /cfg/rq/jobs/registries/finished/clear/
+ */
+export async function createRqJobsRegistriesFinishedClearCreate(  params: { queue: string },  client?: any
+): Promise<JobActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_registries.rqJobsRegistriesFinishedClearCreate(params.queue)
+  return JobActionResponseSchema.parse(response)
+}
+
+
+/**
+ * List started jobs
+ *
+ * @method GET
+ * @path /cfg/rq/jobs/registries/started/
+ */
+export async function getRqJobsRegistriesStartedList(  params?: { queue?: string },  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_registries.rqJobsRegistriesStartedList(params?.queue)
+  return response
+}
+
+

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

@@ -0,0 +1,92 @@
+/**
+ * Typed fetchers for RQ Schedules
+ *
+ * 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 { ScheduleActionResponseSchema, type ScheduleActionResponse } from '../schemas/ScheduleActionResponse.schema'
+import { ScheduleCreateRequestSchema, type ScheduleCreateRequest } from '../schemas/ScheduleCreateRequest.schema'
+import { ScheduledJobSchema, type ScheduledJob } from '../schemas/ScheduledJob.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * List scheduled jobs
+ *
+ * @method GET
+ * @path /cfg/rq/schedules/
+ */
+export async function getRqSchedulesList(  params?: { queue?: string },  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_schedules.list(params?.queue)
+  return response
+}
+
+
+/**
+ * Create scheduled job
+ *
+ * @method POST
+ * @path /cfg/rq/schedules/
+ */
+export async function createRqSchedulesCreate(  data: ScheduleCreateRequest,  client?: any
+): Promise<ScheduleActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_schedules.create(data)
+  return ScheduleActionResponseSchema.parse(response)
+}
+
+
+/**
+ * Get scheduled job details
+ *
+ * @method GET
+ * @path /cfg/rq/schedules/{id}/
+ */
+export async function getRqSchedulesRetrieve(  id: string, pk: string, params?: { queue?: string },  client?: any
+): Promise<ScheduledJob> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_schedules.retrieve(id, pk, params?.queue)
+  return ScheduledJobSchema.parse(response)
+}
+
+
+/**
+ * Cancel scheduled job
+ *
+ * @method DELETE
+ * @path /cfg/rq/schedules/{id}/
+ */
+export async function deleteRqSchedulesDestroy(  id: string, pk: string, params?: { queue?: string },  client?: any
+): Promise<ScheduleActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_schedules.destroy(id, pk, params?.queue)
+  return ScheduleActionResponseSchema.parse(response)
+}
+
+

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

@@ -0,0 +1,120 @@
+/**
+ * Typed fetchers for RQ Testing
+ *
+ * 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 { RunDemoRequestRequestSchema, type RunDemoRequestRequest } from '../schemas/RunDemoRequestRequest.schema'
+import { StressTestRequestRequestSchema, type StressTestRequestRequest } from '../schemas/StressTestRequestRequest.schema'
+import { TestingActionResponseSchema, type TestingActionResponse } from '../schemas/TestingActionResponse.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * List test scenarios
+ *
+ * @method GET
+ * @path /cfg/rq/testing/
+ */
+export async function getRqTestingList(  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_testing.list()
+  return response
+}
+
+
+/**
+ * Cleanup test jobs
+ *
+ * @method DELETE
+ * @path /cfg/rq/testing/cleanup/
+ */
+export async function deleteRqTestingCleanupDestroy(  params?: { delete_demo_jobs_only?: boolean; queue?: string; registries?: string },  client?: any
+): Promise<TestingActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_testing.cleanupDestroy(params?.delete_demo_jobs_only, params?.queue, params?.registries)
+  return TestingActionResponseSchema.parse(response)
+}
+
+
+/**
+ * Get test results
+ *
+ * @method GET
+ * @path /cfg/rq/testing/results/
+ */
+export async function getRqTestingResultsRetrieve(  params?: { queue?: string; scenario?: string },  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_testing.resultsRetrieve(params?.queue, params?.scenario)
+  return response
+}
+
+
+/**
+ * Run demo task
+ *
+ * @method POST
+ * @path /cfg/rq/testing/run-demo/
+ */
+export async function createRqTestingRunDemoCreate(  data: RunDemoRequestRequest,  client?: any
+): Promise<TestingActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_testing.runDemoCreate(data)
+  return TestingActionResponseSchema.parse(response)
+}
+
+
+/**
+ * Schedule demo tasks
+ *
+ * @method POST
+ * @path /cfg/rq/testing/schedule-demo/
+ */
+export async function createRqTestingScheduleDemoCreate(  data: any,  client?: any
+): Promise<TestingActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_testing.scheduleDemoCreate(data)
+  return TestingActionResponseSchema.parse(response)
+}
+
+
+/**
+ * Stress test
+ *
+ * @method POST
+ * @path /cfg/rq/testing/stress-test/
+ */
+export async function createRqTestingStressTestCreate(  data: StressTestRequestRequest,  client?: any
+): Promise<TestingActionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_testing.stressTestCreate(data)
+  return TestingActionResponseSchema.parse(response)
+}
+
+

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

@@ -0,0 +1,62 @@
+/**
+ * Typed fetchers for RQ Workers
+ *
+ * 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 { WorkerStatsSchema, type WorkerStats } from '../schemas/WorkerStats.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * List all workers
+ *
+ * @method GET
+ * @path /cfg/rq/workers/
+ */
+export async function getRqWorkersList(  params?: { queue?: string; state?: string },  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_workers.list(params?.queue, params?.state)
+  return response
+}
+
+
+/**
+ * Get worker statistics
+ *
+ * @method GET
+ * @path /cfg/rq/workers/stats/
+ */
+export async function getRqWorkersStatsRetrieve(  client?: any
+): Promise<WorkerStats> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_rq_workers.statsRetrieve()
+  return WorkerStatsSchema.parse(response)
+}
+
+