@djangocfg/api 1.2.18 → 1.2.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@djangocfg/api",
-  "version": "1.2.18",
+  "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.18",
+    "@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__grpc__grpc_monitoring.ts

@@ -0,0 +1,122 @@
+/**
+ * Typed fetchers for Grpc 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 { MethodListSchema, type MethodList } from '../schemas/MethodList.schema'
+import { OverviewStatsSchema, type OverviewStats } from '../schemas/OverviewStats.schema'
+import { RecentRequestsSchema, type RecentRequests } from '../schemas/RecentRequests.schema'
+import { ServiceListSchema, type ServiceList } from '../schemas/ServiceList.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * Get gRPC health status
+ *
+ * @method GET
+ * @path /cfg/grpc/monitor/health/
+ */
+export async function getGrpcMonitorHealthRetrieve(  client?: any
+): Promise<HealthCheck> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_monitoring.grpcMonitorHealthRetrieve()
+  return HealthCheckSchema.parse(response)
+}
+
+
+/**
+ * Get method statistics
+ *
+ * @method GET
+ * @path /cfg/grpc/monitor/methods/
+ */
+export async function getGrpcMonitorMethodsRetrieve(  params?: { hours?: number; service?: string },  client?: any
+): Promise<MethodList> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_monitoring.grpcMonitorMethodsRetrieve(params?.hours, params?.service)
+  return MethodListSchema.parse(response)
+}
+
+
+/**
+ * Get overview statistics
+ *
+ * @method GET
+ * @path /cfg/grpc/monitor/overview/
+ */
+export async function getGrpcMonitorOverviewRetrieve(  params?: { hours?: number },  client?: any
+): Promise<OverviewStats> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_monitoring.grpcMonitorOverviewRetrieve(params?.hours)
+  return OverviewStatsSchema.parse(response)
+}
+
+
+/**
+ * Get recent requests
+ *
+ * @method GET
+ * @path /cfg/grpc/monitor/requests/
+ */
+export async function getGrpcMonitorRequestsRetrieve(  params?: { count?: number; method?: string; offset?: number; service?: string; status?: string },  client?: any
+): Promise<RecentRequests> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_monitoring.grpcMonitorRequestsRetrieve(params?.count, params?.method, params?.offset, params?.service, params?.status)
+  return RecentRequestsSchema.parse(response)
+}
+
+
+/**
+ * Get service statistics
+ *
+ * @method GET
+ * @path /cfg/grpc/monitor/services/
+ */
+export async function getGrpcMonitorServicesRetrieve(  params?: { hours?: number },  client?: any
+): Promise<ServiceList> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_monitoring.grpcMonitorServicesRetrieve(params?.hours)
+  return ServiceListSchema.parse(response)
+}
+
+
+/**
+ * Get request timeline
+ *
+ * @method GET
+ * @path /cfg/grpc/monitor/timeline/
+ */
+export async function getGrpcMonitorTimelineRetrieve(  params?: { hours?: number; interval?: string },  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_monitoring.grpcMonitorTimelineRetrieve(params?.hours, params?.interval)
+  return response
+}
+
+

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)
+}
+
+