feat: add Job Monitor page with cron job logging and Selenium queue status

apps/Backend/src/cron/backupCheck.ts

@@ -3,6 +3,7 @@ import fs from "fs";
 import path from "path";
 import { storage } from "../storage";
 import { backupDatabaseToPath } from "../services/databaseBackupService";
+import { cronJobLogStorage } from "../storage/cron-job-log-storage";
 
 // Local backup folder in the app root (apps/Backend/backups)
 const LOCAL_BACKUP_DIR = path.resolve(process.cwd(), "backups");
@@ -45,17 +46,26 @@ export const startBackupCron = () => {
 
     if (!admin.autoBackupEnabled) {
       console.log("✅ [8 PM] Auto-backup is disabled for admin, skipped.");
+      const startedAt = new Date();
+      const log = await cronJobLogStorage.createJobLog("local-backup", startedAt);
+      await cronJobLogStorage.completeJobLog(log.id, "skipped", new Date());
       return;
     }
 
+    const startedAt = new Date();
+    const log = await cronJobLogStorage.createJobLog("local-backup", startedAt);
+
     try {
       const filename = `dental_backup_${Date.now()}.sql`;
       await backupDatabaseToPath({ destinationPath: LOCAL_BACKUP_DIR, filename });
       await storage.createBackup(admin.id);
       await storage.deleteNotificationsByType(admin.id, "BACKUP");
+      await cronJobLogStorage.completeJobLog(log.id, "success", new Date());
       console.log(`✅ Local backup done → ${filename}`);
     } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
       console.error("Local backup failed:", err);
+      await cronJobLogStorage.completeJobLog(log.id, "failed", new Date(), errorMessage);
       await storage.createNotification(
         admin.id,
         "BACKUP",
@@ -80,11 +90,19 @@ export const startBackupCron = () => {
 
     if (!admin.usbBackupEnabled) {
       console.log("✅ [9 PM] USB backup is disabled for admin, skipped.");
+      const startedAt = new Date();
+      const log = await cronJobLogStorage.createJobLog("usb-backup", startedAt);
+      await cronJobLogStorage.completeJobLog(log.id, "skipped", new Date());
       return;
     }
 
+    const startedAt = new Date();
+    const log = await cronJobLogStorage.createJobLog("usb-backup", startedAt);
+
     const destination = await storage.getActiveBackupDestination(admin.id);
     if (!destination) {
+      const errorMessage = "No backup destination configured.";
+      await cronJobLogStorage.completeJobLog(log.id, "failed", new Date(), errorMessage);
       await storage.createNotification(
         admin.id,
         "BACKUP",
@@ -96,6 +114,8 @@ export const startBackupCron = () => {
     const usbBackupPath = path.join(destination.path, USB_BACKUP_FOLDER_NAME);
 
     if (!fs.existsSync(usbBackupPath)) {
+      const errorMessage = `Folder "${USB_BACKUP_FOLDER_NAME}" not found on the drive.`;
+      await cronJobLogStorage.completeJobLog(log.id, "failed", new Date(), errorMessage);
       await storage.createNotification(
         admin.id,
         "BACKUP",
@@ -109,9 +129,12 @@ export const startBackupCron = () => {
       await backupDatabaseToPath({ destinationPath: usbBackupPath, filename });
       await storage.createBackup(admin.id);
       await storage.deleteNotificationsByType(admin.id, "BACKUP");
+      await cronJobLogStorage.completeJobLog(log.id, "success", new Date());
       console.log(`✅ USB backup done → ${usbBackupPath}/${filename}`);
     } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
       console.error("USB backup failed:", err);
+      await cronJobLogStorage.completeJobLog(log.id, "failed", new Date(), errorMessage);
       await storage.createNotification(
         admin.id,
         "BACKUP",

apps/Backend/src/routes/index.ts

@@ -19,6 +19,7 @@ import paymentOcrRoutes from "./paymentOcrExtraction";
 import cloudStorageRoutes from "./cloud-storage";
 import paymentsReportsRoutes from "./payments-reports";
 import exportPaymentsReportsRoutes from "./export-payments-reports";
+import jobMonitorRoutes from "./job-monitor";
 
 const router = Router();
 
@@ -42,5 +43,6 @@ router.use("/payment-ocr", paymentOcrRoutes);
 router.use("/cloud-storage", cloudStorageRoutes);
 router.use("/payments-reports", paymentsReportsRoutes);
 router.use("/export-payments-reports", exportPaymentsReportsRoutes);
+router.use("/job-monitor", jobMonitorRoutes);
 
 export default router;

apps/Backend/src/routes/job-monitor.ts

@@ -0,0 +1,51 @@
+import { Router, Request, Response } from "express";
+import axios from "axios";
+import { cronJobLogStorage } from "../storage/cron-job-log-storage";
+
+const router = Router();
+
+const SELENIUM_BASE_URL =
+  process.env.SELENIUM_AGENT_BASE_URL || "http://localhost:5002";
+
+// GET /api/job-monitor/summary
+// Returns last run per cron job + recent history
+router.get("/summary", async (_req: Request, res: Response) => {
+  try {
+    const [lastRuns, recentLogs] = await Promise.all([
+      cronJobLogStorage.getLastRunPerJob(),
+      cronJobLogStorage.getRecentLogs(30),
+    ]);
+    res.json({ lastRuns, recentLogs });
+  } catch (err) {
+    console.error("job-monitor/summary error:", err);
+    res.status(500).json({ error: "Failed to fetch cron job summary" });
+  }
+});
+
+// GET /api/job-monitor/failed
+// Returns recent failed job logs
+router.get("/failed", async (_req: Request, res: Response) => {
+  try {
+    const failed = await cronJobLogStorage.getFailedLogs(20);
+    res.json(failed);
+  } catch (err) {
+    console.error("job-monitor/failed error:", err);
+    res.status(500).json({ error: "Failed to fetch failed jobs" });
+  }
+});
+
+// GET /api/job-monitor/selenium-status
+// Proxies the Selenium service /status endpoint
+router.get("/selenium-status", async (_req: Request, res: Response) => {
+  try {
+    const response = await axios.get(`${SELENIUM_BASE_URL}/status`, {
+      timeout: 4000,
+    });
+    res.json({ online: true, ...response.data });
+  } catch (err) {
+    // Service may be offline — return gracefully
+    res.json({ online: false, active_jobs: 0, queued_jobs: 0, status: "offline" });
+  }
+});
+
+export default router;

apps/Backend/src/storage/cron-job-log-storage.ts

@@ -0,0 +1,61 @@
+import { prisma as db } from "@repo/db/client";
+
+export type CronJobStatus = "success" | "failed" | "skipped";
+
+export interface CronJobLogEntry {
+  id: number;
+  jobName: string;
+  status: string;
+  startedAt: Date;
+  completedAt: Date | null;
+  durationMs: number | null;
+  errorMessage: string | null;
+}
+
+export const cronJobLogStorage = {
+  async createJobLog(
+    jobName: string,
+    startedAt: Date
+  ): Promise<CronJobLogEntry> {
+    return db.cronJobLog.create({
+      data: { jobName, status: "running", startedAt },
+    });
+  },
+
+  async completeJobLog(
+    id: number,
+    status: CronJobStatus,
+    completedAt: Date,
+    errorMessage?: string
+  ): Promise<CronJobLogEntry> {
+    const durationMs = completedAt.getTime() - (await db.cronJobLog.findUniqueOrThrow({ where: { id } })).startedAt.getTime();
+    return db.cronJobLog.update({
+      where: { id },
+      data: { status, completedAt, durationMs, errorMessage: errorMessage ?? null },
+    });
+  },
+
+  async getRecentLogs(limit = 50): Promise<CronJobLogEntry[]> {
+    return db.cronJobLog.findMany({
+      orderBy: { startedAt: "desc" },
+      take: limit,
+    });
+  },
+
+  async getLastRunPerJob(): Promise<CronJobLogEntry[]> {
+    // Get the most recent log entry for each distinct jobName
+    const jobs = await db.cronJobLog.findMany({
+      distinct: ["jobName"],
+      orderBy: { startedAt: "desc" },
+    });
+    return jobs;
+  },
+
+  async getFailedLogs(limit = 20): Promise<CronJobLogEntry[]> {
+    return db.cronJobLog.findMany({
+      where: { status: "failed" },
+      orderBy: { startedAt: "desc" },
+      take: limit,
+    });
+  },
+};

apps/Backend/src/storage/index.ts

@@ -16,6 +16,7 @@ import { cloudStorageStorage } from './cloudStorage-storage';
 import { paymentsReportsStorage } from './payments-reports-storage';
 import { patientDocumentsStorage } from './patientDocuments-storage';
 import * as exportPaymentsReportsStorage from "./export-payments-reports-storage";
+import { cronJobLogStorage } from "./cron-job-log-storage";
 
 
 export const storage = {
@@ -34,7 +35,8 @@ export const storage = {
   ...cloudStorageStorage,
   ...paymentsReportsStorage,
   ...patientDocumentsStorage,
-  ...exportPaymentsReportsStorage, 
+  ...exportPaymentsReportsStorage,
+  ...cronJobLogStorage,
 
 };
 

apps/Frontend/src/App.tsx

@@ -27,6 +27,7 @@ const DatabaseManagementPage = lazy(
 );
 const ReportsPage = lazy(() => import("./pages/reports-page"));
 const CloudStoragePage = lazy(() => import("./pages/cloud-storage-page"));
+const JobMonitorPage = lazy(() => import("./pages/job-monitor-page"));
 const NotFound = lazy(() => import("./pages/not-found"));
 
 function Router() {
@@ -56,6 +57,11 @@ function Router() {
       />
       <ProtectedRoute path="/reports" component={() => <ReportsPage />} />
       <ProtectedRoute path="/cloud-storage" component={() => <CloudStoragePage />} />
+      <ProtectedRoute
+        path="/job-monitor"
+        component={() => <JobMonitorPage />}
+        adminOnly
+      />
       <Route path="/auth" component={() => <AuthPage />} />
       <Route component={() => <NotFound />} />
     </Switch>

apps/Frontend/src/components/layout/sidebar.tsx

@@ -12,6 +12,7 @@ import {
   FileText,
   Cloud,
   Phone,
+  Activity,
 } from "lucide-react";
 import { cn } from "@/lib/utils";
 import { useMemo } from "react";
@@ -82,6 +83,12 @@ export function Sidebar() {
         icon: <Database className="h-5 w-5" />,
         adminOnly: true,
       },
+      {
+        name: "Job Monitor",
+        path: "/job-monitor",
+        icon: <Activity className="h-5 w-5" />,
+        adminOnly: true,
+      },
       {
         name: "Settings",
         path: "/settings",

apps/Frontend/src/pages/job-monitor-page.tsx

@@ -0,0 +1,384 @@
+import { useQuery } from "@tanstack/react-query";
+import { apiRequest } from "@/lib/queryClient";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Activity,
+  AlertTriangle,
+  CheckCircle2,
+  Clock,
+  RefreshCw,
+  ServerCrash,
+  SkipForward,
+  Wifi,
+  WifiOff,
+} from "lucide-react";
+import { formatDistanceToNow, format } from "date-fns";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+interface CronJobLog {
+  id: number;
+  jobName: string;
+  status: string;
+  startedAt: string;
+  completedAt: string | null;
+  durationMs: number | null;
+  errorMessage: string | null;
+}
+
+interface CronSummary {
+  lastRuns: CronJobLog[];
+  recentLogs: CronJobLog[];
+}
+
+interface SeleniumStatus {
+  online: boolean;
+  active_jobs: number;
+  queued_jobs: number;
+  status: string;
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+const JOB_LABELS: Record<string, string> = {
+  "local-backup": "Local Backup (8 PM)",
+  "usb-backup": "USB Backup (9 PM)",
+};
+
+function jobLabel(name: string) {
+  return JOB_LABELS[name] ?? name;
+}
+
+function StatusBadge({ status }: { status: string }) {
+  if (status === "success")
+    return (
+      <Badge className="bg-green-100 text-green-700 border-green-200 gap-1">
+        <CheckCircle2 className="h-3 w-3" /> Success
+      </Badge>
+    );
+  if (status === "failed")
+    return (
+      <Badge className="bg-red-100 text-red-700 border-red-200 gap-1">
+        <ServerCrash className="h-3 w-3" /> Failed
+      </Badge>
+    );
+  if (status === "skipped")
+    return (
+      <Badge className="bg-gray-100 text-gray-600 border-gray-200 gap-1">
+        <SkipForward className="h-3 w-3" /> Skipped
+      </Badge>
+    );
+  return (
+    <Badge className="bg-blue-100 text-blue-700 border-blue-200 gap-1">
+      <Activity className="h-3 w-3 animate-pulse" /> Running
+    </Badge>
+  );
+}
+
+function formatDuration(ms: number | null) {
+  if (ms === null) return "—";
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function formatDate(iso: string | null) {
+  if (!iso) return "—";
+  return format(new Date(iso), "MMM d, yyyy HH:mm:ss");
+}
+
+function timeAgo(iso: string | null) {
+  if (!iso) return "—";
+  return formatDistanceToNow(new Date(iso), { addSuffix: true });
+}
+
+// ─── Page ─────────────────────────────────────────────────────────────────────
+
+export default function JobMonitorPage() {
+  const {
+    data: summary,
+    isLoading: loadingSummary,
+    refetch: refetchSummary,
+    dataUpdatedAt: summaryUpdated,
+  } = useQuery<CronSummary>({
+    queryKey: ["/job-monitor/summary"],
+    queryFn: async () => {
+      const res = await apiRequest("GET", "/api/job-monitor/summary");
+      return res.json();
+    },
+    refetchInterval: 30_000,
+  });
+
+  const {
+    data: failed,
+    isLoading: loadingFailed,
+    refetch: refetchFailed,
+  } = useQuery<CronJobLog[]>({
+    queryKey: ["/job-monitor/failed"],
+    queryFn: async () => {
+      const res = await apiRequest("GET", "/api/job-monitor/failed");
+      return res.json();
+    },
+    refetchInterval: 30_000,
+  });
+
+  const {
+    data: seleniumStatus,
+    isLoading: loadingSelenium,
+    refetch: refetchSelenium,
+  } = useQuery<SeleniumStatus>({
+    queryKey: ["/job-monitor/selenium-status"],
+    queryFn: async () => {
+      const res = await apiRequest("GET", "/api/job-monitor/selenium-status");
+      return res.json();
+    },
+    refetchInterval: 10_000,
+  });
+
+  function refreshAll() {
+    refetchSummary();
+    refetchFailed();
+    refetchSelenium();
+  }
+
+  const lastUpdated = summaryUpdated
+    ? format(new Date(summaryUpdated), "HH:mm:ss")
+    : null;
+
+  return (
+    <div className="p-6 max-w-5xl mx-auto space-y-6">
+      {/* Header */}
+      <div className="flex items-center justify-between">
+        <div>
+          <h1 className="text-2xl font-semibold text-gray-900">Job Monitor</h1>
+          <p className="text-sm text-gray-500 mt-0.5">
+            Background job health and queue status
+            {lastUpdated && (
+              <span className="ml-2 text-gray-400">· last updated {lastUpdated}</span>
+            )}
+          </p>
+        </div>
+        <Button
+          variant="outline"
+          size="sm"
+          onClick={refreshAll}
+          className="gap-1.5"
+        >
+          <RefreshCw className="h-4 w-4" />
+          Refresh
+        </Button>
+      </div>
+
+      {/* ── Cron Jobs ── */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base flex items-center gap-2">
+            <Clock className="h-4 w-4 text-gray-500" />
+            Scheduled Cron Jobs
+          </CardTitle>
+        </CardHeader>
+        <CardContent>
+          {loadingSummary ? (
+            <p className="text-sm text-gray-400">Loading…</p>
+          ) : !summary?.lastRuns.length ? (
+            <p className="text-sm text-gray-500">
+              No job runs recorded yet. Jobs are scheduled at 8 PM (local backup) and 9 PM (USB backup).
+            </p>
+          ) : (
+            <div className="space-y-3">
+              {summary.lastRuns.map((log) => (
+                <div
+                  key={log.id}
+                  className="flex items-start justify-between rounded-lg border border-gray-100 bg-gray-50 px-4 py-3"
+                >
+                  <div className="space-y-0.5">
+                    <p className="text-sm font-medium text-gray-800">
+                      {jobLabel(log.jobName)}
+                    </p>
+                    <p className="text-xs text-gray-500">
+                      Last run: {formatDate(log.startedAt)}{" "}
+                      <span className="text-gray-400">({timeAgo(log.startedAt)})</span>
+                    </p>
+                    {log.status === "failed" && log.errorMessage && (
+                      <p className="text-xs text-red-600 mt-1 flex items-center gap-1">
+                        <AlertTriangle className="h-3 w-3 shrink-0" />
+                        {log.errorMessage}
+                      </p>
+                    )}
+                  </div>
+                  <div className="flex flex-col items-end gap-1">
+                    <StatusBadge status={log.status} />
+                    <span className="text-xs text-gray-400">
+                      {formatDuration(log.durationMs)}
+                    </span>
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+
+      {/* ── Selenium Queue ── */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base flex items-center gap-2">
+            {seleniumStatus?.online ? (
+              <Wifi className="h-4 w-4 text-green-500" />
+            ) : (
+              <WifiOff className="h-4 w-4 text-gray-400" />
+            )}
+            Selenium Job Queue
+          </CardTitle>
+        </CardHeader>
+        <CardContent>
+          {loadingSelenium ? (
+            <p className="text-sm text-gray-400">Loading…</p>
+          ) : (
+            <div className="grid grid-cols-3 gap-4">
+              {/* Online status */}
+              <div className="rounded-lg border border-gray-100 bg-gray-50 px-4 py-3 text-center">
+                <p className="text-xs text-gray-500 mb-1">Service</p>
+                {seleniumStatus?.online ? (
+                  <span className="inline-flex items-center gap-1 text-sm font-medium text-green-700">
+                    <CheckCircle2 className="h-4 w-4" /> Online
+                  </span>
+                ) : (
+                  <span className="inline-flex items-center gap-1 text-sm font-medium text-gray-500">
+                    <WifiOff className="h-4 w-4" /> Offline
+                  </span>
+                )}
+              </div>
+
+              {/* Active jobs */}
+              <div className="rounded-lg border border-gray-100 bg-gray-50 px-4 py-3 text-center">
+                <p className="text-xs text-gray-500 mb-1">Active Jobs</p>
+                <p
+                  className={`text-2xl font-bold ${
+                    (seleniumStatus?.active_jobs ?? 0) > 0
+                      ? "text-blue-600"
+                      : "text-gray-700"
+                  }`}
+                >
+                  {seleniumStatus?.active_jobs ?? 0}
+                </p>
+              </div>
+
+              {/* Queued jobs */}
+              <div className="rounded-lg border border-gray-100 bg-gray-50 px-4 py-3 text-center">
+                <p className="text-xs text-gray-500 mb-1">Queued</p>
+                <p
+                  className={`text-2xl font-bold ${
+                    (seleniumStatus?.queued_jobs ?? 0) > 0
+                      ? "text-amber-600"
+                      : "text-gray-700"
+                  }`}
+                >
+                  {seleniumStatus?.queued_jobs ?? 0}
+                </p>
+              </div>
+            </div>
+          )}
+        </CardContent>
+      </Card>
+
+      {/* ── Failed Alerts ── */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base flex items-center gap-2">
+            <AlertTriangle className="h-4 w-4 text-red-500" />
+            Failed Job Alerts
+            {!loadingFailed && failed && failed.length > 0 && (
+              <Badge className="bg-red-100 text-red-700 border-red-200 ml-1">
+                {failed.length}
+              </Badge>
+            )}
+          </CardTitle>
+        </CardHeader>
+        <CardContent>
+          {loadingFailed ? (
+            <p className="text-sm text-gray-400">Loading…</p>
+          ) : !failed?.length ? (
+            <div className="flex items-center gap-2 text-sm text-green-700">
+              <CheckCircle2 className="h-4 w-4" />
+              No failed jobs — everything looks healthy.
+            </div>
+          ) : (
+            <div className="space-y-2">
+              {failed.map((log) => (
+                <div
+                  key={log.id}
+                  className="rounded-lg border border-red-100 bg-red-50 px-4 py-3"
+                >
+                  <div className="flex items-center justify-between mb-1">
+                    <span className="text-sm font-medium text-red-800">
+                      {jobLabel(log.jobName)}
+                    </span>
+                    <span className="text-xs text-gray-500">
+                      {formatDate(log.startedAt)}
+                    </span>
+                  </div>
+                  {log.errorMessage && (
+                    <p className="text-xs text-red-600">{log.errorMessage}</p>
+                  )}
+                </div>
+              ))}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+
+      {/* ── Recent History ── */}
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base flex items-center gap-2">
+            <Activity className="h-4 w-4 text-gray-500" />
+            Recent Run History
+          </CardTitle>
+        </CardHeader>
+        <CardContent>
+          {loadingSummary ? (
+            <p className="text-sm text-gray-400">Loading…</p>
+          ) : !summary?.recentLogs.length ? (
+            <p className="text-sm text-gray-500">No history yet.</p>
+          ) : (
+            <div className="overflow-x-auto">
+              <table className="w-full text-sm">
+                <thead>
+                  <tr className="border-b text-xs text-gray-500 uppercase tracking-wide">
+                    <th className="text-left py-2 pr-4 font-medium">Job</th>
+                    <th className="text-left py-2 pr-4 font-medium">Started</th>
+                    <th className="text-left py-2 pr-4 font-medium">Duration</th>
+                    <th className="text-left py-2 font-medium">Status</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {summary.recentLogs.map((log) => (
+                    <tr
+                      key={log.id}
+                      className="border-b border-gray-50 last:border-0 hover:bg-gray-50 transition-colors"
+                    >
+                      <td className="py-2 pr-4 font-medium text-gray-700">
+                        {jobLabel(log.jobName)}
+                      </td>
+                      <td className="py-2 pr-4 text-gray-500">
+                        {formatDate(log.startedAt)}
+                      </td>
+                      <td className="py-2 pr-4 text-gray-500">
+                        {formatDuration(log.durationMs)}
+                      </td>
+                      <td className="py-2">
+                        <StatusBadge status={log.status} />
+                      </td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

packages/db/generated/prisma/index-browser.js

@@ -323,6 +323,16 @@ exports.Prisma.NotificationScalarFieldEnum = {
   read: 'read'
 };
 
+exports.Prisma.CronJobLogScalarFieldEnum = {
+  id: 'id',
+  jobName: 'jobName',
+  status: 'status',
+  startedAt: 'startedAt',
+  completedAt: 'completedAt',
+  durationMs: 'durationMs',
+  errorMessage: 'errorMessage'
+};
+
 exports.Prisma.CloudFolderScalarFieldEnum = {
   id: 'id',
   userId: 'userId',
@@ -508,6 +518,7 @@ exports.Prisma.ModelName = {
   DatabaseBackup: 'DatabaseBackup',
   BackupDestination: 'BackupDestination',
   Notification: 'Notification',
+  CronJobLog: 'CronJobLog',
   CloudFolder: 'CloudFolder',
   CloudFile: 'CloudFile',
   CloudFileChunk: 'CloudFileChunk',

packages/db/generated/prisma/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "prisma-client-246293e720df1adf8730b52510e5dd3a44f079859a3249054c7cc8bdf2e0739c",
+  "name": "prisma-client-4bc6ced9b73ff651becdfed4e68ae8090595ad6cc91677c4e986b059be8d6d3b",
   "main": "index.js",
   "types": "index.d.ts",
   "browser": "default.js",

packages/db/generated/prisma/schema.prisma

@@ -399,6 +399,21 @@ enum NotificationTypes {
   ETC
 }
 
+// Cron job execution log
+model CronJobLog {
+  id           Int       @id @default(autoincrement())
+  jobName      String // e.g. "local-backup", "usb-backup"
+  status       String // "success" | "failed" | "skipped"
+  startedAt    DateTime
+  completedAt  DateTime?
+  durationMs   Int?
+  errorMessage String?
+
+  @@index([jobName])
+  @@index([startedAt])
+  @@index([status])
+}
+
 model CloudFolder {
   id        Int           @id @default(autoincrement())
   userId    Int

packages/db/prisma/schema.prisma

@@ -400,6 +400,21 @@ enum NotificationTypes {
   ETC
 }
 
+// Cron job execution log
+model CronJobLog {
+  id           Int       @id @default(autoincrement())
+  jobName      String    // e.g. "local-backup", "usb-backup"
+  status       String    // "success" | "failed" | "skipped"
+  startedAt    DateTime
+  completedAt  DateTime?
+  durationMs   Int?
+  errorMessage String?
+
+  @@index([jobName])
+  @@index([startedAt])
+  @@index([status])
+}
+
 model CloudFolder {
   id        Int           @id @default(autoincrement())
   userId    Int

packages/db/shared/.prisma-zod-generator-manifest.json

@@ -1,7 +1,7 @@
 {
   "version": "1.0",
   "generatorVersion": "1.0.0",
-  "generatedAt": "2026-04-11T03:16:27.200Z",
+  "generatedAt": "2026-04-13T03:50:09.276Z",
   "outputPath": "/home/ff/Desktop/DentalManagementMHAprilgg/packages/db/shared",
   "files": [
     "schemas/enums/TransactionIsolationLevel.schema.ts",
@@ -22,6 +22,7 @@
     "schemas/enums/DatabaseBackupScalarFieldEnum.schema.ts",
     "schemas/enums/BackupDestinationScalarFieldEnum.schema.ts",
     "schemas/enums/NotificationScalarFieldEnum.schema.ts",
+    "schemas/enums/CronJobLogScalarFieldEnum.schema.ts",
     "schemas/enums/CloudFolderScalarFieldEnum.schema.ts",
     "schemas/enums/CloudFileScalarFieldEnum.schema.ts",
     "schemas/enums/CloudFileChunkScalarFieldEnum.schema.ts",
@@ -129,6 +130,11 @@
     "schemas/objects/NotificationWhereUniqueInput.schema.ts",
     "schemas/objects/NotificationOrderByWithAggregationInput.schema.ts",
     "schemas/objects/NotificationScalarWhereWithAggregatesInput.schema.ts",
+    "schemas/objects/CronJobLogWhereInput.schema.ts",
+    "schemas/objects/CronJobLogOrderByWithRelationInput.schema.ts",
+    "schemas/objects/CronJobLogWhereUniqueInput.schema.ts",
+    "schemas/objects/CronJobLogOrderByWithAggregationInput.schema.ts",
+    "schemas/objects/CronJobLogScalarWhereWithAggregatesInput.schema.ts",
     "schemas/objects/CloudFolderWhereInput.schema.ts",
     "schemas/objects/CloudFolderOrderByWithRelationInput.schema.ts",
     "schemas/objects/CloudFolderWhereUniqueInput.schema.ts",
@@ -273,6 +279,13 @@
     "schemas/objects/NotificationCreateManyInput.schema.ts",
     "schemas/objects/NotificationUpdateManyMutationInput.schema.ts",
     "schemas/objects/NotificationUncheckedUpdateManyInput.schema.ts",
+    "schemas/objects/CronJobLogCreateInput.schema.ts",
+    "schemas/objects/CronJobLogUncheckedCreateInput.schema.ts",
+    "schemas/objects/CronJobLogUpdateInput.schema.ts",
+    "schemas/objects/CronJobLogUncheckedUpdateInput.schema.ts",
+    "schemas/objects/CronJobLogCreateManyInput.schema.ts",
+    "schemas/objects/CronJobLogUpdateManyMutationInput.schema.ts",
+    "schemas/objects/CronJobLogUncheckedUpdateManyInput.schema.ts",
     "schemas/objects/CloudFolderCreateInput.schema.ts",
     "schemas/objects/CloudFolderUncheckedCreateInput.schema.ts",
     "schemas/objects/CloudFolderUpdateInput.schema.ts",
@@ -485,6 +498,13 @@
     "schemas/objects/NotificationMinOrderByAggregateInput.schema.ts",
     "schemas/objects/NotificationSumOrderByAggregateInput.schema.ts",
     "schemas/objects/EnumNotificationTypesWithAggregatesFilter.schema.ts",
+    "schemas/objects/DateTimeNullableFilter.schema.ts",
+    "schemas/objects/CronJobLogCountOrderByAggregateInput.schema.ts",
+    "schemas/objects/CronJobLogAvgOrderByAggregateInput.schema.ts",
+    "schemas/objects/CronJobLogMaxOrderByAggregateInput.schema.ts",
+    "schemas/objects/CronJobLogMinOrderByAggregateInput.schema.ts",
+    "schemas/objects/CronJobLogSumOrderByAggregateInput.schema.ts",
+    "schemas/objects/DateTimeNullableWithAggregatesFilter.schema.ts",
     "schemas/objects/CloudFolderNullableScalarRelationFilter.schema.ts",
     "schemas/objects/CloudFolderUserIdParentIdNameCompoundUniqueInput.schema.ts",
     "schemas/objects/CloudFolderCountOrderByAggregateInput.schema.ts",
@@ -718,6 +738,7 @@
     "schemas/objects/UserCreateNestedOneWithoutNotificationsInput.schema.ts",
     "schemas/objects/EnumNotificationTypesFieldUpdateOperationsInput.schema.ts",
     "schemas/objects/UserUpdateOneRequiredWithoutNotificationsNestedInput.schema.ts",
+    "schemas/objects/NullableDateTimeFieldUpdateOperationsInput.schema.ts",
     "schemas/objects/CloudFolderCreateNestedOneWithoutChildrenInput.schema.ts",
     "schemas/objects/CloudFolderCreateNestedManyWithoutParentInput.schema.ts",
     "schemas/objects/UserCreateNestedOneWithoutCloudFoldersInput.schema.ts",
@@ -789,6 +810,8 @@
     "schemas/objects/NestedEnumPaymentMethodWithAggregatesFilter.schema.ts",
     "schemas/objects/NestedEnumNotificationTypesFilter.schema.ts",
     "schemas/objects/NestedEnumNotificationTypesWithAggregatesFilter.schema.ts",
+    "schemas/objects/NestedDateTimeNullableFilter.schema.ts",
+    "schemas/objects/NestedDateTimeNullableWithAggregatesFilter.schema.ts",
     "schemas/objects/NestedBigIntFilter.schema.ts",
     "schemas/objects/NestedBigIntWithAggregatesFilter.schema.ts",
     "schemas/objects/NestedEnumCommunicationChannelFilter.schema.ts",
@@ -1511,6 +1534,11 @@
     "schemas/objects/NotificationSumAggregateInput.schema.ts",
     "schemas/objects/NotificationMinAggregateInput.schema.ts",
     "schemas/objects/NotificationMaxAggregateInput.schema.ts",
+    "schemas/objects/CronJobLogCountAggregateInput.schema.ts",
+    "schemas/objects/CronJobLogAvgAggregateInput.schema.ts",
+    "schemas/objects/CronJobLogSumAggregateInput.schema.ts",
+    "schemas/objects/CronJobLogMinAggregateInput.schema.ts",
+    "schemas/objects/CronJobLogMaxAggregateInput.schema.ts",
     "schemas/objects/CloudFolderCountAggregateInput.schema.ts",
     "schemas/objects/CloudFolderAvgAggregateInput.schema.ts",
     "schemas/objects/CloudFolderSumAggregateInput.schema.ts",
@@ -1606,6 +1634,7 @@
     "schemas/objects/DatabaseBackupSelect.schema.ts",
     "schemas/objects/BackupDestinationSelect.schema.ts",
     "schemas/objects/NotificationSelect.schema.ts",
+    "schemas/objects/CronJobLogSelect.schema.ts",
     "schemas/objects/CloudFolderSelect.schema.ts",
     "schemas/objects/CloudFileSelect.schema.ts",
     "schemas/objects/CloudFileChunkSelect.schema.ts",
@@ -1628,6 +1657,7 @@
     "schemas/objects/DatabaseBackupArgs.schema.ts",
     "schemas/objects/BackupDestinationArgs.schema.ts",
     "schemas/objects/NotificationArgs.schema.ts",
+    "schemas/objects/CronJobLogArgs.schema.ts",
     "schemas/objects/CloudFolderArgs.schema.ts",
     "schemas/objects/CloudFileArgs.schema.ts",
     "schemas/objects/CloudFileChunkArgs.schema.ts",
@@ -1944,6 +1974,23 @@
     "schemas/upsertOneNotification.schema.ts",
     "schemas/aggregateNotification.schema.ts",
     "schemas/groupByNotification.schema.ts",
+    "schemas/findUniqueCronJobLog.schema.ts",
+    "schemas/findUniqueOrThrowCronJobLog.schema.ts",
+    "schemas/findFirstCronJobLog.schema.ts",
+    "schemas/findFirstOrThrowCronJobLog.schema.ts",
+    "schemas/findManyCronJobLog.schema.ts",
+    "schemas/countCronJobLog.schema.ts",
+    "schemas/createOneCronJobLog.schema.ts",
+    "schemas/createManyCronJobLog.schema.ts",
+    "schemas/createManyAndReturnCronJobLog.schema.ts",
+    "schemas/deleteOneCronJobLog.schema.ts",
+    "schemas/deleteManyCronJobLog.schema.ts",
+    "schemas/updateOneCronJobLog.schema.ts",
+    "schemas/updateManyCronJobLog.schema.ts",
+    "schemas/updateManyAndReturnCronJobLog.schema.ts",
+    "schemas/upsertOneCronJobLog.schema.ts",
+    "schemas/aggregateCronJobLog.schema.ts",
+    "schemas/groupByCronJobLog.schema.ts",
     "schemas/findUniqueCloudFolder.schema.ts",
     "schemas/findUniqueOrThrowCloudFolder.schema.ts",
     "schemas/findFirstCloudFolder.schema.ts",
@@ -2250,6 +2297,19 @@
     "schemas/results/NotificationAggregateResult.schema.ts",
     "schemas/results/NotificationGroupByResult.schema.ts",
     "schemas/results/NotificationCountResult.schema.ts",
+    "schemas/results/CronJobLogFindUniqueResult.schema.ts",
+    "schemas/results/CronJobLogFindFirstResult.schema.ts",
+    "schemas/results/CronJobLogFindManyResult.schema.ts",
+    "schemas/results/CronJobLogCreateResult.schema.ts",
+    "schemas/results/CronJobLogCreateManyResult.schema.ts",
+    "schemas/results/CronJobLogUpdateResult.schema.ts",
+    "schemas/results/CronJobLogUpdateManyResult.schema.ts",
+    "schemas/results/CronJobLogUpsertResult.schema.ts",
+    "schemas/results/CronJobLogDeleteResult.schema.ts",
+    "schemas/results/CronJobLogDeleteManyResult.schema.ts",
+    "schemas/results/CronJobLogAggregateResult.schema.ts",
+    "schemas/results/CronJobLogGroupByResult.schema.ts",
+    "schemas/results/CronJobLogCountResult.schema.ts",
     "schemas/results/CloudFolderFindUniqueResult.schema.ts",
     "schemas/results/CloudFolderFindFirstResult.schema.ts",
     "schemas/results/CloudFolderFindManyResult.schema.ts",
@@ -2334,6 +2394,7 @@
     "schemas/variants/pure/DatabaseBackup.pure.ts",
     "schemas/variants/pure/BackupDestination.pure.ts",
     "schemas/variants/pure/Notification.pure.ts",
+    "schemas/variants/pure/CronJobLog.pure.ts",
     "schemas/variants/pure/CloudFolder.pure.ts",
     "schemas/variants/pure/CloudFile.pure.ts",
     "schemas/variants/pure/CloudFileChunk.pure.ts",
@@ -2357,6 +2418,7 @@
     "schemas/variants/input/DatabaseBackup.input.ts",
     "schemas/variants/input/BackupDestination.input.ts",
     "schemas/variants/input/Notification.input.ts",
+    "schemas/variants/input/CronJobLog.input.ts",
     "schemas/variants/input/CloudFolder.input.ts",
     "schemas/variants/input/CloudFile.input.ts",
     "schemas/variants/input/CloudFileChunk.input.ts",
@@ -2380,6 +2442,7 @@
     "schemas/variants/result/DatabaseBackup.result.ts",
     "schemas/variants/result/BackupDestination.result.ts",
     "schemas/variants/result/Notification.result.ts",
+    "schemas/variants/result/CronJobLog.result.ts",
     "schemas/variants/result/CloudFolder.result.ts",
     "schemas/variants/result/CloudFile.result.ts",
     "schemas/variants/result/CloudFileChunk.result.ts",

packages/db/shared/schemas/aggregateCronJobLog.schema.ts

@@ -0,0 +1,14 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogOrderByWithRelationInputObjectSchema as CronJobLogOrderByWithRelationInputObjectSchema } from './objects/CronJobLogOrderByWithRelationInput.schema';
+import { CronJobLogWhereInputObjectSchema as CronJobLogWhereInputObjectSchema } from './objects/CronJobLogWhereInput.schema';
+import { CronJobLogWhereUniqueInputObjectSchema as CronJobLogWhereUniqueInputObjectSchema } from './objects/CronJobLogWhereUniqueInput.schema';
+import { CronJobLogCountAggregateInputObjectSchema as CronJobLogCountAggregateInputObjectSchema } from './objects/CronJobLogCountAggregateInput.schema';
+import { CronJobLogMinAggregateInputObjectSchema as CronJobLogMinAggregateInputObjectSchema } from './objects/CronJobLogMinAggregateInput.schema';
+import { CronJobLogMaxAggregateInputObjectSchema as CronJobLogMaxAggregateInputObjectSchema } from './objects/CronJobLogMaxAggregateInput.schema';
+import { CronJobLogAvgAggregateInputObjectSchema as CronJobLogAvgAggregateInputObjectSchema } from './objects/CronJobLogAvgAggregateInput.schema';
+import { CronJobLogSumAggregateInputObjectSchema as CronJobLogSumAggregateInputObjectSchema } from './objects/CronJobLogSumAggregateInput.schema';
+
+export const CronJobLogAggregateSchema: z.ZodType<Prisma.CronJobLogAggregateArgs> = z.object({ orderBy: z.union([CronJobLogOrderByWithRelationInputObjectSchema, CronJobLogOrderByWithRelationInputObjectSchema.array()]).optional(), where: CronJobLogWhereInputObjectSchema.optional(), cursor: CronJobLogWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), CronJobLogCountAggregateInputObjectSchema ]).optional(), _min: CronJobLogMinAggregateInputObjectSchema.optional(), _max: CronJobLogMaxAggregateInputObjectSchema.optional(), _avg: CronJobLogAvgAggregateInputObjectSchema.optional(), _sum: CronJobLogSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogAggregateArgs>;
+
+export const CronJobLogAggregateZodSchema = z.object({ orderBy: z.union([CronJobLogOrderByWithRelationInputObjectSchema, CronJobLogOrderByWithRelationInputObjectSchema.array()]).optional(), where: CronJobLogWhereInputObjectSchema.optional(), cursor: CronJobLogWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), _count: z.union([ z.literal(true), CronJobLogCountAggregateInputObjectSchema ]).optional(), _min: CronJobLogMinAggregateInputObjectSchema.optional(), _max: CronJobLogMaxAggregateInputObjectSchema.optional(), _avg: CronJobLogAvgAggregateInputObjectSchema.optional(), _sum: CronJobLogSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/countCronJobLog.schema.ts

@@ -0,0 +1,10 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogOrderByWithRelationInputObjectSchema as CronJobLogOrderByWithRelationInputObjectSchema } from './objects/CronJobLogOrderByWithRelationInput.schema';
+import { CronJobLogWhereInputObjectSchema as CronJobLogWhereInputObjectSchema } from './objects/CronJobLogWhereInput.schema';
+import { CronJobLogWhereUniqueInputObjectSchema as CronJobLogWhereUniqueInputObjectSchema } from './objects/CronJobLogWhereUniqueInput.schema';
+import { CronJobLogCountAggregateInputObjectSchema as CronJobLogCountAggregateInputObjectSchema } from './objects/CronJobLogCountAggregateInput.schema';
+
+export const CronJobLogCountSchema: z.ZodType<Prisma.CronJobLogCountArgs> = z.object({ orderBy: z.union([CronJobLogOrderByWithRelationInputObjectSchema, CronJobLogOrderByWithRelationInputObjectSchema.array()]).optional(), where: CronJobLogWhereInputObjectSchema.optional(), cursor: CronJobLogWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), select: z.union([ z.literal(true), CronJobLogCountAggregateInputObjectSchema ]).optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogCountArgs>;
+
+export const CronJobLogCountZodSchema = z.object({ orderBy: z.union([CronJobLogOrderByWithRelationInputObjectSchema, CronJobLogOrderByWithRelationInputObjectSchema.array()]).optional(), where: CronJobLogWhereInputObjectSchema.optional(), cursor: CronJobLogWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), select: z.union([ z.literal(true), CronJobLogCountAggregateInputObjectSchema ]).optional() }).strict();

packages/db/shared/schemas/createManyAndReturnCronJobLog.schema.ts

@@ -0,0 +1,8 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogSelectObjectSchema as CronJobLogSelectObjectSchema } from './objects/CronJobLogSelect.schema';
+import { CronJobLogCreateManyInputObjectSchema as CronJobLogCreateManyInputObjectSchema } from './objects/CronJobLogCreateManyInput.schema';
+
+export const CronJobLogCreateManyAndReturnSchema: z.ZodType<Prisma.CronJobLogCreateManyAndReturnArgs> = z.object({ select: CronJobLogSelectObjectSchema.optional(), data: z.union([ CronJobLogCreateManyInputObjectSchema, z.array(CronJobLogCreateManyInputObjectSchema) ]), skipDuplicates: z.boolean().optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogCreateManyAndReturnArgs>;
+
+export const CronJobLogCreateManyAndReturnZodSchema = z.object({ select: CronJobLogSelectObjectSchema.optional(), data: z.union([ CronJobLogCreateManyInputObjectSchema, z.array(CronJobLogCreateManyInputObjectSchema) ]), skipDuplicates: z.boolean().optional() }).strict();

packages/db/shared/schemas/createManyCronJobLog.schema.ts

@@ -0,0 +1,7 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogCreateManyInputObjectSchema as CronJobLogCreateManyInputObjectSchema } from './objects/CronJobLogCreateManyInput.schema';
+
+export const CronJobLogCreateManySchema: z.ZodType<Prisma.CronJobLogCreateManyArgs> = z.object({ data: z.union([ CronJobLogCreateManyInputObjectSchema, z.array(CronJobLogCreateManyInputObjectSchema) ]), skipDuplicates: z.boolean().optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogCreateManyArgs>;
+
+export const CronJobLogCreateManyZodSchema = z.object({ data: z.union([ CronJobLogCreateManyInputObjectSchema, z.array(CronJobLogCreateManyInputObjectSchema) ]), skipDuplicates: z.boolean().optional() }).strict();

packages/db/shared/schemas/createOneCronJobLog.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogSelectObjectSchema as CronJobLogSelectObjectSchema } from './objects/CronJobLogSelect.schema';
+import { CronJobLogCreateInputObjectSchema as CronJobLogCreateInputObjectSchema } from './objects/CronJobLogCreateInput.schema';
+import { CronJobLogUncheckedCreateInputObjectSchema as CronJobLogUncheckedCreateInputObjectSchema } from './objects/CronJobLogUncheckedCreateInput.schema';
+
+export const CronJobLogCreateOneSchema: z.ZodType<Prisma.CronJobLogCreateArgs> = z.object({ select: CronJobLogSelectObjectSchema.optional(),  data: z.union([CronJobLogCreateInputObjectSchema, CronJobLogUncheckedCreateInputObjectSchema]) }).strict() as unknown as z.ZodType<Prisma.CronJobLogCreateArgs>;
+
+export const CronJobLogCreateOneZodSchema = z.object({ select: CronJobLogSelectObjectSchema.optional(),  data: z.union([CronJobLogCreateInputObjectSchema, CronJobLogUncheckedCreateInputObjectSchema]) }).strict();

packages/db/shared/schemas/deleteManyCronJobLog.schema.ts

@@ -0,0 +1,7 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogWhereInputObjectSchema as CronJobLogWhereInputObjectSchema } from './objects/CronJobLogWhereInput.schema';
+
+export const CronJobLogDeleteManySchema: z.ZodType<Prisma.CronJobLogDeleteManyArgs> = z.object({ where: CronJobLogWhereInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogDeleteManyArgs>;
+
+export const CronJobLogDeleteManyZodSchema = z.object({ where: CronJobLogWhereInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/deleteOneCronJobLog.schema.ts

@@ -0,0 +1,8 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogSelectObjectSchema as CronJobLogSelectObjectSchema } from './objects/CronJobLogSelect.schema';
+import { CronJobLogWhereUniqueInputObjectSchema as CronJobLogWhereUniqueInputObjectSchema } from './objects/CronJobLogWhereUniqueInput.schema';
+
+export const CronJobLogDeleteOneSchema: z.ZodType<Prisma.CronJobLogDeleteArgs> = z.object({ select: CronJobLogSelectObjectSchema.optional(),  where: CronJobLogWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.CronJobLogDeleteArgs>;
+
+export const CronJobLogDeleteOneZodSchema = z.object({ select: CronJobLogSelectObjectSchema.optional(),  where: CronJobLogWhereUniqueInputObjectSchema }).strict();

packages/db/shared/schemas/enums/CronJobLogScalarFieldEnum.schema.ts

@@ -0,0 +1,5 @@
+import * as z from 'zod';
+
+export const CronJobLogScalarFieldEnumSchema = z.enum(['id', 'jobName', 'status', 'startedAt', 'completedAt', 'durationMs', 'errorMessage'])
+
+export type CronJobLogScalarFieldEnum = z.infer<typeof CronJobLogScalarFieldEnumSchema>;

packages/db/shared/schemas/findFirstCronJobLog.schema.ts

@@ -0,0 +1,33 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogOrderByWithRelationInputObjectSchema as CronJobLogOrderByWithRelationInputObjectSchema } from './objects/CronJobLogOrderByWithRelationInput.schema';
+import { CronJobLogWhereInputObjectSchema as CronJobLogWhereInputObjectSchema } from './objects/CronJobLogWhereInput.schema';
+import { CronJobLogWhereUniqueInputObjectSchema as CronJobLogWhereUniqueInputObjectSchema } from './objects/CronJobLogWhereUniqueInput.schema';
+import { CronJobLogScalarFieldEnumSchema } from './enums/CronJobLogScalarFieldEnum.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const CronJobLogFindFirstSelectSchema: z.ZodType<Prisma.CronJobLogSelect> = z.object({
+    id: z.boolean().optional(),
+    jobName: z.boolean().optional(),
+    status: z.boolean().optional(),
+    startedAt: z.boolean().optional(),
+    completedAt: z.boolean().optional(),
+    durationMs: z.boolean().optional(),
+    errorMessage: z.boolean().optional()
+  }).strict() as unknown as z.ZodType<Prisma.CronJobLogSelect>;
+
+export const CronJobLogFindFirstSelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    jobName: z.boolean().optional(),
+    status: z.boolean().optional(),
+    startedAt: z.boolean().optional(),
+    completedAt: z.boolean().optional(),
+    durationMs: z.boolean().optional(),
+    errorMessage: z.boolean().optional()
+  }).strict();
+
+export const CronJobLogFindFirstSchema: z.ZodType<Prisma.CronJobLogFindFirstArgs> = z.object({ select: CronJobLogFindFirstSelectSchema.optional(),  orderBy: z.union([CronJobLogOrderByWithRelationInputObjectSchema, CronJobLogOrderByWithRelationInputObjectSchema.array()]).optional(), where: CronJobLogWhereInputObjectSchema.optional(), cursor: CronJobLogWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([CronJobLogScalarFieldEnumSchema, CronJobLogScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogFindFirstArgs>;
+
+export const CronJobLogFindFirstZodSchema = z.object({ select: CronJobLogFindFirstSelectSchema.optional(),  orderBy: z.union([CronJobLogOrderByWithRelationInputObjectSchema, CronJobLogOrderByWithRelationInputObjectSchema.array()]).optional(), where: CronJobLogWhereInputObjectSchema.optional(), cursor: CronJobLogWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([CronJobLogScalarFieldEnumSchema, CronJobLogScalarFieldEnumSchema.array()]).optional() }).strict();

packages/db/shared/schemas/findFirstOrThrowCronJobLog.schema.ts

@@ -0,0 +1,33 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogOrderByWithRelationInputObjectSchema as CronJobLogOrderByWithRelationInputObjectSchema } from './objects/CronJobLogOrderByWithRelationInput.schema';
+import { CronJobLogWhereInputObjectSchema as CronJobLogWhereInputObjectSchema } from './objects/CronJobLogWhereInput.schema';
+import { CronJobLogWhereUniqueInputObjectSchema as CronJobLogWhereUniqueInputObjectSchema } from './objects/CronJobLogWhereUniqueInput.schema';
+import { CronJobLogScalarFieldEnumSchema } from './enums/CronJobLogScalarFieldEnum.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const CronJobLogFindFirstOrThrowSelectSchema: z.ZodType<Prisma.CronJobLogSelect> = z.object({
+    id: z.boolean().optional(),
+    jobName: z.boolean().optional(),
+    status: z.boolean().optional(),
+    startedAt: z.boolean().optional(),
+    completedAt: z.boolean().optional(),
+    durationMs: z.boolean().optional(),
+    errorMessage: z.boolean().optional()
+  }).strict() as unknown as z.ZodType<Prisma.CronJobLogSelect>;
+
+export const CronJobLogFindFirstOrThrowSelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    jobName: z.boolean().optional(),
+    status: z.boolean().optional(),
+    startedAt: z.boolean().optional(),
+    completedAt: z.boolean().optional(),
+    durationMs: z.boolean().optional(),
+    errorMessage: z.boolean().optional()
+  }).strict();
+
+export const CronJobLogFindFirstOrThrowSchema: z.ZodType<Prisma.CronJobLogFindFirstOrThrowArgs> = z.object({ select: CronJobLogFindFirstOrThrowSelectSchema.optional(),  orderBy: z.union([CronJobLogOrderByWithRelationInputObjectSchema, CronJobLogOrderByWithRelationInputObjectSchema.array()]).optional(), where: CronJobLogWhereInputObjectSchema.optional(), cursor: CronJobLogWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([CronJobLogScalarFieldEnumSchema, CronJobLogScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogFindFirstOrThrowArgs>;
+
+export const CronJobLogFindFirstOrThrowZodSchema = z.object({ select: CronJobLogFindFirstOrThrowSelectSchema.optional(),  orderBy: z.union([CronJobLogOrderByWithRelationInputObjectSchema, CronJobLogOrderByWithRelationInputObjectSchema.array()]).optional(), where: CronJobLogWhereInputObjectSchema.optional(), cursor: CronJobLogWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([CronJobLogScalarFieldEnumSchema, CronJobLogScalarFieldEnumSchema.array()]).optional() }).strict();

packages/db/shared/schemas/findManyCronJobLog.schema.ts

@@ -0,0 +1,33 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogOrderByWithRelationInputObjectSchema as CronJobLogOrderByWithRelationInputObjectSchema } from './objects/CronJobLogOrderByWithRelationInput.schema';
+import { CronJobLogWhereInputObjectSchema as CronJobLogWhereInputObjectSchema } from './objects/CronJobLogWhereInput.schema';
+import { CronJobLogWhereUniqueInputObjectSchema as CronJobLogWhereUniqueInputObjectSchema } from './objects/CronJobLogWhereUniqueInput.schema';
+import { CronJobLogScalarFieldEnumSchema } from './enums/CronJobLogScalarFieldEnum.schema';
+
+// Select schema needs to be in file to prevent circular imports
+//------------------------------------------------------
+
+export const CronJobLogFindManySelectSchema: z.ZodType<Prisma.CronJobLogSelect> = z.object({
+    id: z.boolean().optional(),
+    jobName: z.boolean().optional(),
+    status: z.boolean().optional(),
+    startedAt: z.boolean().optional(),
+    completedAt: z.boolean().optional(),
+    durationMs: z.boolean().optional(),
+    errorMessage: z.boolean().optional()
+  }).strict() as unknown as z.ZodType<Prisma.CronJobLogSelect>;
+
+export const CronJobLogFindManySelectZodSchema = z.object({
+    id: z.boolean().optional(),
+    jobName: z.boolean().optional(),
+    status: z.boolean().optional(),
+    startedAt: z.boolean().optional(),
+    completedAt: z.boolean().optional(),
+    durationMs: z.boolean().optional(),
+    errorMessage: z.boolean().optional()
+  }).strict();
+
+export const CronJobLogFindManySchema: z.ZodType<Prisma.CronJobLogFindManyArgs> = z.object({ select: CronJobLogFindManySelectSchema.optional(),  orderBy: z.union([CronJobLogOrderByWithRelationInputObjectSchema, CronJobLogOrderByWithRelationInputObjectSchema.array()]).optional(), where: CronJobLogWhereInputObjectSchema.optional(), cursor: CronJobLogWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([CronJobLogScalarFieldEnumSchema, CronJobLogScalarFieldEnumSchema.array()]).optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogFindManyArgs>;
+
+export const CronJobLogFindManyZodSchema = z.object({ select: CronJobLogFindManySelectSchema.optional(),  orderBy: z.union([CronJobLogOrderByWithRelationInputObjectSchema, CronJobLogOrderByWithRelationInputObjectSchema.array()]).optional(), where: CronJobLogWhereInputObjectSchema.optional(), cursor: CronJobLogWhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.union([CronJobLogScalarFieldEnumSchema, CronJobLogScalarFieldEnumSchema.array()]).optional() }).strict();

packages/db/shared/schemas/findUniqueCronJobLog.schema.ts

@@ -0,0 +1,8 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogSelectObjectSchema as CronJobLogSelectObjectSchema } from './objects/CronJobLogSelect.schema';
+import { CronJobLogWhereUniqueInputObjectSchema as CronJobLogWhereUniqueInputObjectSchema } from './objects/CronJobLogWhereUniqueInput.schema';
+
+export const CronJobLogFindUniqueSchema: z.ZodType<Prisma.CronJobLogFindUniqueArgs> = z.object({ select: CronJobLogSelectObjectSchema.optional(),  where: CronJobLogWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.CronJobLogFindUniqueArgs>;
+
+export const CronJobLogFindUniqueZodSchema = z.object({ select: CronJobLogSelectObjectSchema.optional(),  where: CronJobLogWhereUniqueInputObjectSchema }).strict();

packages/db/shared/schemas/findUniqueOrThrowCronJobLog.schema.ts

@@ -0,0 +1,8 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogSelectObjectSchema as CronJobLogSelectObjectSchema } from './objects/CronJobLogSelect.schema';
+import { CronJobLogWhereUniqueInputObjectSchema as CronJobLogWhereUniqueInputObjectSchema } from './objects/CronJobLogWhereUniqueInput.schema';
+
+export const CronJobLogFindUniqueOrThrowSchema: z.ZodType<Prisma.CronJobLogFindUniqueOrThrowArgs> = z.object({ select: CronJobLogSelectObjectSchema.optional(),  where: CronJobLogWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.CronJobLogFindUniqueOrThrowArgs>;
+
+export const CronJobLogFindUniqueOrThrowZodSchema = z.object({ select: CronJobLogSelectObjectSchema.optional(),  where: CronJobLogWhereUniqueInputObjectSchema }).strict();

packages/db/shared/schemas/groupByCronJobLog.schema.ts

@@ -0,0 +1,15 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogWhereInputObjectSchema as CronJobLogWhereInputObjectSchema } from './objects/CronJobLogWhereInput.schema';
+import { CronJobLogOrderByWithAggregationInputObjectSchema as CronJobLogOrderByWithAggregationInputObjectSchema } from './objects/CronJobLogOrderByWithAggregationInput.schema';
+import { CronJobLogScalarWhereWithAggregatesInputObjectSchema as CronJobLogScalarWhereWithAggregatesInputObjectSchema } from './objects/CronJobLogScalarWhereWithAggregatesInput.schema';
+import { CronJobLogScalarFieldEnumSchema } from './enums/CronJobLogScalarFieldEnum.schema';
+import { CronJobLogCountAggregateInputObjectSchema as CronJobLogCountAggregateInputObjectSchema } from './objects/CronJobLogCountAggregateInput.schema';
+import { CronJobLogMinAggregateInputObjectSchema as CronJobLogMinAggregateInputObjectSchema } from './objects/CronJobLogMinAggregateInput.schema';
+import { CronJobLogMaxAggregateInputObjectSchema as CronJobLogMaxAggregateInputObjectSchema } from './objects/CronJobLogMaxAggregateInput.schema';
+import { CronJobLogAvgAggregateInputObjectSchema as CronJobLogAvgAggregateInputObjectSchema } from './objects/CronJobLogAvgAggregateInput.schema';
+import { CronJobLogSumAggregateInputObjectSchema as CronJobLogSumAggregateInputObjectSchema } from './objects/CronJobLogSumAggregateInput.schema';
+
+export const CronJobLogGroupBySchema: z.ZodType<Prisma.CronJobLogGroupByArgs> = z.object({ where: CronJobLogWhereInputObjectSchema.optional(), orderBy: z.union([CronJobLogOrderByWithAggregationInputObjectSchema, CronJobLogOrderByWithAggregationInputObjectSchema.array()]).optional(), having: CronJobLogScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(CronJobLogScalarFieldEnumSchema), _count: z.union([ z.literal(true), CronJobLogCountAggregateInputObjectSchema ]).optional(), _min: CronJobLogMinAggregateInputObjectSchema.optional(), _max: CronJobLogMaxAggregateInputObjectSchema.optional(), _avg: CronJobLogAvgAggregateInputObjectSchema.optional(), _sum: CronJobLogSumAggregateInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogGroupByArgs>;
+
+export const CronJobLogGroupByZodSchema = z.object({ where: CronJobLogWhereInputObjectSchema.optional(), orderBy: z.union([CronJobLogOrderByWithAggregationInputObjectSchema, CronJobLogOrderByWithAggregationInputObjectSchema.array()]).optional(), having: CronJobLogScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(CronJobLogScalarFieldEnumSchema), _count: z.union([ z.literal(true), CronJobLogCountAggregateInputObjectSchema ]).optional(), _min: CronJobLogMinAggregateInputObjectSchema.optional(), _max: CronJobLogMaxAggregateInputObjectSchema.optional(), _avg: CronJobLogAvgAggregateInputObjectSchema.optional(), _sum: CronJobLogSumAggregateInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/index.ts

@@ -16,6 +16,7 @@ export * from './enums/ServiceLineTransactionScalarFieldEnum.schema'
 export * from './enums/DatabaseBackupScalarFieldEnum.schema'
 export * from './enums/BackupDestinationScalarFieldEnum.schema'
 export * from './enums/NotificationScalarFieldEnum.schema'
+export * from './enums/CronJobLogScalarFieldEnum.schema'
 export * from './enums/CloudFolderScalarFieldEnum.schema'
 export * from './enums/CloudFileScalarFieldEnum.schema'
 export * from './enums/CloudFileChunkScalarFieldEnum.schema'
@@ -327,6 +328,23 @@ export * from './updateManyAndReturnNotification.schema'
 export * from './upsertOneNotification.schema'
 export * from './aggregateNotification.schema'
 export * from './groupByNotification.schema'
+export * from './findUniqueCronJobLog.schema'
+export * from './findUniqueOrThrowCronJobLog.schema'
+export * from './findFirstCronJobLog.schema'
+export * from './findFirstOrThrowCronJobLog.schema'
+export * from './findManyCronJobLog.schema'
+export * from './countCronJobLog.schema'
+export * from './createOneCronJobLog.schema'
+export * from './createManyCronJobLog.schema'
+export * from './createManyAndReturnCronJobLog.schema'
+export * from './deleteOneCronJobLog.schema'
+export * from './deleteManyCronJobLog.schema'
+export * from './updateOneCronJobLog.schema'
+export * from './updateManyCronJobLog.schema'
+export * from './updateManyAndReturnCronJobLog.schema'
+export * from './upsertOneCronJobLog.schema'
+export * from './aggregateCronJobLog.schema'
+export * from './groupByCronJobLog.schema'
 export * from './findUniqueCloudFolder.schema'
 export * from './findUniqueOrThrowCloudFolder.schema'
 export * from './findFirstCloudFolder.schema'
@@ -633,6 +651,19 @@ export * from './results/NotificationDeleteManyResult.schema'
 export * from './results/NotificationAggregateResult.schema'
 export * from './results/NotificationGroupByResult.schema'
 export * from './results/NotificationCountResult.schema'
+export * from './results/CronJobLogFindUniqueResult.schema'
+export * from './results/CronJobLogFindFirstResult.schema'
+export * from './results/CronJobLogFindManyResult.schema'
+export * from './results/CronJobLogCreateResult.schema'
+export * from './results/CronJobLogCreateManyResult.schema'
+export * from './results/CronJobLogUpdateResult.schema'
+export * from './results/CronJobLogUpdateManyResult.schema'
+export * from './results/CronJobLogUpsertResult.schema'
+export * from './results/CronJobLogDeleteResult.schema'
+export * from './results/CronJobLogDeleteManyResult.schema'
+export * from './results/CronJobLogAggregateResult.schema'
+export * from './results/CronJobLogGroupByResult.schema'
+export * from './results/CronJobLogCountResult.schema'
 export * from './results/CloudFolderFindUniqueResult.schema'
 export * from './results/CloudFolderFindFirstResult.schema'
 export * from './results/CloudFolderFindManyResult.schema'
@@ -717,6 +748,7 @@ export * from './variants/pure/ServiceLineTransaction.pure'
 export * from './variants/pure/DatabaseBackup.pure'
 export * from './variants/pure/BackupDestination.pure'
 export * from './variants/pure/Notification.pure'
+export * from './variants/pure/CronJobLog.pure'
 export * from './variants/pure/CloudFolder.pure'
 export * from './variants/pure/CloudFile.pure'
 export * from './variants/pure/CloudFileChunk.pure'
@@ -740,6 +772,7 @@ export * from './variants/input/ServiceLineTransaction.input'
 export * from './variants/input/DatabaseBackup.input'
 export * from './variants/input/BackupDestination.input'
 export * from './variants/input/Notification.input'
+export * from './variants/input/CronJobLog.input'
 export * from './variants/input/CloudFolder.input'
 export * from './variants/input/CloudFile.input'
 export * from './variants/input/CloudFileChunk.input'
@@ -763,6 +796,7 @@ export * from './variants/result/ServiceLineTransaction.result'
 export * from './variants/result/DatabaseBackup.result'
 export * from './variants/result/BackupDestination.result'
 export * from './variants/result/Notification.result'
+export * from './variants/result/CronJobLog.result'
 export * from './variants/result/CloudFolder.result'
 export * from './variants/result/CloudFile.result'
 export * from './variants/result/CloudFileChunk.result'

packages/db/shared/schemas/objects/CronJobLogArgs.schema.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { CronJobLogSelectObjectSchema as CronJobLogSelectObjectSchema } from './CronJobLogSelect.schema'
+
+const makeSchema = () => z.object({
+  select: z.lazy(() => CronJobLogSelectObjectSchema).optional()
+}).strict();
+export const CronJobLogArgsObjectSchema = makeSchema();
+export const CronJobLogArgsObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogAvgAggregateInput.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  id: z.literal(true).optional(),
+  durationMs: z.literal(true).optional()
+}).strict();
+export const CronJobLogAvgAggregateInputObjectSchema: z.ZodType<Prisma.CronJobLogAvgAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogAvgAggregateInputType>;
+export const CronJobLogAvgAggregateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogAvgOrderByAggregateInput.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { SortOrderSchema } from '../enums/SortOrder.schema'
+
+const makeSchema = () => z.object({
+  id: SortOrderSchema.optional(),
+  durationMs: SortOrderSchema.optional()
+}).strict();
+export const CronJobLogAvgOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CronJobLogAvgOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogAvgOrderByAggregateInput>;
+export const CronJobLogAvgOrderByAggregateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogCountAggregateInput.schema.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  id: z.literal(true).optional(),
+  jobName: z.literal(true).optional(),
+  status: z.literal(true).optional(),
+  startedAt: z.literal(true).optional(),
+  completedAt: z.literal(true).optional(),
+  durationMs: z.literal(true).optional(),
+  errorMessage: z.literal(true).optional(),
+  _all: z.literal(true).optional()
+}).strict();
+export const CronJobLogCountAggregateInputObjectSchema: z.ZodType<Prisma.CronJobLogCountAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogCountAggregateInputType>;
+export const CronJobLogCountAggregateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogCountOrderByAggregateInput.schema.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { SortOrderSchema } from '../enums/SortOrder.schema'
+
+const makeSchema = () => z.object({
+  id: SortOrderSchema.optional(),
+  jobName: SortOrderSchema.optional(),
+  status: SortOrderSchema.optional(),
+  startedAt: SortOrderSchema.optional(),
+  completedAt: SortOrderSchema.optional(),
+  durationMs: SortOrderSchema.optional(),
+  errorMessage: SortOrderSchema.optional()
+}).strict();
+export const CronJobLogCountOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CronJobLogCountOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogCountOrderByAggregateInput>;
+export const CronJobLogCountOrderByAggregateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogCreateInput.schema.ts

@@ -0,0 +1,14 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.coerce.date(),
+  completedAt: z.coerce.date().optional().nullable(),
+  durationMs: z.number().int().optional().nullable(),
+  errorMessage: z.string().optional().nullable()
+}).strict();
+export const CronJobLogCreateInputObjectSchema: z.ZodType<Prisma.CronJobLogCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogCreateInput>;
+export const CronJobLogCreateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogCreateManyInput.schema.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  id: z.number().int().optional(),
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.coerce.date(),
+  completedAt: z.coerce.date().optional().nullable(),
+  durationMs: z.number().int().optional().nullable(),
+  errorMessage: z.string().optional().nullable()
+}).strict();
+export const CronJobLogCreateManyInputObjectSchema: z.ZodType<Prisma.CronJobLogCreateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogCreateManyInput>;
+export const CronJobLogCreateManyInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogMaxAggregateInput.schema.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  id: z.literal(true).optional(),
+  jobName: z.literal(true).optional(),
+  status: z.literal(true).optional(),
+  startedAt: z.literal(true).optional(),
+  completedAt: z.literal(true).optional(),
+  durationMs: z.literal(true).optional(),
+  errorMessage: z.literal(true).optional()
+}).strict();
+export const CronJobLogMaxAggregateInputObjectSchema: z.ZodType<Prisma.CronJobLogMaxAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogMaxAggregateInputType>;
+export const CronJobLogMaxAggregateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogMaxOrderByAggregateInput.schema.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { SortOrderSchema } from '../enums/SortOrder.schema'
+
+const makeSchema = () => z.object({
+  id: SortOrderSchema.optional(),
+  jobName: SortOrderSchema.optional(),
+  status: SortOrderSchema.optional(),
+  startedAt: SortOrderSchema.optional(),
+  completedAt: SortOrderSchema.optional(),
+  durationMs: SortOrderSchema.optional(),
+  errorMessage: SortOrderSchema.optional()
+}).strict();
+export const CronJobLogMaxOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CronJobLogMaxOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogMaxOrderByAggregateInput>;
+export const CronJobLogMaxOrderByAggregateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogMinAggregateInput.schema.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  id: z.literal(true).optional(),
+  jobName: z.literal(true).optional(),
+  status: z.literal(true).optional(),
+  startedAt: z.literal(true).optional(),
+  completedAt: z.literal(true).optional(),
+  durationMs: z.literal(true).optional(),
+  errorMessage: z.literal(true).optional()
+}).strict();
+export const CronJobLogMinAggregateInputObjectSchema: z.ZodType<Prisma.CronJobLogMinAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogMinAggregateInputType>;
+export const CronJobLogMinAggregateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogMinOrderByAggregateInput.schema.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { SortOrderSchema } from '../enums/SortOrder.schema'
+
+const makeSchema = () => z.object({
+  id: SortOrderSchema.optional(),
+  jobName: SortOrderSchema.optional(),
+  status: SortOrderSchema.optional(),
+  startedAt: SortOrderSchema.optional(),
+  completedAt: SortOrderSchema.optional(),
+  durationMs: SortOrderSchema.optional(),
+  errorMessage: SortOrderSchema.optional()
+}).strict();
+export const CronJobLogMinOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CronJobLogMinOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogMinOrderByAggregateInput>;
+export const CronJobLogMinOrderByAggregateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogOrderByWithAggregationInput.schema.ts

@@ -0,0 +1,26 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { SortOrderSchema } from '../enums/SortOrder.schema';
+import { SortOrderInputObjectSchema as SortOrderInputObjectSchema } from './SortOrderInput.schema';
+import { CronJobLogCountOrderByAggregateInputObjectSchema as CronJobLogCountOrderByAggregateInputObjectSchema } from './CronJobLogCountOrderByAggregateInput.schema';
+import { CronJobLogAvgOrderByAggregateInputObjectSchema as CronJobLogAvgOrderByAggregateInputObjectSchema } from './CronJobLogAvgOrderByAggregateInput.schema';
+import { CronJobLogMaxOrderByAggregateInputObjectSchema as CronJobLogMaxOrderByAggregateInputObjectSchema } from './CronJobLogMaxOrderByAggregateInput.schema';
+import { CronJobLogMinOrderByAggregateInputObjectSchema as CronJobLogMinOrderByAggregateInputObjectSchema } from './CronJobLogMinOrderByAggregateInput.schema';
+import { CronJobLogSumOrderByAggregateInputObjectSchema as CronJobLogSumOrderByAggregateInputObjectSchema } from './CronJobLogSumOrderByAggregateInput.schema'
+
+const makeSchema = () => z.object({
+  id: SortOrderSchema.optional(),
+  jobName: SortOrderSchema.optional(),
+  status: SortOrderSchema.optional(),
+  startedAt: SortOrderSchema.optional(),
+  completedAt: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
+  durationMs: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
+  errorMessage: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
+  _count: z.lazy(() => CronJobLogCountOrderByAggregateInputObjectSchema).optional(),
+  _avg: z.lazy(() => CronJobLogAvgOrderByAggregateInputObjectSchema).optional(),
+  _max: z.lazy(() => CronJobLogMaxOrderByAggregateInputObjectSchema).optional(),
+  _min: z.lazy(() => CronJobLogMinOrderByAggregateInputObjectSchema).optional(),
+  _sum: z.lazy(() => CronJobLogSumOrderByAggregateInputObjectSchema).optional()
+}).strict();
+export const CronJobLogOrderByWithAggregationInputObjectSchema: z.ZodType<Prisma.CronJobLogOrderByWithAggregationInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogOrderByWithAggregationInput>;
+export const CronJobLogOrderByWithAggregationInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogOrderByWithRelationInput.schema.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { SortOrderSchema } from '../enums/SortOrder.schema';
+import { SortOrderInputObjectSchema as SortOrderInputObjectSchema } from './SortOrderInput.schema'
+
+const makeSchema = () => z.object({
+  id: SortOrderSchema.optional(),
+  jobName: SortOrderSchema.optional(),
+  status: SortOrderSchema.optional(),
+  startedAt: SortOrderSchema.optional(),
+  completedAt: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
+  durationMs: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional(),
+  errorMessage: z.union([SortOrderSchema, z.lazy(() => SortOrderInputObjectSchema)]).optional()
+}).strict();
+export const CronJobLogOrderByWithRelationInputObjectSchema: z.ZodType<Prisma.CronJobLogOrderByWithRelationInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogOrderByWithRelationInput>;
+export const CronJobLogOrderByWithRelationInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogScalarWhereWithAggregatesInput.schema.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { IntWithAggregatesFilterObjectSchema as IntWithAggregatesFilterObjectSchema } from './IntWithAggregatesFilter.schema';
+import { StringWithAggregatesFilterObjectSchema as StringWithAggregatesFilterObjectSchema } from './StringWithAggregatesFilter.schema';
+import { DateTimeWithAggregatesFilterObjectSchema as DateTimeWithAggregatesFilterObjectSchema } from './DateTimeWithAggregatesFilter.schema';
+import { DateTimeNullableWithAggregatesFilterObjectSchema as DateTimeNullableWithAggregatesFilterObjectSchema } from './DateTimeNullableWithAggregatesFilter.schema';
+import { IntNullableWithAggregatesFilterObjectSchema as IntNullableWithAggregatesFilterObjectSchema } from './IntNullableWithAggregatesFilter.schema';
+import { StringNullableWithAggregatesFilterObjectSchema as StringNullableWithAggregatesFilterObjectSchema } from './StringNullableWithAggregatesFilter.schema'
+
+const cronjoblogscalarwherewithaggregatesinputSchema = z.object({
+  AND: z.union([z.lazy(() => CronJobLogScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => CronJobLogScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
+  OR: z.lazy(() => CronJobLogScalarWhereWithAggregatesInputObjectSchema).array().optional(),
+  NOT: z.union([z.lazy(() => CronJobLogScalarWhereWithAggregatesInputObjectSchema), z.lazy(() => CronJobLogScalarWhereWithAggregatesInputObjectSchema).array()]).optional(),
+  id: z.union([z.lazy(() => IntWithAggregatesFilterObjectSchema), z.number().int()]).optional(),
+  jobName: z.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()]).optional(),
+  status: z.union([z.lazy(() => StringWithAggregatesFilterObjectSchema), z.string()]).optional(),
+  startedAt: z.union([z.lazy(() => DateTimeWithAggregatesFilterObjectSchema), z.coerce.date()]).optional(),
+  completedAt: z.union([z.lazy(() => DateTimeNullableWithAggregatesFilterObjectSchema), z.coerce.date()]).optional().nullable(),
+  durationMs: z.union([z.lazy(() => IntNullableWithAggregatesFilterObjectSchema), z.number().int()]).optional().nullable(),
+  errorMessage: z.union([z.lazy(() => StringNullableWithAggregatesFilterObjectSchema), z.string()]).optional().nullable()
+}).strict();
+export const CronJobLogScalarWhereWithAggregatesInputObjectSchema: z.ZodType<Prisma.CronJobLogScalarWhereWithAggregatesInput> = cronjoblogscalarwherewithaggregatesinputSchema as unknown as z.ZodType<Prisma.CronJobLogScalarWhereWithAggregatesInput>;
+export const CronJobLogScalarWhereWithAggregatesInputObjectZodSchema = cronjoblogscalarwherewithaggregatesinputSchema;

packages/db/shared/schemas/objects/CronJobLogSelect.schema.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  id: z.boolean().optional(),
+  jobName: z.boolean().optional(),
+  status: z.boolean().optional(),
+  startedAt: z.boolean().optional(),
+  completedAt: z.boolean().optional(),
+  durationMs: z.boolean().optional(),
+  errorMessage: z.boolean().optional()
+}).strict();
+export const CronJobLogSelectObjectSchema: z.ZodType<Prisma.CronJobLogSelect> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogSelect>;
+export const CronJobLogSelectObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogSumAggregateInput.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  id: z.literal(true).optional(),
+  durationMs: z.literal(true).optional()
+}).strict();
+export const CronJobLogSumAggregateInputObjectSchema: z.ZodType<Prisma.CronJobLogSumAggregateInputType> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogSumAggregateInputType>;
+export const CronJobLogSumAggregateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogSumOrderByAggregateInput.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { SortOrderSchema } from '../enums/SortOrder.schema'
+
+const makeSchema = () => z.object({
+  id: SortOrderSchema.optional(),
+  durationMs: SortOrderSchema.optional()
+}).strict();
+export const CronJobLogSumOrderByAggregateInputObjectSchema: z.ZodType<Prisma.CronJobLogSumOrderByAggregateInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogSumOrderByAggregateInput>;
+export const CronJobLogSumOrderByAggregateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogUncheckedCreateInput.schema.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  id: z.number().int().optional(),
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.coerce.date(),
+  completedAt: z.coerce.date().optional().nullable(),
+  durationMs: z.number().int().optional().nullable(),
+  errorMessage: z.string().optional().nullable()
+}).strict();
+export const CronJobLogUncheckedCreateInputObjectSchema: z.ZodType<Prisma.CronJobLogUncheckedCreateInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogUncheckedCreateInput>;
+export const CronJobLogUncheckedCreateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogUncheckedUpdateInput.schema.ts

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
+import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
+import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
+import { NullableDateTimeFieldUpdateOperationsInputObjectSchema as NullableDateTimeFieldUpdateOperationsInputObjectSchema } from './NullableDateTimeFieldUpdateOperationsInput.schema';
+import { NullableIntFieldUpdateOperationsInputObjectSchema as NullableIntFieldUpdateOperationsInputObjectSchema } from './NullableIntFieldUpdateOperationsInput.schema';
+import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema'
+
+const makeSchema = () => z.object({
+  id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
+  jobName: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
+  status: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
+  startedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional(),
+  completedAt: z.union([z.coerce.date(), z.lazy(() => NullableDateTimeFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
+  durationMs: z.union([z.number().int(), z.lazy(() => NullableIntFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
+  errorMessage: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable()
+}).strict();
+export const CronJobLogUncheckedUpdateInputObjectSchema: z.ZodType<Prisma.CronJobLogUncheckedUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogUncheckedUpdateInput>;
+export const CronJobLogUncheckedUpdateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogUncheckedUpdateManyInput.schema.ts

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { IntFieldUpdateOperationsInputObjectSchema as IntFieldUpdateOperationsInputObjectSchema } from './IntFieldUpdateOperationsInput.schema';
+import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
+import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
+import { NullableDateTimeFieldUpdateOperationsInputObjectSchema as NullableDateTimeFieldUpdateOperationsInputObjectSchema } from './NullableDateTimeFieldUpdateOperationsInput.schema';
+import { NullableIntFieldUpdateOperationsInputObjectSchema as NullableIntFieldUpdateOperationsInputObjectSchema } from './NullableIntFieldUpdateOperationsInput.schema';
+import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema'
+
+const makeSchema = () => z.object({
+  id: z.union([z.number().int(), z.lazy(() => IntFieldUpdateOperationsInputObjectSchema)]).optional(),
+  jobName: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
+  status: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
+  startedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional(),
+  completedAt: z.union([z.coerce.date(), z.lazy(() => NullableDateTimeFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
+  durationMs: z.union([z.number().int(), z.lazy(() => NullableIntFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
+  errorMessage: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable()
+}).strict();
+export const CronJobLogUncheckedUpdateManyInputObjectSchema: z.ZodType<Prisma.CronJobLogUncheckedUpdateManyInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogUncheckedUpdateManyInput>;
+export const CronJobLogUncheckedUpdateManyInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogUpdateInput.schema.ts

@@ -0,0 +1,18 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
+import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
+import { NullableDateTimeFieldUpdateOperationsInputObjectSchema as NullableDateTimeFieldUpdateOperationsInputObjectSchema } from './NullableDateTimeFieldUpdateOperationsInput.schema';
+import { NullableIntFieldUpdateOperationsInputObjectSchema as NullableIntFieldUpdateOperationsInputObjectSchema } from './NullableIntFieldUpdateOperationsInput.schema';
+import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema'
+
+const makeSchema = () => z.object({
+  jobName: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
+  status: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
+  startedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional(),
+  completedAt: z.union([z.coerce.date(), z.lazy(() => NullableDateTimeFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
+  durationMs: z.union([z.number().int(), z.lazy(() => NullableIntFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
+  errorMessage: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable()
+}).strict();
+export const CronJobLogUpdateInputObjectSchema: z.ZodType<Prisma.CronJobLogUpdateInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogUpdateInput>;
+export const CronJobLogUpdateInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogUpdateManyMutationInput.schema.ts

@@ -0,0 +1,18 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { StringFieldUpdateOperationsInputObjectSchema as StringFieldUpdateOperationsInputObjectSchema } from './StringFieldUpdateOperationsInput.schema';
+import { DateTimeFieldUpdateOperationsInputObjectSchema as DateTimeFieldUpdateOperationsInputObjectSchema } from './DateTimeFieldUpdateOperationsInput.schema';
+import { NullableDateTimeFieldUpdateOperationsInputObjectSchema as NullableDateTimeFieldUpdateOperationsInputObjectSchema } from './NullableDateTimeFieldUpdateOperationsInput.schema';
+import { NullableIntFieldUpdateOperationsInputObjectSchema as NullableIntFieldUpdateOperationsInputObjectSchema } from './NullableIntFieldUpdateOperationsInput.schema';
+import { NullableStringFieldUpdateOperationsInputObjectSchema as NullableStringFieldUpdateOperationsInputObjectSchema } from './NullableStringFieldUpdateOperationsInput.schema'
+
+const makeSchema = () => z.object({
+  jobName: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
+  status: z.union([z.string(), z.lazy(() => StringFieldUpdateOperationsInputObjectSchema)]).optional(),
+  startedAt: z.union([z.coerce.date(), z.lazy(() => DateTimeFieldUpdateOperationsInputObjectSchema)]).optional(),
+  completedAt: z.union([z.coerce.date(), z.lazy(() => NullableDateTimeFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
+  durationMs: z.union([z.number().int(), z.lazy(() => NullableIntFieldUpdateOperationsInputObjectSchema)]).optional().nullable(),
+  errorMessage: z.union([z.string(), z.lazy(() => NullableStringFieldUpdateOperationsInputObjectSchema)]).optional().nullable()
+}).strict();
+export const CronJobLogUpdateManyMutationInputObjectSchema: z.ZodType<Prisma.CronJobLogUpdateManyMutationInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogUpdateManyMutationInput>;
+export const CronJobLogUpdateManyMutationInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/CronJobLogWhereInput.schema.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { IntFilterObjectSchema as IntFilterObjectSchema } from './IntFilter.schema';
+import { StringFilterObjectSchema as StringFilterObjectSchema } from './StringFilter.schema';
+import { DateTimeFilterObjectSchema as DateTimeFilterObjectSchema } from './DateTimeFilter.schema';
+import { DateTimeNullableFilterObjectSchema as DateTimeNullableFilterObjectSchema } from './DateTimeNullableFilter.schema';
+import { IntNullableFilterObjectSchema as IntNullableFilterObjectSchema } from './IntNullableFilter.schema';
+import { StringNullableFilterObjectSchema as StringNullableFilterObjectSchema } from './StringNullableFilter.schema'
+
+const cronjoblogwhereinputSchema = z.object({
+  AND: z.union([z.lazy(() => CronJobLogWhereInputObjectSchema), z.lazy(() => CronJobLogWhereInputObjectSchema).array()]).optional(),
+  OR: z.lazy(() => CronJobLogWhereInputObjectSchema).array().optional(),
+  NOT: z.union([z.lazy(() => CronJobLogWhereInputObjectSchema), z.lazy(() => CronJobLogWhereInputObjectSchema).array()]).optional(),
+  id: z.union([z.lazy(() => IntFilterObjectSchema), z.number().int()]).optional(),
+  jobName: z.union([z.lazy(() => StringFilterObjectSchema), z.string()]).optional(),
+  status: z.union([z.lazy(() => StringFilterObjectSchema), z.string()]).optional(),
+  startedAt: z.union([z.lazy(() => DateTimeFilterObjectSchema), z.coerce.date()]).optional(),
+  completedAt: z.union([z.lazy(() => DateTimeNullableFilterObjectSchema), z.coerce.date()]).optional().nullable(),
+  durationMs: z.union([z.lazy(() => IntNullableFilterObjectSchema), z.number().int()]).optional().nullable(),
+  errorMessage: z.union([z.lazy(() => StringNullableFilterObjectSchema), z.string()]).optional().nullable()
+}).strict();
+export const CronJobLogWhereInputObjectSchema: z.ZodType<Prisma.CronJobLogWhereInput> = cronjoblogwhereinputSchema as unknown as z.ZodType<Prisma.CronJobLogWhereInput>;
+export const CronJobLogWhereInputObjectZodSchema = cronjoblogwhereinputSchema;

packages/db/shared/schemas/objects/CronJobLogWhereUniqueInput.schema.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  id: z.number().int().optional()
+}).strict();
+export const CronJobLogWhereUniqueInputObjectSchema: z.ZodType<Prisma.CronJobLogWhereUniqueInput> = makeSchema() as unknown as z.ZodType<Prisma.CronJobLogWhereUniqueInput>;
+export const CronJobLogWhereUniqueInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/DateTimeNullableFilter.schema.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { NestedDateTimeNullableFilterObjectSchema as NestedDateTimeNullableFilterObjectSchema } from './NestedDateTimeNullableFilter.schema'
+
+const makeSchema = () => z.object({
+  equals: z.date().optional().nullable(),
+  in: z.union([z.date().array(), z.string().datetime().array()]).optional().nullable(),
+  notIn: z.union([z.date().array(), z.string().datetime().array()]).optional().nullable(),
+  lt: z.date().optional(),
+  lte: z.date().optional(),
+  gt: z.date().optional(),
+  gte: z.date().optional(),
+  not: z.union([z.date(), z.lazy(() => NestedDateTimeNullableFilterObjectSchema)]).optional().nullable()
+}).strict();
+export const DateTimeNullableFilterObjectSchema: z.ZodType<Prisma.DateTimeNullableFilter> = makeSchema() as unknown as z.ZodType<Prisma.DateTimeNullableFilter>;
+export const DateTimeNullableFilterObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/DateTimeNullableWithAggregatesFilter.schema.ts

@@ -0,0 +1,21 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { NestedDateTimeNullableWithAggregatesFilterObjectSchema as NestedDateTimeNullableWithAggregatesFilterObjectSchema } from './NestedDateTimeNullableWithAggregatesFilter.schema';
+import { NestedIntNullableFilterObjectSchema as NestedIntNullableFilterObjectSchema } from './NestedIntNullableFilter.schema';
+import { NestedDateTimeNullableFilterObjectSchema as NestedDateTimeNullableFilterObjectSchema } from './NestedDateTimeNullableFilter.schema'
+
+const makeSchema = () => z.object({
+  equals: z.date().optional().nullable(),
+  in: z.union([z.date().array(), z.string().datetime().array()]).optional().nullable(),
+  notIn: z.union([z.date().array(), z.string().datetime().array()]).optional().nullable(),
+  lt: z.date().optional(),
+  lte: z.date().optional(),
+  gt: z.date().optional(),
+  gte: z.date().optional(),
+  not: z.union([z.date(), z.lazy(() => NestedDateTimeNullableWithAggregatesFilterObjectSchema)]).optional().nullable(),
+  _count: z.lazy(() => NestedIntNullableFilterObjectSchema).optional(),
+  _min: z.lazy(() => NestedDateTimeNullableFilterObjectSchema).optional(),
+  _max: z.lazy(() => NestedDateTimeNullableFilterObjectSchema).optional()
+}).strict();
+export const DateTimeNullableWithAggregatesFilterObjectSchema: z.ZodType<Prisma.DateTimeNullableWithAggregatesFilter> = makeSchema() as unknown as z.ZodType<Prisma.DateTimeNullableWithAggregatesFilter>;
+export const DateTimeNullableWithAggregatesFilterObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/NestedDateTimeNullableFilter.schema.ts

@@ -0,0 +1,16 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const nesteddatetimenullablefilterSchema = z.object({
+  equals: z.date().optional().nullable(),
+  in: z.union([z.date().array(), z.string().datetime().array()]).optional().nullable(),
+  notIn: z.union([z.date().array(), z.string().datetime().array()]).optional().nullable(),
+  lt: z.date().optional(),
+  lte: z.date().optional(),
+  gt: z.date().optional(),
+  gte: z.date().optional(),
+  not: z.union([z.date(), z.lazy(() => NestedDateTimeNullableFilterObjectSchema)]).optional().nullable()
+}).strict();
+export const NestedDateTimeNullableFilterObjectSchema: z.ZodType<Prisma.NestedDateTimeNullableFilter> = nesteddatetimenullablefilterSchema as unknown as z.ZodType<Prisma.NestedDateTimeNullableFilter>;
+export const NestedDateTimeNullableFilterObjectZodSchema = nesteddatetimenullablefilterSchema;

packages/db/shared/schemas/objects/NestedDateTimeNullableWithAggregatesFilter.schema.ts

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+import { NestedIntNullableFilterObjectSchema as NestedIntNullableFilterObjectSchema } from './NestedIntNullableFilter.schema';
+import { NestedDateTimeNullableFilterObjectSchema as NestedDateTimeNullableFilterObjectSchema } from './NestedDateTimeNullableFilter.schema'
+
+const nesteddatetimenullablewithaggregatesfilterSchema = z.object({
+  equals: z.date().optional().nullable(),
+  in: z.union([z.date().array(), z.string().datetime().array()]).optional().nullable(),
+  notIn: z.union([z.date().array(), z.string().datetime().array()]).optional().nullable(),
+  lt: z.date().optional(),
+  lte: z.date().optional(),
+  gt: z.date().optional(),
+  gte: z.date().optional(),
+  not: z.union([z.date(), z.lazy(() => NestedDateTimeNullableWithAggregatesFilterObjectSchema)]).optional().nullable(),
+  _count: z.lazy(() => NestedIntNullableFilterObjectSchema).optional(),
+  _min: z.lazy(() => NestedDateTimeNullableFilterObjectSchema).optional(),
+  _max: z.lazy(() => NestedDateTimeNullableFilterObjectSchema).optional()
+}).strict();
+export const NestedDateTimeNullableWithAggregatesFilterObjectSchema: z.ZodType<Prisma.NestedDateTimeNullableWithAggregatesFilter> = nesteddatetimenullablewithaggregatesfilterSchema as unknown as z.ZodType<Prisma.NestedDateTimeNullableWithAggregatesFilter>;
+export const NestedDateTimeNullableWithAggregatesFilterObjectZodSchema = nesteddatetimenullablewithaggregatesfilterSchema;

packages/db/shared/schemas/objects/NullableDateTimeFieldUpdateOperationsInput.schema.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod';
+import type { Prisma } from '../../../generated/prisma';
+
+
+const makeSchema = () => z.object({
+  set: z.coerce.date().optional()
+}).strict();
+export const NullableDateTimeFieldUpdateOperationsInputObjectSchema: z.ZodType<Prisma.NullableDateTimeFieldUpdateOperationsInput> = makeSchema() as unknown as z.ZodType<Prisma.NullableDateTimeFieldUpdateOperationsInput>;
+export const NullableDateTimeFieldUpdateOperationsInputObjectZodSchema = makeSchema();

packages/db/shared/schemas/objects/index.ts

@@ -1239,6 +1239,30 @@ export * from './CommunicationWhereInput.schema.d';
 export * from './CommunicationWhereInput.schema';
 export * from './CommunicationWhereUniqueInput.schema.d';
 export * from './CommunicationWhereUniqueInput.schema';
+export * from './CronJobLogArgs.schema';
+export * from './CronJobLogAvgAggregateInput.schema';
+export * from './CronJobLogAvgOrderByAggregateInput.schema';
+export * from './CronJobLogCountAggregateInput.schema';
+export * from './CronJobLogCountOrderByAggregateInput.schema';
+export * from './CronJobLogCreateInput.schema';
+export * from './CronJobLogCreateManyInput.schema';
+export * from './CronJobLogMaxAggregateInput.schema';
+export * from './CronJobLogMaxOrderByAggregateInput.schema';
+export * from './CronJobLogMinAggregateInput.schema';
+export * from './CronJobLogMinOrderByAggregateInput.schema';
+export * from './CronJobLogOrderByWithAggregationInput.schema';
+export * from './CronJobLogOrderByWithRelationInput.schema';
+export * from './CronJobLogScalarWhereWithAggregatesInput.schema';
+export * from './CronJobLogSelect.schema';
+export * from './CronJobLogSumAggregateInput.schema';
+export * from './CronJobLogSumOrderByAggregateInput.schema';
+export * from './CronJobLogUncheckedCreateInput.schema';
+export * from './CronJobLogUncheckedUpdateInput.schema';
+export * from './CronJobLogUncheckedUpdateManyInput.schema';
+export * from './CronJobLogUpdateInput.schema';
+export * from './CronJobLogUpdateManyMutationInput.schema';
+export * from './CronJobLogWhereInput.schema';
+export * from './CronJobLogWhereUniqueInput.schema';
 export * from './DatabaseBackupArgs.schema';
 export * from './DatabaseBackupAvgAggregateInput.schema.d';
 export * from './DatabaseBackupAvgAggregateInput.schema';
@@ -1327,6 +1351,8 @@ export * from './DateTimeFieldUpdateOperationsInput.schema.d';
 export * from './DateTimeFieldUpdateOperationsInput.schema';
 export * from './DateTimeFilter.schema.d';
 export * from './DateTimeFilter.schema';
+export * from './DateTimeNullableFilter.schema';
+export * from './DateTimeNullableWithAggregatesFilter.schema';
 export * from './DateTimeWithAggregatesFilter.schema.d';
 export * from './DateTimeWithAggregatesFilter.schema';
 export * from './DecimalFieldUpdateOperationsInput.schema.d';
@@ -1525,6 +1551,8 @@ export * from './NestedBytesWithAggregatesFilter.schema.d';
 export * from './NestedBytesWithAggregatesFilter.schema';
 export * from './NestedDateTimeFilter.schema.d';
 export * from './NestedDateTimeFilter.schema';
+export * from './NestedDateTimeNullableFilter.schema';
+export * from './NestedDateTimeNullableWithAggregatesFilter.schema';
 export * from './NestedDateTimeWithAggregatesFilter.schema.d';
 export * from './NestedDateTimeWithAggregatesFilter.schema';
 export * from './NestedDecimalFilter.schema.d';
@@ -1775,6 +1803,7 @@ export * from './NpiProviderWhereInput.schema.d';
 export * from './NpiProviderWhereInput.schema';
 export * from './NpiProviderWhereUniqueInput.schema.d';
 export * from './NpiProviderWhereUniqueInput.schema';
+export * from './NullableDateTimeFieldUpdateOperationsInput.schema';
 export * from './NullableDecimalFieldUpdateOperationsInput.schema.d';
 export * from './NullableDecimalFieldUpdateOperationsInput.schema';
 export * from './NullableIntFieldUpdateOperationsInput.schema.d';

packages/db/shared/schemas/results/CronJobLogAggregateResult.schema.ts

@@ -0,0 +1,36 @@
+import * as z from 'zod';
+export const CronJobLogAggregateResultSchema = z.object({  _count: z.object({
+    id: z.number(),
+    jobName: z.number(),
+    status: z.number(),
+    startedAt: z.number(),
+    completedAt: z.number(),
+    durationMs: z.number(),
+    errorMessage: z.number()
+  }).optional(),
+  _sum: z.object({
+    id: z.number().nullable(),
+    durationMs: z.number().nullable()
+  }).nullable().optional(),
+  _avg: z.object({
+    id: z.number().nullable(),
+    durationMs: z.number().nullable()
+  }).nullable().optional(),
+  _min: z.object({
+    id: z.number().int().nullable(),
+    jobName: z.string().nullable(),
+    status: z.string().nullable(),
+    startedAt: z.date().nullable(),
+    completedAt: z.date().nullable(),
+    durationMs: z.number().int().nullable(),
+    errorMessage: z.string().nullable()
+  }).nullable().optional(),
+  _max: z.object({
+    id: z.number().int().nullable(),
+    jobName: z.string().nullable(),
+    status: z.string().nullable(),
+    startedAt: z.date().nullable(),
+    completedAt: z.date().nullable(),
+    durationMs: z.number().int().nullable(),
+    errorMessage: z.string().nullable()
+  }).nullable().optional()});

packages/db/shared/schemas/results/CronJobLogCountResult.schema.ts

@@ -0,0 +1,2 @@
+import * as z from 'zod';
+export const CronJobLogCountResultSchema = z.number();

packages/db/shared/schemas/results/CronJobLogCreateManyResult.schema.ts

@@ -0,0 +1,4 @@
+import * as z from 'zod';
+export const CronJobLogCreateManyResultSchema = z.object({
+  count: z.number()
+});

packages/db/shared/schemas/results/CronJobLogCreateResult.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+export const CronJobLogCreateResultSchema = z.object({
+  id: z.number().int(),
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.date(),
+  completedAt: z.date().optional(),
+  durationMs: z.number().int().optional(),
+  errorMessage: z.string().optional()
+});

packages/db/shared/schemas/results/CronJobLogDeleteManyResult.schema.ts

@@ -0,0 +1,4 @@
+import * as z from 'zod';
+export const CronJobLogDeleteManyResultSchema = z.object({
+  count: z.number()
+});

packages/db/shared/schemas/results/CronJobLogDeleteResult.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+export const CronJobLogDeleteResultSchema = z.nullable(z.object({
+  id: z.number().int(),
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.date(),
+  completedAt: z.date().optional(),
+  durationMs: z.number().int().optional(),
+  errorMessage: z.string().optional()
+}));

packages/db/shared/schemas/results/CronJobLogFindFirstResult.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+export const CronJobLogFindFirstResultSchema = z.nullable(z.object({
+  id: z.number().int(),
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.date(),
+  completedAt: z.date().optional(),
+  durationMs: z.number().int().optional(),
+  errorMessage: z.string().optional()
+}));

packages/db/shared/schemas/results/CronJobLogFindManyResult.schema.ts

@@ -0,0 +1,20 @@
+import * as z from 'zod';
+export const CronJobLogFindManyResultSchema = z.object({
+  data: z.array(z.object({
+  id: z.number().int(),
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.date(),
+  completedAt: z.date().optional(),
+  durationMs: z.number().int().optional(),
+  errorMessage: z.string().optional()
+})),
+  pagination: z.object({
+  page: z.number().int().min(1),
+  pageSize: z.number().int().min(1),
+  total: z.number().int().min(0),
+  totalPages: z.number().int().min(0),
+  hasNext: z.boolean(),
+  hasPrev: z.boolean()
+})
+});

packages/db/shared/schemas/results/CronJobLogFindUniqueResult.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+export const CronJobLogFindUniqueResultSchema = z.nullable(z.object({
+  id: z.number().int(),
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.date(),
+  completedAt: z.date().optional(),
+  durationMs: z.number().int().optional(),
+  errorMessage: z.string().optional()
+}));

packages/db/shared/schemas/results/CronJobLogGroupByResult.schema.ts

@@ -0,0 +1,45 @@
+import * as z from 'zod';
+export const CronJobLogGroupByResultSchema = z.array(z.object({
+  id: z.number().int(),
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.date(),
+  completedAt: z.date(),
+  durationMs: z.number().int(),
+  errorMessage: z.string(),
+  _count: z.object({
+    id: z.number(),
+    jobName: z.number(),
+    status: z.number(),
+    startedAt: z.number(),
+    completedAt: z.number(),
+    durationMs: z.number(),
+    errorMessage: z.number()
+  }).optional(),
+  _sum: z.object({
+    id: z.number().nullable(),
+    durationMs: z.number().nullable()
+  }).nullable().optional(),
+  _avg: z.object({
+    id: z.number().nullable(),
+    durationMs: z.number().nullable()
+  }).nullable().optional(),
+  _min: z.object({
+    id: z.number().int().nullable(),
+    jobName: z.string().nullable(),
+    status: z.string().nullable(),
+    startedAt: z.date().nullable(),
+    completedAt: z.date().nullable(),
+    durationMs: z.number().int().nullable(),
+    errorMessage: z.string().nullable()
+  }).nullable().optional(),
+  _max: z.object({
+    id: z.number().int().nullable(),
+    jobName: z.string().nullable(),
+    status: z.string().nullable(),
+    startedAt: z.date().nullable(),
+    completedAt: z.date().nullable(),
+    durationMs: z.number().int().nullable(),
+    errorMessage: z.string().nullable()
+  }).nullable().optional()
+}));

packages/db/shared/schemas/results/CronJobLogUpdateManyResult.schema.ts

@@ -0,0 +1,4 @@
+import * as z from 'zod';
+export const CronJobLogUpdateManyResultSchema = z.object({
+  count: z.number()
+});

packages/db/shared/schemas/results/CronJobLogUpdateResult.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+export const CronJobLogUpdateResultSchema = z.nullable(z.object({
+  id: z.number().int(),
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.date(),
+  completedAt: z.date().optional(),
+  durationMs: z.number().int().optional(),
+  errorMessage: z.string().optional()
+}));

packages/db/shared/schemas/results/CronJobLogUpsertResult.schema.ts

@@ -0,0 +1,10 @@
+import * as z from 'zod';
+export const CronJobLogUpsertResultSchema = z.object({
+  id: z.number().int(),
+  jobName: z.string(),
+  status: z.string(),
+  startedAt: z.date(),
+  completedAt: z.date().optional(),
+  durationMs: z.number().int().optional(),
+  errorMessage: z.string().optional()
+});

packages/db/shared/schemas/results/index.ts

@@ -219,6 +219,19 @@ export { NotificationDeleteManyResultSchema } from './NotificationDeleteManyResu
 export { NotificationAggregateResultSchema } from './NotificationAggregateResult.schema';
 export { NotificationGroupByResultSchema } from './NotificationGroupByResult.schema';
 export { NotificationCountResultSchema } from './NotificationCountResult.schema';
+export { CronJobLogFindUniqueResultSchema } from './CronJobLogFindUniqueResult.schema';
+export { CronJobLogFindFirstResultSchema } from './CronJobLogFindFirstResult.schema';
+export { CronJobLogFindManyResultSchema } from './CronJobLogFindManyResult.schema';
+export { CronJobLogCreateResultSchema } from './CronJobLogCreateResult.schema';
+export { CronJobLogCreateManyResultSchema } from './CronJobLogCreateManyResult.schema';
+export { CronJobLogUpdateResultSchema } from './CronJobLogUpdateResult.schema';
+export { CronJobLogUpdateManyResultSchema } from './CronJobLogUpdateManyResult.schema';
+export { CronJobLogUpsertResultSchema } from './CronJobLogUpsertResult.schema';
+export { CronJobLogDeleteResultSchema } from './CronJobLogDeleteResult.schema';
+export { CronJobLogDeleteManyResultSchema } from './CronJobLogDeleteManyResult.schema';
+export { CronJobLogAggregateResultSchema } from './CronJobLogAggregateResult.schema';
+export { CronJobLogGroupByResultSchema } from './CronJobLogGroupByResult.schema';
+export { CronJobLogCountResultSchema } from './CronJobLogCountResult.schema';
 export { CloudFolderFindUniqueResultSchema } from './CloudFolderFindUniqueResult.schema';
 export { CloudFolderFindFirstResultSchema } from './CloudFolderFindFirstResult.schema';
 export { CloudFolderFindManyResultSchema } from './CloudFolderFindManyResult.schema';

packages/db/shared/schemas/updateManyAndReturnCronJobLog.schema.ts

@@ -0,0 +1,9 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogSelectObjectSchema as CronJobLogSelectObjectSchema } from './objects/CronJobLogSelect.schema';
+import { CronJobLogUpdateManyMutationInputObjectSchema as CronJobLogUpdateManyMutationInputObjectSchema } from './objects/CronJobLogUpdateManyMutationInput.schema';
+import { CronJobLogWhereInputObjectSchema as CronJobLogWhereInputObjectSchema } from './objects/CronJobLogWhereInput.schema';
+
+export const CronJobLogUpdateManyAndReturnSchema: z.ZodType<Prisma.CronJobLogUpdateManyAndReturnArgs> = z.object({ select: CronJobLogSelectObjectSchema.optional(), data: CronJobLogUpdateManyMutationInputObjectSchema, where: CronJobLogWhereInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogUpdateManyAndReturnArgs>;
+
+export const CronJobLogUpdateManyAndReturnZodSchema = z.object({ select: CronJobLogSelectObjectSchema.optional(), data: CronJobLogUpdateManyMutationInputObjectSchema, where: CronJobLogWhereInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/updateManyCronJobLog.schema.ts

@@ -0,0 +1,8 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogUpdateManyMutationInputObjectSchema as CronJobLogUpdateManyMutationInputObjectSchema } from './objects/CronJobLogUpdateManyMutationInput.schema';
+import { CronJobLogWhereInputObjectSchema as CronJobLogWhereInputObjectSchema } from './objects/CronJobLogWhereInput.schema';
+
+export const CronJobLogUpdateManySchema: z.ZodType<Prisma.CronJobLogUpdateManyArgs> = z.object({ data: CronJobLogUpdateManyMutationInputObjectSchema, where: CronJobLogWhereInputObjectSchema.optional() }).strict() as unknown as z.ZodType<Prisma.CronJobLogUpdateManyArgs>;
+
+export const CronJobLogUpdateManyZodSchema = z.object({ data: CronJobLogUpdateManyMutationInputObjectSchema, where: CronJobLogWhereInputObjectSchema.optional() }).strict();

packages/db/shared/schemas/updateOneCronJobLog.schema.ts

@@ -0,0 +1,10 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogSelectObjectSchema as CronJobLogSelectObjectSchema } from './objects/CronJobLogSelect.schema';
+import { CronJobLogUpdateInputObjectSchema as CronJobLogUpdateInputObjectSchema } from './objects/CronJobLogUpdateInput.schema';
+import { CronJobLogUncheckedUpdateInputObjectSchema as CronJobLogUncheckedUpdateInputObjectSchema } from './objects/CronJobLogUncheckedUpdateInput.schema';
+import { CronJobLogWhereUniqueInputObjectSchema as CronJobLogWhereUniqueInputObjectSchema } from './objects/CronJobLogWhereUniqueInput.schema';
+
+export const CronJobLogUpdateOneSchema: z.ZodType<Prisma.CronJobLogUpdateArgs> = z.object({ select: CronJobLogSelectObjectSchema.optional(),  data: z.union([CronJobLogUpdateInputObjectSchema, CronJobLogUncheckedUpdateInputObjectSchema]), where: CronJobLogWhereUniqueInputObjectSchema }).strict() as unknown as z.ZodType<Prisma.CronJobLogUpdateArgs>;
+
+export const CronJobLogUpdateOneZodSchema = z.object({ select: CronJobLogSelectObjectSchema.optional(),  data: z.union([CronJobLogUpdateInputObjectSchema, CronJobLogUncheckedUpdateInputObjectSchema]), where: CronJobLogWhereUniqueInputObjectSchema }).strict();

packages/db/shared/schemas/upsertOneCronJobLog.schema.ts

@@ -0,0 +1,12 @@
+import type { Prisma } from '../../generated/prisma';
+import * as z from 'zod';
+import { CronJobLogSelectObjectSchema as CronJobLogSelectObjectSchema } from './objects/CronJobLogSelect.schema';
+import { CronJobLogWhereUniqueInputObjectSchema as CronJobLogWhereUniqueInputObjectSchema } from './objects/CronJobLogWhereUniqueInput.schema';
+import { CronJobLogCreateInputObjectSchema as CronJobLogCreateInputObjectSchema } from './objects/CronJobLogCreateInput.schema';
+import { CronJobLogUncheckedCreateInputObjectSchema as CronJobLogUncheckedCreateInputObjectSchema } from './objects/CronJobLogUncheckedCreateInput.schema';
+import { CronJobLogUpdateInputObjectSchema as CronJobLogUpdateInputObjectSchema } from './objects/CronJobLogUpdateInput.schema';
+import { CronJobLogUncheckedUpdateInputObjectSchema as CronJobLogUncheckedUpdateInputObjectSchema } from './objects/CronJobLogUncheckedUpdateInput.schema';
+
+export const CronJobLogUpsertOneSchema: z.ZodType<Prisma.CronJobLogUpsertArgs> = z.object({ select: CronJobLogSelectObjectSchema.optional(),  where: CronJobLogWhereUniqueInputObjectSchema, create: z.union([ CronJobLogCreateInputObjectSchema, CronJobLogUncheckedCreateInputObjectSchema ]), update: z.union([ CronJobLogUpdateInputObjectSchema, CronJobLogUncheckedUpdateInputObjectSchema ]) }).strict() as unknown as z.ZodType<Prisma.CronJobLogUpsertArgs>;
+
+export const CronJobLogUpsertOneZodSchema = z.object({ select: CronJobLogSelectObjectSchema.optional(),  where: CronJobLogWhereUniqueInputObjectSchema, create: z.union([ CronJobLogCreateInputObjectSchema, CronJobLogUncheckedCreateInputObjectSchema ]), update: z.union([ CronJobLogUpdateInputObjectSchema, CronJobLogUncheckedUpdateInputObjectSchema ]) }).strict();

packages/db/shared/schemas/variants/input/CronJobLog.input.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CronJobLogInputSchema = z.object({
+    id: z.number().int(),
+    jobName: z.string(),
+    status: z.string(),
+    startedAt: z.date(),
+    completedAt: z.date().optional().nullable(),
+    durationMs: z.number().int().optional().nullable(),
+    errorMessage: z.string().optional().nullable()
+}).strict();
+
+export type CronJobLogInputType = z.infer<typeof CronJobLogInputSchema>;

packages/db/shared/schemas/variants/input/index.ts

@@ -20,6 +20,7 @@ export { ServiceLineTransactionInputSchema } from './ServiceLineTransaction.inpu
 export { DatabaseBackupInputSchema } from './DatabaseBackup.input';
 export { BackupDestinationInputSchema } from './BackupDestination.input';
 export { NotificationInputSchema } from './Notification.input';
+export { CronJobLogInputSchema } from './CronJobLog.input';
 export { CloudFolderInputSchema } from './CloudFolder.input';
 export { CloudFileInputSchema } from './CloudFile.input';
 export { CloudFileChunkInputSchema } from './CloudFileChunk.input';

packages/db/shared/schemas/variants/pure/CronJobLog.pure.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CronJobLogModelSchema = z.object({
+    id: z.number().int(),
+    jobName: z.string(),
+    status: z.string(),
+    startedAt: z.date(),
+    completedAt: z.date().nullable(),
+    durationMs: z.number().int().nullable(),
+    errorMessage: z.string().nullable()
+}).strict();
+
+export type CronJobLogPureType = z.infer<typeof CronJobLogModelSchema>;

packages/db/shared/schemas/variants/pure/index.ts

@@ -20,6 +20,7 @@ export { ServiceLineTransactionModelSchema } from './ServiceLineTransaction.pure
 export { DatabaseBackupModelSchema } from './DatabaseBackup.pure';
 export { BackupDestinationModelSchema } from './BackupDestination.pure';
 export { NotificationModelSchema } from './Notification.pure';
+export { CronJobLogModelSchema } from './CronJobLog.pure';
 export { CloudFolderModelSchema } from './CloudFolder.pure';
 export { CloudFileModelSchema } from './CloudFile.pure';
 export { CloudFileChunkModelSchema } from './CloudFileChunk.pure';

packages/db/shared/schemas/variants/result/CronJobLog.result.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+// prettier-ignore
+export const CronJobLogResultSchema = z.object({
+    id: z.number().int(),
+    jobName: z.string(),
+    status: z.string(),
+    startedAt: z.date(),
+    completedAt: z.date().nullable(),
+    durationMs: z.number().int().nullable(),
+    errorMessage: z.string().nullable()
+}).strict();
+
+export type CronJobLogResultType = z.infer<typeof CronJobLogResultSchema>;

packages/db/shared/schemas/variants/result/index.ts

@@ -20,6 +20,7 @@ export { ServiceLineTransactionResultSchema } from './ServiceLineTransaction.res
 export { DatabaseBackupResultSchema } from './DatabaseBackup.result';
 export { BackupDestinationResultSchema } from './BackupDestination.result';
 export { NotificationResultSchema } from './Notification.result';
+export { CronJobLogResultSchema } from './CronJobLog.result';
 export { CloudFolderResultSchema } from './CloudFolder.result';
 export { CloudFileResultSchema } from './CloudFile.result';
 export { CloudFileChunkResultSchema } from './CloudFileChunk.result';