@djangocfg/api 1.2.21 → 1.2.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@djangocfg/api",
-  "version": "1.2.21",
+  "version": "1.2.23",
   "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.21",
+    "@djangocfg/typescript-config": "^1.2.23",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "tsup": "^8.5.0",

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

@@ -29,9 +29,9 @@
  * const users = await getUsers({ page: 1 }, api)
  * ```
  */
+import { CentrifugoOverviewStatsSchema, type CentrifugoOverviewStats } from '../schemas/CentrifugoOverviewStats.schema'
 import { ChannelListSchema, type ChannelList } from '../schemas/ChannelList.schema'
 import { HealthCheckSchema, type HealthCheck } from '../schemas/HealthCheck.schema'
-import { OverviewStatsSchema, type OverviewStats } from '../schemas/OverviewStats.schema'
 import { RecentPublishesSchema, type RecentPublishes } from '../schemas/RecentPublishes.schema'
 import { getAPIInstance } from '../../api-instance'
 
@@ -56,10 +56,10 @@ export async function getCentrifugoMonitorHealthRetrieve(  client?: any
  * @path /cfg/centrifugo/monitor/overview/
  */
 export async function getCentrifugoMonitorOverviewRetrieve(  params?: { hours?: number },  client?: any
-): Promise<OverviewStats> {
+): Promise<CentrifugoOverviewStats> {
   const api = client || getAPIInstance()
   const response = await api.cfg_centrifugo_monitoring.centrifugoMonitorOverviewRetrieve(params?.hours)
-  return OverviewStatsSchema.parse(response)
+  return CentrifugoOverviewStatsSchema.parse(response)
 }
 
 

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

@@ -0,0 +1,48 @@
+/**
+ * Typed fetchers for Dashboard - Config
+ *
+ * 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 { ConfigDataSchema, type ConfigData } from '../schemas/ConfigData.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * Get configuration data
+ *
+ * @method GET
+ * @path /cfg/dashboard/api/config/config/
+ */
+export async function getDashboardApiConfigConfigRetrieve(  client?: any
+): Promise<ConfigData> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_dashboard_config.dashboardApiConfigConfigRetrieve()
+  return ConfigDataSchema.parse(response)
+}
+
+

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

@@ -0,0 +1,138 @@
+/**
+ * Typed fetchers for Grpc Charts
+ *
+ * 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 { DashboardChartsSchema, type DashboardCharts } from '../schemas/DashboardCharts.schema'
+import { ErrorDistributionChartSchema, type ErrorDistributionChart } from '../schemas/ErrorDistributionChart.schema'
+import { RequestVolumeChartSchema, type RequestVolumeChart } from '../schemas/RequestVolumeChart.schema'
+import { ResponseTimeChartSchema, type ResponseTimeChart } from '../schemas/ResponseTimeChart.schema'
+import { ServerLifecycleChartSchema, type ServerLifecycleChart } from '../schemas/ServerLifecycleChart.schema'
+import { ServerUptimeChartSchema, type ServerUptimeChart } from '../schemas/ServerUptimeChart.schema'
+import { ServiceActivityChartSchema, type ServiceActivityChart } from '../schemas/ServiceActivityChart.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * Get all dashboard charts data
+ *
+ * @method GET
+ * @path /cfg/grpc/charts/dashboard/
+ */
+export async function getGrpcChartsDashboardRetrieve(  params?: { hours?: number },  client?: any
+): Promise<DashboardCharts> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_charts.dashboardRetrieve(params?.hours)
+  return DashboardChartsSchema.parse(response)
+}
+
+
+/**
+ * Get error distribution chart data
+ *
+ * @method GET
+ * @path /cfg/grpc/charts/error-distribution/
+ */
+export async function getGrpcChartsErrorDistributionRetrieve(  params?: { hours?: number },  client?: any
+): Promise<ErrorDistributionChart> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_charts.errorDistributionRetrieve(params?.hours)
+  return ErrorDistributionChartSchema.parse(response)
+}
+
+
+/**
+ * Get request volume chart data
+ *
+ * @method GET
+ * @path /cfg/grpc/charts/request-volume/
+ */
+export async function getGrpcChartsRequestVolumeRetrieve(  params?: { hours?: number },  client?: any
+): Promise<RequestVolumeChart> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_charts.requestVolumeRetrieve(params?.hours)
+  return RequestVolumeChartSchema.parse(response)
+}
+
+
+/**
+ * Get response time chart data
+ *
+ * @method GET
+ * @path /cfg/grpc/charts/response-time/
+ */
+export async function getGrpcChartsResponseTimeRetrieve(  params?: { hours?: number },  client?: any
+): Promise<ResponseTimeChart> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_charts.responseTimeRetrieve(params?.hours)
+  return ResponseTimeChartSchema.parse(response)
+}
+
+
+/**
+ * Get server lifecycle events
+ *
+ * @method GET
+ * @path /cfg/grpc/charts/server-lifecycle/
+ */
+export async function getGrpcChartsServerLifecycleRetrieve(  params?: { hours?: number },  client?: any
+): Promise<ServerLifecycleChart> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_charts.serverLifecycleRetrieve(params?.hours)
+  return ServerLifecycleChartSchema.parse(response)
+}
+
+
+/**
+ * Get server uptime chart data
+ *
+ * @method GET
+ * @path /cfg/grpc/charts/server-uptime/
+ */
+export async function getGrpcChartsServerUptimeRetrieve(  params?: { hours?: number },  client?: any
+): Promise<ServerUptimeChart> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_charts.serverUptimeRetrieve(params?.hours)
+  return ServerUptimeChartSchema.parse(response)
+}
+
+
+/**
+ * Get service activity chart data
+ *
+ * @method GET
+ * @path /cfg/grpc/charts/service-activity/
+ */
+export async function getGrpcChartsServiceActivityRetrieve(  params?: { hours?: number },  client?: any
+): Promise<ServiceActivityChart> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_charts.serviceActivityRetrieve(params?.hours)
+  return ServiceActivityChartSchema.parse(response)
+}
+
+

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

@@ -0,0 +1,63 @@
+/**
+ * Typed fetchers for Grpc Configuration
+ *
+ * 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 { GRPCConfigSchema, type GRPCConfig } from '../schemas/GRPCConfig.schema'
+import { GRPCServerInfoSchema, type GRPCServerInfo } from '../schemas/GRPCServerInfo.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * Get gRPC configuration
+ *
+ * @method GET
+ * @path /cfg/grpc/config/config/
+ */
+export async function getGrpcConfigConfigRetrieve(  client?: any
+): Promise<GRPCConfig> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_configuration.grpcConfigConfigRetrieve()
+  return GRPCConfigSchema.parse(response)
+}
+
+
+/**
+ * Get server information
+ *
+ * @method GET
+ * @path /cfg/grpc/config/server-info/
+ */
+export async function getGrpcConfigServerInfoRetrieve(  client?: any
+): Promise<GRPCServerInfo> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_configuration.grpcConfigServerInfoRetrieve()
+  return GRPCServerInfoSchema.parse(response)
+}
+
+

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

@@ -29,10 +29,10 @@
  * const users = await getUsers({ page: 1 }, api)
  * ```
  */
-import { HealthCheckSchema, type HealthCheck } from '../schemas/HealthCheck.schema'
+import { GRPCHealthCheckSchema, type GRPCHealthCheck } from '../schemas/GRPCHealthCheck.schema'
+import { GRPCOverviewStatsSchema, type GRPCOverviewStats } from '../schemas/GRPCOverviewStats.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 { RecentRequestSchema, type RecentRequest } from '../schemas/RecentRequest.schema'
 import { ServiceListSchema, type ServiceList } from '../schemas/ServiceList.schema'
 import { getAPIInstance } from '../../api-instance'
 
@@ -43,10 +43,10 @@ import { getAPIInstance } from '../../api-instance'
  * @path /cfg/grpc/monitor/health/
  */
 export async function getGrpcMonitorHealthRetrieve(  client?: any
-): Promise<HealthCheck> {
+): Promise<GRPCHealthCheck> {
   const api = client || getAPIInstance()
   const response = await api.cfg_grpc_monitoring.grpcMonitorHealthRetrieve()
-  return HealthCheckSchema.parse(response)
+  return GRPCHealthCheckSchema.parse(response)
 }
 
 
@@ -71,10 +71,10 @@ export async function getGrpcMonitorMethodsRetrieve(  params?: { hours?: number;
  * @path /cfg/grpc/monitor/overview/
  */
 export async function getGrpcMonitorOverviewRetrieve(  params?: { hours?: number },  client?: any
-): Promise<OverviewStats> {
+): Promise<GRPCOverviewStats> {
   const api = client || getAPIInstance()
   const response = await api.cfg_grpc_monitoring.grpcMonitorOverviewRetrieve(params?.hours)
-  return OverviewStatsSchema.parse(response)
+  return GRPCOverviewStatsSchema.parse(response)
 }
 
 
@@ -84,11 +84,11 @@ export async function getGrpcMonitorOverviewRetrieve(  params?: { hours?: number
  * @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> {
+export async function getGrpcMonitorRequestsRetrieve(  params?: { method?: string; service?: string; status?: string },  client?: any
+): Promise<RecentRequest> {
   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)
+  const response = await api.cfg_grpc_monitoring.grpcMonitorRequestsRetrieve(params?.method, params?.service, params?.status)
+  return RecentRequestSchema.parse(response)
 }
 
 

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

@@ -0,0 +1,77 @@
+/**
+ * Typed fetchers for Grpc Services
+ *
+ * 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 { ServiceDetailSchema, type ServiceDetail } from '../schemas/ServiceDetail.schema'
+import { ServiceMethodsSchema, type ServiceMethods } from '../schemas/ServiceMethods.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * List all services
+ *
+ * @method GET
+ * @path /cfg/grpc/services/
+ */
+export async function getGrpcServicesList(  params?: { hours?: number },  client?: any
+): Promise<any> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_services.list(params?.hours)
+  return response
+}
+
+
+/**
+ * Get service details
+ *
+ * @method GET
+ * @path /cfg/grpc/services/{id}/
+ */
+export async function getGrpcServicesRetrieve(  id: string, pk: string,  client?: any
+): Promise<ServiceDetail> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_services.retrieve(id, pk)
+  return ServiceDetailSchema.parse(response)
+}
+
+
+/**
+ * Get service methods
+ *
+ * @method GET
+ * @path /cfg/grpc/services/{id}/methods/
+ */
+export async function getGrpcServicesMethodsRetrieve(  id: string, pk: string,  client?: any
+): Promise<ServiceMethods> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_services.methodsRetrieve(id, pk)
+  return ServiceMethodsSchema.parse(response)
+}
+
+

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

@@ -0,0 +1,79 @@
+/**
+ * Typed fetchers for Grpc 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 { GRPCCallRequestRequestSchema, type GRPCCallRequestRequest } from '../schemas/GRPCCallRequestRequest.schema'
+import { GRPCCallResponseSchema, type GRPCCallResponse } from '../schemas/GRPCCallResponse.schema'
+import { GRPCExamplesListSchema, type GRPCExamplesList } from '../schemas/GRPCExamplesList.schema'
+import { GRPCTestLogSchema, type GRPCTestLog } from '../schemas/GRPCTestLog.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * Call gRPC method
+ *
+ * @method POST
+ * @path /cfg/grpc/test/call/
+ */
+export async function createGrpcTestCallCreate(  data: GRPCCallRequestRequest,  client?: any
+): Promise<GRPCCallResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_testing.grpcTestCallCreate(data)
+  return GRPCCallResponseSchema.parse(response)
+}
+
+
+/**
+ * Get example payloads
+ *
+ * @method GET
+ * @path /cfg/grpc/test/examples/
+ */
+export async function getGrpcTestExamplesRetrieve(  params?: { method?: string; service?: string },  client?: any
+): Promise<GRPCExamplesList> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_testing.grpcTestExamplesRetrieve(params?.method, params?.service)
+  return GRPCExamplesListSchema.parse(response)
+}
+
+
+/**
+ * Get test logs
+ *
+ * @method GET
+ * @path /cfg/grpc/test/logs/
+ */
+export async function getGrpcTestLogsRetrieve(  params?: { method?: string; service?: string; status?: string },  client?: any
+): Promise<GRPCTestLog> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_grpc_testing.grpcTestLogsRetrieve(params?.method, params?.service, params?.status)
+  return GRPCTestLogSchema.parse(response)
+}
+
+

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

@@ -36,11 +36,16 @@ export * from './cfg__dashboard__dashboard_activity'
 export * from './cfg__dashboard__dashboard_api_zones'
 export * from './cfg__dashboard__dashboard_charts'
 export * from './cfg__dashboard__dashboard_commands'
+export * from './cfg__dashboard__dashboard_config'
 export * from './cfg__dashboard__dashboard_overview'
 export * from './cfg__dashboard__dashboard_statistics'
 export * from './cfg__dashboard__dashboard_system'
 export * from './cfg__endpoints'
+export * from './cfg__grpc__grpc_charts'
+export * from './cfg__grpc__grpc_configuration'
 export * from './cfg__grpc__grpc_monitoring'
+export * from './cfg__grpc__grpc_services'
+export * from './cfg__grpc__grpc_testing'
 export * from './cfg__health'
 export * from './cfg__knowbase'
 export * from './cfg__leads'

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

@@ -18,9 +18,9 @@ import useSWR from 'swr'
 import { useSWRConfig } from 'swr'
 import * as Fetchers from '../fetchers/cfg__centrifugo__centrifugo_monitoring'
 import type { API } from '../../index'
+import type { CentrifugoOverviewStats } from '../schemas/CentrifugoOverviewStats.schema'
 import type { ChannelList } from '../schemas/ChannelList.schema'
 import type { HealthCheck } from '../schemas/HealthCheck.schema'
-import type { OverviewStats } from '../schemas/OverviewStats.schema'
 import type { RecentPublishes } from '../schemas/RecentPublishes.schema'
 
 /**
@@ -43,8 +43,8 @@ export function useCentrifugoMonitorHealthRetrieve(client?: API): ReturnType<typ
  * @method GET
  * @path /cfg/centrifugo/monitor/overview/
  */
-export function useCentrifugoMonitorOverviewRetrieve(params?: { hours?: number }, client?: API): ReturnType<typeof useSWR<OverviewStats>> {
-  return useSWR<OverviewStats>(
+export function useCentrifugoMonitorOverviewRetrieve(params?: { hours?: number }, client?: API): ReturnType<typeof useSWR<CentrifugoOverviewStats>> {
+  return useSWR<CentrifugoOverviewStats>(
     params ? ['cfg-centrifugo-monitor-overview', params] : 'cfg-centrifugo-monitor-overview',
     () => Fetchers.getCentrifugoMonitorOverviewRetrieve(params, client)
   )

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

@@ -0,0 +1,36 @@
+/**
+ * SWR Hooks for Dashboard - Config
+ *
+ * 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__dashboard__dashboard_config'
+import type { API } from '../../index'
+import type { ConfigData } from '../schemas/ConfigData.schema'
+
+/**
+ * Get configuration data
+ *
+ * @method GET
+ * @path /cfg/dashboard/api/config/config/
+ */
+export function useDashboardApiConfigConfigRetrieve(client?: API): ReturnType<typeof useSWR<ConfigData>> {
+  return useSWR<ConfigData>(
+    'cfg-dashboard-api-config-config',
+    () => Fetchers.getDashboardApiConfigConfigRetrieve(client)
+  )
+}
+
+