diff --git a/.env.template b/.env.template
index 83e39beb..ea20fd71 100644
--- a/.env.template
+++ b/.env.template
@@ -16,8 +16,16 @@ DB_USER=test
 DB_PASSWORD=test
 DB_NAME=scriptio
 
-# Staging Basic Auth (htpasswd format, escape $ as $$ in this file)
+# Basic Auth (htpasswd format, escape $ as $$ in this file)
+PROD_AUTH_USERS=
 STAGING_AUTH_USERS=
+MONITORING_AUTH_USERS=
+
+# Monitoring
+GRAFANA_ADMIN_PASSWORD=
+METRICS_BEARER_TOKEN=
+APP_MEMORY_LIMIT_BYTES=536870912    # 512 MiB; tune to the prod container's memory budget
+DB_SIZE_LIMIT_BYTES=10737418240     # 10 GiB; tune to the prod DB's expected ceiling
 
 # S3 storage
 S3_BUCKET=
diff --git a/Dockerfile b/Dockerfile
index 3fbba538..0db35525 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -26,5 +26,5 @@ EXPOSE 3000
 USER node
 ENV NEXT_TELEMETRY_DISABLED 1
 
-ENTRYPOINT ["./launch.sh"]
+ENTRYPOINT ["./scripts/launch.sh"]
 CMD [ "npm", "start" ]
\ No newline at end of file
diff --git a/components/admin/AdminShell.module.css b/components/admin/AdminShell.module.css
new file mode 100644
index 00000000..07024496
--- /dev/null
+++ b/components/admin/AdminShell.module.css
@@ -0,0 +1,133 @@
+.wrapper {
+    display: flex;
+    width: 100%;
+    height: 100vh;
+    background: var(--main-bg);
+}
+
+.sidebar {
+    width: 240px;
+    flex-shrink: 0;
+    background: var(--secondary);
+    border-right: 1px solid var(--separator);
+    display: flex;
+    flex-direction: column;
+    padding: 24px 16px;
+    gap: 24px;
+}
+
+.brand {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 0 8px;
+    color: var(--primary-text);
+    font-family: var(--font-josefin), sans-serif;
+    font-weight: 700;
+    font-size: 18px;
+    letter-spacing: 0.02em;
+}
+
+.brandBadge {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 8px;
+    border-radius: 999px;
+    background: var(--tertiary);
+    color: var(--primary-text);
+    font-size: 10px;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+    font-family: var(--font-inter), sans-serif;
+    font-weight: 600;
+}
+
+.nav {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+}
+
+.navGroupLabel {
+    font-family: var(--font-inter), sans-serif;
+    font-size: 11px;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+    color: var(--secondary-text);
+    padding: 12px 12px 4px;
+}
+
+.navItem {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 10px 12px;
+    background: transparent;
+    border: none;
+    border-radius: 8px;
+    color: var(--primary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+    cursor: pointer;
+    text-align: left;
+    text-decoration: none;
+    transition: background-color 120ms ease;
+}
+
+.navItem:hover {
+    background: var(--primary-hover);
+}
+
+.navItemActive {
+    background: var(--tertiary);
+}
+
+.navItemActive:hover {
+    background: var(--tertiary-hover);
+}
+
+.footer {
+    margin-top: auto;
+    padding: 12px;
+    border-top: 1px solid var(--separator);
+    color: var(--secondary-text);
+    font-size: 12px;
+    font-family: var(--font-inter), sans-serif;
+}
+
+.footerEmail {
+    color: var(--primary-text);
+    font-weight: 600;
+    display: block;
+    margin-bottom: 2px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.main {
+    flex: 1;
+    overflow-y: auto;
+    padding: 32px 40px;
+    min-width: 0;
+}
+
+.header {
+    display: flex;
+    align-items: baseline;
+    justify-content: space-between;
+    margin-bottom: 24px;
+}
+
+.title {
+    color: var(--primary-text);
+    font-family: var(--font-josefin), sans-serif;
+    font-size: 28px;
+    font-weight: 700;
+}
+
+.subtitle {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 13px;
+}
diff --git a/components/admin/AdminShell.tsx b/components/admin/AdminShell.tsx
new file mode 100644
index 00000000..a0db4ec0
--- /dev/null
+++ b/components/admin/AdminShell.tsx
@@ -0,0 +1,72 @@
+"use client";
+
+import { ReactNode } from "react";
+import Link from "next/link";
+import { usePathname } from "next/navigation";
+import { BarChart3, Users, FolderOpen, LogOut } from "lucide-react";
+import styles from "./AdminShell.module.css";
+
+type NavLink = { href: string; label: string; icon: ReactNode };
+
+const NAV_LINKS: NavLink[] = [
+    { href: "/admin", label: "Overview", icon: <BarChart3 size={16} /> },
+    { href: "/admin/users", label: "Users", icon: <Users size={16} /> },
+    { href: "/admin/projects", label: "Projects", icon: <FolderOpen size={16} /> },
+];
+
+type Props = {
+    email: string;
+    title: string;
+    subtitle?: string;
+    children: ReactNode;
+};
+
+export default function AdminShell({ email, title, subtitle, children }: Props) {
+    const pathname = usePathname() ?? "";
+
+    return (
+        <div className={styles.wrapper}>
+            <aside className={styles.sidebar}>
+                <div className={styles.brand}>
+                    Scriptio
+                    <span className={styles.brandBadge}>Admin</span>
+                </div>
+                <nav className={styles.nav}>
+                    <div className={styles.navGroupLabel}>Monitoring</div>
+                    {NAV_LINKS.map((link) => {
+                        const active =
+                            link.href === "/admin"
+                                ? pathname === "/admin"
+                                : pathname.startsWith(link.href);
+                        return (
+                            <Link
+                                key={link.href}
+                                href={link.href}
+                                className={`${styles.navItem} ${active ? styles.navItemActive : ""}`}
+                            >
+                                {link.icon}
+                                {link.label}
+                            </Link>
+                        );
+                    })}
+                </nav>
+                <div className={styles.footer}>
+                    <span className={styles.footerEmail} title={email}>
+                        {email}
+                    </span>
+                    <Link href="/" className={styles.navItem} style={{ padding: "8px 0" }}>
+                        <LogOut size={14} />
+                        Back to app
+                    </Link>
+                </div>
+            </aside>
+            <main className={styles.main}>
+                <div className={styles.header}>
+                    <h1 className={styles.title}>{title}</h1>
+                    {subtitle && <span className={styles.subtitle}>{subtitle}</span>}
+                </div>
+                {children}
+            </main>
+        </div>
+    );
+}
diff --git a/components/admin/ProjectDetail.module.css b/components/admin/ProjectDetail.module.css
new file mode 100644
index 00000000..eace3676
--- /dev/null
+++ b/components/admin/ProjectDetail.module.css
@@ -0,0 +1,137 @@
+.container {
+    display: flex;
+    flex-direction: column;
+    gap: 24px;
+}
+
+.backLink {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    color: var(--secondary-text);
+    text-decoration: none;
+    font-family: var(--font-inter), sans-serif;
+    font-size: 13px;
+    margin-bottom: 8px;
+    width: fit-content;
+}
+
+.backLink:hover {
+    color: var(--primary-text);
+}
+
+.card {
+    background: var(--secondary);
+    border: 1px solid var(--separator);
+    border-radius: 12px;
+    padding: 24px;
+    box-shadow: var(--panel-shadow);
+}
+
+.cardTitle {
+    color: var(--primary-text);
+    font-family: var(--font-josefin), sans-serif;
+    font-size: 18px;
+    font-weight: 700;
+    margin-bottom: 16px;
+}
+
+.fields {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+    gap: 16px 24px;
+}
+
+.field {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    min-width: 0;
+}
+
+.fieldLabel {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 11px;
+    font-weight: 600;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+}
+
+.fieldValue {
+    color: var(--primary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+    overflow-wrap: anywhere;
+}
+
+.idValue {
+    font-family: var(--font-courier), monospace;
+    font-size: 13px;
+}
+
+.table {
+    display: flex;
+    flex-direction: column;
+    border: 1px solid var(--separator);
+    border-radius: 8px;
+    overflow: hidden;
+}
+
+.tableRow {
+    display: grid;
+    grid-template-columns: 2fr 1fr;
+    gap: 16px;
+    padding: 12px 16px;
+    font-family: var(--font-inter), sans-serif;
+    font-size: 13px;
+    color: var(--primary-text);
+    border-bottom: 1px solid var(--separator);
+    align-items: center;
+}
+
+.tableRow:last-child {
+    border-bottom: none;
+}
+
+.tableHeader {
+    background: var(--primary);
+    color: var(--secondary-text);
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    font-weight: 600;
+}
+
+.tableRowLink {
+    text-decoration: none;
+    transition: background-color 120ms ease;
+    cursor: pointer;
+}
+
+.tableRowLink:hover {
+    background: var(--primary-hover);
+}
+
+.tableCellMuted {
+    color: var(--secondary-text);
+    font-size: 12px;
+}
+
+.emptyRow {
+    padding: 16px;
+    text-align: center;
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 13px;
+}
+
+.message {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+}
+
+.error {
+    color: var(--error);
+}
diff --git a/components/admin/ProjectDetail.tsx b/components/admin/ProjectDetail.tsx
new file mode 100644
index 00000000..fb538644
--- /dev/null
+++ b/components/admin/ProjectDetail.tsx
@@ -0,0 +1,156 @@
+"use client";
+
+import Link from "next/link";
+import useSWR from "swr";
+import { ArrowLeft } from "lucide-react";
+import { ProjectRole } from "../../src/generated/client/browser";
+import styles from "./ProjectDetail.module.css";
+
+type ProjectDetailPayload = {
+    id: string;
+    title: string;
+    author: string | null;
+    description: string | null;
+    createdAt: string;
+    updatedAt: string;
+    _count: { members: number; invitations: number };
+};
+
+type Member = {
+    role: ProjectRole;
+    user: { id: string; email: string };
+};
+
+type Invite = {
+    email: string;
+    createdAt: string;
+};
+
+function formatDateTime(iso: string) {
+    return new Date(iso).toLocaleString(undefined, {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+    });
+}
+
+type Props = { projectId: string };
+
+export default function ProjectDetail({ projectId }: Props) {
+    const { data, error, isLoading } = useSWR<ProjectDetailPayload>(
+        `/api/admin/projects/${projectId}`,
+    );
+    const { data: members } = useSWR<Member[]>(
+        `/api/admin/projects/${projectId}/members`,
+    );
+    const { data: invites } = useSWR<Invite[]>(
+        `/api/admin/projects/${projectId}/invites`,
+    );
+
+    return (
+        <div className={styles.container}>
+            <Link href="/admin/projects" className={styles.backLink}>
+                <ArrowLeft size={14} /> Back to search
+            </Link>
+
+            {isLoading && <p className={styles.message}>Loading project…</p>}
+            {error && <p className={`${styles.message} ${styles.error}`}>Project not found.</p>}
+
+            {data && (
+                <>
+                    <section className={styles.card}>
+                        <h2 className={styles.cardTitle}>Project</h2>
+                        <div className={styles.fields}>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Title</span>
+                                <span className={styles.fieldValue}>{data.title}</span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Project ID</span>
+                                <span className={`${styles.fieldValue} ${styles.idValue}`}>
+                                    {data.id}
+                                </span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Author</span>
+                                <span className={styles.fieldValue}>{data.author ?? "—"}</span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Description</span>
+                                <span className={styles.fieldValue}>{data.description ?? "—"}</span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Created</span>
+                                <span className={styles.fieldValue}>
+                                    {formatDateTime(data.createdAt)}
+                                </span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Last updated</span>
+                                <span className={styles.fieldValue}>
+                                    {formatDateTime(data.updatedAt)}
+                                </span>
+                            </div>
+                        </div>
+                    </section>
+
+                    <section className={styles.card}>
+                        <h2 className={styles.cardTitle}>
+                            Members ({data._count.members})
+                        </h2>
+                        <div className={styles.table}>
+                            <div className={`${styles.tableRow} ${styles.tableHeader}`}>
+                                <span>Email</span>
+                                <span>Role</span>
+                            </div>
+                            {!members && (
+                                <div className={styles.emptyRow}>Loading…</div>
+                            )}
+                            {members && members.length === 0 && (
+                                <div className={styles.emptyRow}>No members.</div>
+                            )}
+                            {members?.map((m) => (
+                                <Link
+                                    key={m.user.id}
+                                    href={`/admin/users/${m.user.id}`}
+                                    className={`${styles.tableRow} ${styles.tableRowLink}`}
+                                >
+                                    <span>{m.user.email}</span>
+                                    <span className={styles.tableCellMuted}>{m.role}</span>
+                                </Link>
+                            ))}
+                        </div>
+                    </section>
+
+                    <section className={styles.card}>
+                        <h2 className={styles.cardTitle}>
+                            Pending invitations ({data._count.invitations})
+                        </h2>
+                        <div className={styles.table}>
+                            <div className={`${styles.tableRow} ${styles.tableHeader}`}>
+                                <span>Email</span>
+                                <span>Invited</span>
+                            </div>
+                            {!invites && (
+                                <div className={styles.emptyRow}>Loading…</div>
+                            )}
+                            {invites && invites.length === 0 && (
+                                <div className={styles.emptyRow}>No pending invitations.</div>
+                            )}
+                            {invites?.map((inv) => (
+                                <div key={inv.email} className={styles.tableRow}>
+                                    <span>{inv.email}</span>
+                                    <span className={styles.tableCellMuted}>
+                                        {formatDateTime(inv.createdAt)}
+                                    </span>
+                                </div>
+                            ))}
+                        </div>
+                    </section>
+                </>
+            )}
+        </div>
+    );
+}
diff --git a/components/admin/ProjectSearch.module.css b/components/admin/ProjectSearch.module.css
new file mode 100644
index 00000000..484ecf66
--- /dev/null
+++ b/components/admin/ProjectSearch.module.css
@@ -0,0 +1,104 @@
+.container {
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+}
+
+.searchBar {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    background: var(--secondary);
+    border: 1px solid var(--input-outline);
+    border-radius: 10px;
+    padding: 10px 14px;
+    box-shadow: var(--panel-shadow);
+}
+
+.searchBar:focus-within {
+    border-color: var(--primary-text);
+}
+
+.searchInput {
+    flex: 1;
+    background: transparent;
+    border: none;
+    outline: none;
+    color: var(--primary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+}
+
+.hint {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 13px;
+    padding: 4px 2px;
+}
+
+.resultList {
+    display: flex;
+    flex-direction: column;
+    border: 1px solid var(--separator);
+    border-radius: 10px;
+    overflow: hidden;
+    background: var(--secondary);
+}
+
+.resultRow {
+    display: grid;
+    grid-template-columns: 2fr 1fr auto auto;
+    gap: 16px;
+    align-items: center;
+    padding: 14px 18px;
+    border-bottom: 1px solid var(--separator);
+    color: var(--primary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+    text-decoration: none;
+    transition: background-color 120ms ease;
+}
+
+.resultRow:last-child {
+    border-bottom: none;
+}
+
+.resultRow:hover {
+    background: var(--primary-hover);
+}
+
+.title {
+    font-weight: 600;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.id {
+    color: var(--secondary-text);
+    font-family: var(--font-courier), monospace;
+    font-size: 12px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.members {
+    color: var(--secondary-text);
+    font-size: 12px;
+    white-space: nowrap;
+}
+
+.date {
+    color: var(--secondary-text);
+    font-size: 12px;
+    white-space: nowrap;
+}
+
+.empty {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+    padding: 24px;
+    text-align: center;
+}
diff --git a/components/admin/ProjectSearch.tsx b/components/admin/ProjectSearch.tsx
new file mode 100644
index 00000000..7ae94a5d
--- /dev/null
+++ b/components/admin/ProjectSearch.tsx
@@ -0,0 +1,88 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import useSWR from "swr";
+import Link from "next/link";
+import { Search } from "lucide-react";
+import styles from "./ProjectSearch.module.css";
+
+type ProjectResult = {
+    id: string;
+    title: string;
+    author: string | null;
+    createdAt: string;
+    updatedAt: string;
+    _count: { members: number };
+};
+
+type SearchResponse = {
+    projects: ProjectResult[];
+    nextCursor: number | null;
+};
+
+function formatDate(iso: string) {
+    return new Date(iso).toLocaleDateString(undefined, {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+    });
+}
+
+export default function ProjectSearch() {
+    const [query, setQuery] = useState("");
+    const [debounced, setDebounced] = useState("");
+
+    useEffect(() => {
+        const t = setTimeout(() => setDebounced(query.trim()), 250);
+        return () => clearTimeout(t);
+    }, [query]);
+
+    const key = debounced ? `/api/admin/projects?q=${encodeURIComponent(debounced)}` : null;
+    const { data, isLoading } = useSWR<SearchResponse>(key);
+
+    return (
+        <div className={styles.container}>
+            <div className={styles.searchBar}>
+                <Search size={16} />
+                <input
+                    className={styles.searchInput}
+                    placeholder="Search by project title or project ID"
+                    value={query}
+                    onChange={(e) => setQuery(e.target.value)}
+                    autoFocus
+                />
+            </div>
+
+            {!debounced && (
+                <p className={styles.hint}>
+                    Start typing a title (partial, case-insensitive) or paste a full project ID.
+                </p>
+            )}
+
+            {debounced && isLoading && <p className={styles.hint}>Searching…</p>}
+
+            {debounced && data && data.projects.length === 0 && (
+                <div className={styles.resultList}>
+                    <div className={styles.empty}>No projects match &quot;{debounced}&quot;.</div>
+                </div>
+            )}
+
+            {data && data.projects.length > 0 && (
+                <div className={styles.resultList}>
+                    {data.projects.map((p) => (
+                        <Link key={p.id} href={`/admin/projects/${p.id}`} className={styles.resultRow}>
+                            <span className={styles.title}>{p.title}</span>
+                            <span className={styles.id}>{p.id}</span>
+                            <span className={styles.members}>
+                                {p._count.members} member{p._count.members !== 1 ? "s" : ""}
+                            </span>
+                            <span className={styles.date}>
+                                Updated {formatDate(p.updatedAt)}
+                            </span>
+                        </Link>
+                    ))}
+                </div>
+            )}
+        </div>
+    );
+}
diff --git a/components/admin/StatsCards.module.css b/components/admin/StatsCards.module.css
new file mode 100644
index 00000000..241bc100
--- /dev/null
+++ b/components/admin/StatsCards.module.css
@@ -0,0 +1,51 @@
+.grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+    gap: 16px;
+}
+
+.card {
+    background: var(--secondary);
+    border: 1px solid var(--separator);
+    border-radius: 12px;
+    padding: 20px;
+    box-shadow: var(--panel-shadow);
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.label {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 12px;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+    font-weight: 600;
+}
+
+.value {
+    color: var(--primary-text);
+    font-family: var(--font-josefin), sans-serif;
+    font-size: 32px;
+    font-weight: 700;
+    line-height: 1;
+}
+
+.hint {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 12px;
+}
+
+.loading,
+.error {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+    padding: 12px 4px;
+}
+
+.error {
+    color: var(--error);
+}
diff --git a/components/admin/StatsCards.tsx b/components/admin/StatsCards.tsx
new file mode 100644
index 00000000..921bae90
--- /dev/null
+++ b/components/admin/StatsCards.tsx
@@ -0,0 +1,41 @@
+"use client";
+
+import useSWR from "swr";
+import styles from "./StatsCards.module.css";
+
+type Stats = {
+    userCount: number;
+    activeProCount: number;
+    projectCount: number;
+    transactionsThisMonth: number;
+};
+
+export default function StatsCards() {
+    const { data, error, isLoading } = useSWR<Stats>("/api/admin/stats");
+
+    if (isLoading) return <div className={styles.loading}>Loading stats…</div>;
+    if (error || !data) return <div className={styles.error}>Failed to load stats.</div>;
+
+    const cards = [
+        { label: "Users", value: data.userCount, hint: "All-time registrations" },
+        { label: "Active Pro", value: data.activeProCount, hint: "isProUntil > now" },
+        { label: "Projects", value: data.projectCount, hint: "All projects" },
+        {
+            label: "Transactions (this month)",
+            value: data.transactionsThisMonth,
+            hint: "Since the 1st",
+        },
+    ];
+
+    return (
+        <div className={styles.grid}>
+            {cards.map((c) => (
+                <div key={c.label} className={styles.card}>
+                    <span className={styles.label}>{c.label}</span>
+                    <span className={styles.value}>{c.value.toLocaleString()}</span>
+                    <span className={styles.hint}>{c.hint}</span>
+                </div>
+            ))}
+        </div>
+    );
+}
diff --git a/components/admin/UserDetail.module.css b/components/admin/UserDetail.module.css
new file mode 100644
index 00000000..62455ea1
--- /dev/null
+++ b/components/admin/UserDetail.module.css
@@ -0,0 +1,177 @@
+.container {
+    display: flex;
+    flex-direction: column;
+    gap: 24px;
+}
+
+.backLink {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    color: var(--secondary-text);
+    text-decoration: none;
+    font-family: var(--font-inter), sans-serif;
+    font-size: 13px;
+    margin-bottom: 8px;
+    width: fit-content;
+}
+
+.backLink:hover {
+    color: var(--primary-text);
+}
+
+.card {
+    background: var(--secondary);
+    border: 1px solid var(--separator);
+    border-radius: 12px;
+    padding: 24px;
+    box-shadow: var(--panel-shadow);
+}
+
+.cardTitle {
+    color: var(--primary-text);
+    font-family: var(--font-josefin), sans-serif;
+    font-size: 18px;
+    font-weight: 700;
+    margin-bottom: 16px;
+}
+
+.fields {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+    gap: 16px 24px;
+}
+
+.field {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    min-width: 0;
+}
+
+.fieldLabel {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 11px;
+    font-weight: 600;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+}
+
+.fieldValue {
+    color: var(--primary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+    overflow-wrap: anywhere;
+}
+
+.idValue {
+    font-family: var(--font-courier), monospace;
+    font-size: 13px;
+}
+
+.badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 3px 10px;
+    border-radius: 999px;
+    font-size: 11px;
+    font-weight: 600;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+    width: fit-content;
+}
+
+.badgePro {
+    background: color-mix(in srgb, var(--success) 22%, transparent);
+    color: var(--success);
+}
+
+.badgeAdmin {
+    background: color-mix(in srgb, var(--warning) 25%, transparent);
+    color: var(--warning);
+}
+
+.badgeMuted {
+    background: var(--tertiary);
+    color: var(--secondary-text);
+}
+
+.badgeDanger {
+    background: color-mix(in srgb, var(--error) 22%, transparent);
+    color: var(--error);
+}
+
+.table {
+    display: flex;
+    flex-direction: column;
+    border: 1px solid var(--separator);
+    border-radius: 8px;
+    overflow: hidden;
+}
+
+.tableRow {
+    display: grid;
+    grid-template-columns: 2fr 1fr 1fr;
+    gap: 16px;
+    padding: 12px 16px;
+    font-family: var(--font-inter), sans-serif;
+    font-size: 13px;
+    color: var(--primary-text);
+    border-bottom: 1px solid var(--separator);
+    align-items: center;
+}
+
+.tableRow:last-child {
+    border-bottom: none;
+}
+
+.tableHeader {
+    background: var(--primary);
+    color: var(--secondary-text);
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    font-weight: 600;
+}
+
+.tableRowLink {
+    text-decoration: none;
+    transition: background-color 120ms ease;
+    cursor: pointer;
+}
+
+.tableRowLink:hover {
+    background: var(--primary-hover);
+}
+
+.tableCellMuted {
+    color: var(--secondary-text);
+    font-size: 12px;
+}
+
+.tableCellMono {
+    font-family: var(--font-courier), monospace;
+    font-size: 12px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.emptyRow {
+    padding: 16px;
+    text-align: center;
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 13px;
+}
+
+.message {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+}
+
+.error {
+    color: var(--error);
+}
diff --git a/components/admin/UserDetail.tsx b/components/admin/UserDetail.tsx
new file mode 100644
index 00000000..4e885669
--- /dev/null
+++ b/components/admin/UserDetail.tsx
@@ -0,0 +1,242 @@
+"use client";
+
+import Link from "next/link";
+import useSWR from "swr";
+import { ArrowLeft } from "lucide-react";
+import { UserRole, SubscriptionProvider, ProjectRole } from "../../src/generated/client/browser";
+import styles from "./UserDetail.module.css";
+
+type UserDetailPayload = {
+    user: {
+        id: string;
+        email: string;
+        createdAt: string;
+        emailVerified: string | null;
+        username: string | null;
+        role: UserRole;
+        isProUntil: string | null;
+        isSubscriptionCancelled: boolean;
+        subscriptionProvider: SubscriptionProvider | null;
+    };
+    projectCount: number;
+    transactionCount: number;
+};
+
+type Membership = {
+    role: ProjectRole;
+    project: {
+        id: string;
+        title: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+
+type Transaction = {
+    id: number;
+    provider: SubscriptionProvider;
+    transactionId: string;
+    createdAt: string;
+};
+
+function formatDateTime(iso: string | null) {
+    if (!iso) return "—";
+    const d = new Date(iso);
+    return d.toLocaleString(undefined, {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit",
+    });
+}
+
+function isPro(isProUntil: string | null) {
+    return !!isProUntil && new Date(isProUntil) > new Date();
+}
+
+type Props = { userId: string };
+
+export default function UserDetail({ userId }: Props) {
+    const { data, error, isLoading } = useSWR<UserDetailPayload>(
+        `/api/admin/users/${userId}`,
+    );
+    const { data: memberships } = useSWR<Membership[]>(
+        `/api/admin/users/${userId}/projects`,
+    );
+    const { data: transactions } = useSWR<Transaction[]>(
+        `/api/admin/users/${userId}/transactions`,
+    );
+
+    return (
+        <div className={styles.container}>
+            <Link href="/admin/users" className={styles.backLink}>
+                <ArrowLeft size={14} /> Back to search
+            </Link>
+
+            {isLoading && <p className={styles.message}>Loading user…</p>}
+            {error && <p className={`${styles.message} ${styles.error}`}>User not found.</p>}
+
+            {data && (
+                <>
+                    <section className={styles.card}>
+                        <h2 className={styles.cardTitle}>Account</h2>
+                        <div className={styles.fields}>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Email</span>
+                                <span className={styles.fieldValue}>{data.user.email}</span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>User ID</span>
+                                <span className={`${styles.fieldValue} ${styles.idValue}`}>
+                                    {data.user.id}
+                                </span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Username</span>
+                                <span className={styles.fieldValue}>
+                                    {data.user.username ?? "—"}
+                                </span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Created</span>
+                                <span className={styles.fieldValue}>
+                                    {formatDateTime(data.user.createdAt)}
+                                </span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Email verified</span>
+                                <span className={styles.fieldValue}>
+                                    {data.user.emailVerified
+                                        ? formatDateTime(data.user.emailVerified)
+                                        : "No"}
+                                </span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Role</span>
+                                <span
+                                    className={`${styles.badge} ${
+                                        data.user.role === UserRole.ADMIN
+                                            ? styles.badgeAdmin
+                                            : styles.badgeMuted
+                                    }`}
+                                >
+                                    {data.user.role}
+                                </span>
+                            </div>
+                        </div>
+                    </section>
+
+                    <section className={styles.card}>
+                        <h2 className={styles.cardTitle}>Subscription</h2>
+                        <div className={styles.fields}>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Status</span>
+                                <span
+                                    className={`${styles.badge} ${
+                                        isPro(data.user.isProUntil)
+                                            ? styles.badgePro
+                                            : styles.badgeMuted
+                                    }`}
+                                >
+                                    {isPro(data.user.isProUntil) ? "Pro" : "Free"}
+                                </span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Pro until</span>
+                                <span className={styles.fieldValue}>
+                                    {formatDateTime(data.user.isProUntil)}
+                                </span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Provider</span>
+                                <span className={styles.fieldValue}>
+                                    {data.user.subscriptionProvider ?? "—"}
+                                </span>
+                            </div>
+                            <div className={styles.field}>
+                                <span className={styles.fieldLabel}>Cancelled</span>
+                                <span
+                                    className={`${styles.badge} ${
+                                        data.user.isSubscriptionCancelled
+                                            ? styles.badgeDanger
+                                            : styles.badgeMuted
+                                    }`}
+                                >
+                                    {data.user.isSubscriptionCancelled ? "Yes" : "No"}
+                                </span>
+                            </div>
+                        </div>
+                    </section>
+
+                    <section className={styles.card}>
+                        <h2 className={styles.cardTitle}>
+                            Projects ({data.projectCount})
+                        </h2>
+                        <div className={styles.table}>
+                            <div className={`${styles.tableRow} ${styles.tableHeader}`}>
+                                <span>Title</span>
+                                <span>Role</span>
+                                <span>Updated</span>
+                            </div>
+                            {!memberships && (
+                                <div className={styles.emptyRow}>Loading…</div>
+                            )}
+                            {memberships && memberships.length === 0 && (
+                                <div className={styles.emptyRow}>
+                                    This user has no projects.
+                                </div>
+                            )}
+                            {memberships?.map((m) => (
+                                <Link
+                                    key={m.project.id}
+                                    href={`/admin/projects/${m.project.id}`}
+                                    className={`${styles.tableRow} ${styles.tableRowLink}`}
+                                >
+                                    <span>{m.project.title}</span>
+                                    <span className={styles.tableCellMuted}>{m.role}</span>
+                                    <span className={styles.tableCellMuted}>
+                                        {formatDateTime(m.project.updatedAt)}
+                                    </span>
+                                </Link>
+                            ))}
+                        </div>
+                    </section>
+
+                    <section className={styles.card}>
+                        <h2 className={styles.cardTitle}>
+                            Transactions ({data.transactionCount})
+                        </h2>
+                        <div className={styles.table}>
+                            <div className={`${styles.tableRow} ${styles.tableHeader}`}>
+                                <span>Transaction ID</span>
+                                <span>Provider</span>
+                                <span>Created</span>
+                            </div>
+                            {!transactions && (
+                                <div className={styles.emptyRow}>Loading…</div>
+                            )}
+                            {transactions && transactions.length === 0 && (
+                                <div className={styles.emptyRow}>No transactions.</div>
+                            )}
+                            {transactions?.map((t) => (
+                                <div key={t.id} className={styles.tableRow}>
+                                    <span
+                                        className={styles.tableCellMono}
+                                        title={t.transactionId}
+                                    >
+                                        {t.transactionId}
+                                    </span>
+                                    <span className={styles.tableCellMuted}>{t.provider}</span>
+                                    <span className={styles.tableCellMuted}>
+                                        {formatDateTime(t.createdAt)}
+                                    </span>
+                                </div>
+                            ))}
+                        </div>
+                    </section>
+                </>
+            )}
+        </div>
+    );
+}
diff --git a/components/admin/UserSearch.module.css b/components/admin/UserSearch.module.css
new file mode 100644
index 00000000..69093ed7
--- /dev/null
+++ b/components/admin/UserSearch.module.css
@@ -0,0 +1,128 @@
+.container {
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+}
+
+.searchBar {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    background: var(--secondary);
+    border: 1px solid var(--input-outline);
+    border-radius: 10px;
+    padding: 10px 14px;
+    box-shadow: var(--panel-shadow);
+}
+
+.searchBar:focus-within {
+    border-color: var(--primary-text);
+}
+
+.searchInput {
+    flex: 1;
+    background: transparent;
+    border: none;
+    outline: none;
+    color: var(--primary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+}
+
+.hint {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 13px;
+    padding: 4px 2px;
+}
+
+.resultList {
+    display: flex;
+    flex-direction: column;
+    border: 1px solid var(--separator);
+    border-radius: 10px;
+    overflow: hidden;
+    background: var(--secondary);
+}
+
+.resultRow {
+    display: grid;
+    grid-template-columns: 1.5fr 1fr auto auto;
+    gap: 16px;
+    align-items: center;
+    padding: 14px 18px;
+    border: none;
+    border-bottom: 1px solid var(--separator);
+    background: transparent;
+    color: var(--primary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+    text-align: left;
+    text-decoration: none;
+    cursor: pointer;
+    transition: background-color 120ms ease;
+}
+
+.resultRow:last-child {
+    border-bottom: none;
+}
+
+.resultRow:hover {
+    background: var(--primary-hover);
+}
+
+.email {
+    font-weight: 600;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.id {
+    color: var(--secondary-text);
+    font-family: var(--font-courier), monospace;
+    font-size: 12px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.badge {
+    display: inline-flex;
+    align-items: center;
+    padding: 3px 10px;
+    border-radius: 999px;
+    font-size: 11px;
+    font-weight: 600;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+}
+
+.badgePro {
+    background: color-mix(in srgb, var(--success) 22%, transparent);
+    color: var(--success);
+}
+
+.badgeAdmin {
+    background: color-mix(in srgb, var(--warning) 25%, transparent);
+    color: var(--warning);
+}
+
+.badgeMuted {
+    background: var(--tertiary);
+    color: var(--secondary-text);
+}
+
+.date {
+    color: var(--secondary-text);
+    font-size: 12px;
+    white-space: nowrap;
+}
+
+.empty {
+    color: var(--secondary-text);
+    font-family: var(--font-inter), sans-serif;
+    font-size: 14px;
+    padding: 24px;
+    text-align: center;
+}
diff --git a/components/admin/UserSearch.tsx b/components/admin/UserSearch.tsx
new file mode 100644
index 00000000..ad5c8499
--- /dev/null
+++ b/components/admin/UserSearch.tsx
@@ -0,0 +1,100 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import useSWR from "swr";
+import Link from "next/link";
+import { Search } from "lucide-react";
+import { UserRole, SubscriptionProvider } from "../../src/generated/client/browser";
+import styles from "./UserSearch.module.css";
+
+type SearchResult = {
+    id: string;
+    email: string;
+    createdAt: string;
+    role: UserRole;
+    isProUntil: string | null;
+    subscriptionProvider: SubscriptionProvider | null;
+};
+
+type SearchResponse = {
+    users: SearchResult[];
+    nextCursor: number | null;
+};
+
+function formatDate(iso: string) {
+    const d = new Date(iso);
+    return d.toLocaleDateString(undefined, { year: "numeric", month: "short", day: "numeric" });
+}
+
+function isPro(isProUntil: string | null) {
+    return !!isProUntil && new Date(isProUntil) > new Date();
+}
+
+export default function UserSearch() {
+    const [query, setQuery] = useState("");
+    const [debounced, setDebounced] = useState("");
+
+    useEffect(() => {
+        const t = setTimeout(() => setDebounced(query.trim()), 250);
+        return () => clearTimeout(t);
+    }, [query]);
+
+    const key = debounced ? `/api/admin/users?q=${encodeURIComponent(debounced)}` : null;
+    const { data, isLoading } = useSWR<SearchResponse>(key);
+
+    return (
+        <div className={styles.container}>
+            <div className={styles.searchBar}>
+                <Search size={16} />
+                <input
+                    className={styles.searchInput}
+                    placeholder="Search by email or user ID"
+                    value={query}
+                    onChange={(e) => setQuery(e.target.value)}
+                    autoFocus
+                />
+            </div>
+
+            {!debounced && (
+                <p className={styles.hint}>
+                    Start typing an email (partial, case-insensitive) or paste a full user ID.
+                </p>
+            )}
+
+            {debounced && isLoading && <p className={styles.hint}>Searching…</p>}
+
+            {debounced && data && data.users.length === 0 && (
+                <div className={styles.resultList}>
+                    <div className={styles.empty}>No users match &quot;{debounced}&quot;.</div>
+                </div>
+            )}
+
+            {data && data.users.length > 0 && (
+                <div className={styles.resultList}>
+                    {data.users.map((u) => (
+                        <Link key={u.id} href={`/admin/users/${u.id}`} className={styles.resultRow}>
+                            <span className={styles.email}>{u.email}</span>
+                            <span className={styles.id}>{u.id}</span>
+                            <span
+                                className={`${styles.badge} ${
+                                    u.role === UserRole.ADMIN
+                                        ? styles.badgeAdmin
+                                        : isPro(u.isProUntil)
+                                          ? styles.badgePro
+                                          : styles.badgeMuted
+                                }`}
+                            >
+                                {u.role === UserRole.ADMIN
+                                    ? "Admin"
+                                    : isPro(u.isProUntil)
+                                      ? "Pro"
+                                      : "Free"}
+                            </span>
+                            <span className={styles.date}>{formatDate(u.createdAt)}</span>
+                        </Link>
+                    ))}
+                </div>
+            )}
+        </div>
+    );
+}
diff --git a/components/dashboard/project/CollaboratorsSettings.tsx b/components/dashboard/project/CollaboratorsSettings.tsx
index 05c3d6e7..7d98ce24 100644
--- a/components/dashboard/project/CollaboratorsSettings.tsx
+++ b/components/dashboard/project/CollaboratorsSettings.tsx
@@ -4,7 +4,7 @@ import { useContext, useMemo, useState } from "react";
 import { useTranslations } from "next-intl";
 import { useCookieUser, useIsPro, useProjectCollaborators, useProjectInvites, useProjectMembership } from "@src/lib/utils/hooks";
 import { CookieUser } from "@src/lib/utils/types";
-import { ProjectRole } from "@prisma/client";
+import { ProjectRole } from "../../../src/generated/client/browser";
 import { Collaborator, ProjectInvite, ProjectMembershipPayload } from "@src/server/repository/project-repository";
 import { Info, Lock } from "lucide-react";
 
diff --git a/docker-compose.yml b/docker-compose.yml
index 9a4ae7f7..ab348deb 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -114,6 +114,71 @@ services:
             timeout: 5s
             retries: 5
 
+    prometheus:
+        image: prom/prometheus:latest
+        container_name: scriptio-prometheus
+        profiles: ["prod"]
+        restart: unless-stopped
+        command:
+            - --config.file=/etc/prometheus/prometheus.yml
+            - --storage.tsdb.retention.time=30d
+        volumes:
+            - ./monitoring/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
+            - prometheus_data:/prometheus
+        configs:
+            - source: metrics_bearer_token
+              target: /etc/prometheus/bearer-token
+              mode: 0400
+        networks:
+            - internal
+        depends_on:
+            - app-prod
+
+    grafana:
+        image: grafana/grafana:latest
+        container_name: scriptio-grafana
+        profiles: ["prod"]
+        restart: unless-stopped
+        environment:
+            - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_ADMIN_PASSWORD}
+            - GF_SERVER_ROOT_URL=https://monitoring.scriptio.app
+            - GF_USERS_ALLOW_SIGN_UP=false
+            - GF_SMTP_ENABLED=true
+            - GF_SMTP_HOST=${SMTP_HOST}:587
+            - GF_SMTP_USER=${SMTP_USER}
+            - GF_SMTP_PASSWORD=${SMTP_SECRET}
+            - GF_SMTP_FROM_ADDRESS=noreply@scriptio.app
+            - GF_SMTP_FROM_NAME=Scriptio Monitoring
+            - APP_MEMORY_LIMIT_BYTES=${APP_MEMORY_LIMIT_BYTES}
+            - DB_SIZE_LIMIT_BYTES=${DB_SIZE_LIMIT_BYTES}
+        volumes:
+            - ./monitoring/grafana/provisioning:/etc/grafana/provisioning:ro
+            - ./monitoring/grafana/dashboards:/etc/grafana/dashboards:ro
+            - grafana_data:/var/lib/grafana
+        networks:
+            - webproxy
+            - internal
+        depends_on:
+            - prometheus
+        labels:
+            - traefik.enable=true
+            - traefik.docker.network=webproxy
+            - traefik.http.routers.scriptio-monitoring.rule=Host(`monitoring.scriptio.app`)
+            - traefik.http.routers.scriptio-monitoring.entrypoints=secure
+            - traefik.http.routers.scriptio-monitoring.tls=true
+            - traefik.http.routers.scriptio-monitoring.tls.certresolver=letsencrypt
+            - traefik.http.routers.scriptio-monitoring.middlewares=monitoring-auth
+            - traefik.http.middlewares.monitoring-auth.basicauth.users=${MONITORING_AUTH_USERS}
+            - traefik.http.services.scriptio-monitoring.loadbalancer.server.port=3000
+
+configs:
+    metrics_bearer_token:
+        content: ${METRICS_BEARER_TOKEN}
+
+volumes:
+    prometheus_data:
+    grafana_data:
+
 networks:
     webproxy:
         external: true
diff --git a/monitoring/grafana/dashboards/scriptio-overview.json b/monitoring/grafana/dashboards/scriptio-overview.json
new file mode 100644
index 00000000..351ccb6f
--- /dev/null
+++ b/monitoring/grafana/dashboards/scriptio-overview.json
@@ -0,0 +1,102 @@
+{
+    "uid": "scriptio-overview",
+    "title": "Scriptio Overview",
+    "timezone": "browser",
+    "schemaVersion": 39,
+    "refresh": "30s",
+    "time": { "from": "now-6h", "to": "now" },
+    "templating": {
+        "list": [
+            {
+                "name": "memory_limit_bytes",
+                "type": "constant",
+                "label": "Memory limit (bytes)",
+                "query": "${APP_MEMORY_LIMIT_BYTES}",
+                "current": { "value": "${APP_MEMORY_LIMIT_BYTES}", "text": "${APP_MEMORY_LIMIT_BYTES}" },
+                "hide": 2
+            },
+            {
+                "name": "db_size_limit_bytes",
+                "type": "constant",
+                "label": "DB size limit (bytes)",
+                "query": "${DB_SIZE_LIMIT_BYTES}",
+                "current": { "value": "${DB_SIZE_LIMIT_BYTES}", "text": "${DB_SIZE_LIMIT_BYTES}" },
+                "hide": 2
+            }
+        ]
+    },
+    "panels": [
+        {
+            "id": 1,
+            "type": "timeseries",
+            "title": "Database size",
+            "gridPos": { "h": 8, "w": 12, "x": 0, "y": 0 },
+            "datasource": { "type": "prometheus", "uid": "prometheus" },
+            "fieldConfig": {
+                "defaults": { "unit": "bytes" },
+                "overrides": []
+            },
+            "targets": [
+                {
+                    "refId": "A",
+                    "expr": "scriptio_db_size_bytes",
+                    "legendFormat": "DB size"
+                }
+            ]
+        },
+        {
+            "id": 2,
+            "type": "timeseries",
+            "title": "HTTP error rate (4xx + 5xx)",
+            "gridPos": { "h": 8, "w": 12, "x": 12, "y": 0 },
+            "datasource": { "type": "prometheus", "uid": "prometheus" },
+            "fieldConfig": {
+                "defaults": { "unit": "percentunit", "min": 0, "max": 1 },
+                "overrides": []
+            },
+            "targets": [
+                {
+                    "refId": "A",
+                    "expr": "sum(rate(http_requests_total{status=~\"4..|5..\"}[5m])) / sum(rate(http_requests_total[5m]))",
+                    "legendFormat": "error rate"
+                }
+            ]
+        },
+        {
+            "id": 3,
+            "type": "timeseries",
+            "title": "CPU usage (% of one core)",
+            "gridPos": { "h": 8, "w": 12, "x": 0, "y": 8 },
+            "datasource": { "type": "prometheus", "uid": "prometheus" },
+            "fieldConfig": {
+                "defaults": { "unit": "percent", "min": 0 },
+                "overrides": []
+            },
+            "targets": [
+                {
+                    "refId": "A",
+                    "expr": "rate(process_cpu_seconds_total[2m]) * 100",
+                    "legendFormat": "cpu %"
+                }
+            ]
+        },
+        {
+            "id": 4,
+            "type": "timeseries",
+            "title": "Memory usage (% of APP_MEMORY_LIMIT_BYTES)",
+            "gridPos": { "h": 8, "w": 12, "x": 12, "y": 8 },
+            "datasource": { "type": "prometheus", "uid": "prometheus" },
+            "fieldConfig": {
+                "defaults": { "unit": "percent", "min": 0, "max": 100 },
+                "overrides": []
+            },
+            "targets": [
+                {
+                    "refId": "A",
+                    "expr": "process_resident_memory_bytes / $memory_limit_bytes * 100",
+                    "legendFormat": "memory %"
+                }
+            ]
+        }
+    ]
+}
diff --git a/monitoring/grafana/provisioning/alerting/contact-points.yml b/monitoring/grafana/provisioning/alerting/contact-points.yml
new file mode 100644
index 00000000..f2f16f36
--- /dev/null
+++ b/monitoring/grafana/provisioning/alerting/contact-points.yml
@@ -0,0 +1,11 @@
+apiVersion: 1
+
+contactPoints:
+    - orgId: 1
+      name: scriptio-email
+      receivers:
+          - uid: scriptio-email
+            type: email
+            settings:
+                addresses: hugo.bois@hotmail.fr
+                singleEmail: true
diff --git a/monitoring/grafana/provisioning/alerting/notification-policies.yml b/monitoring/grafana/provisioning/alerting/notification-policies.yml
new file mode 100644
index 00000000..bcb35290
--- /dev/null
+++ b/monitoring/grafana/provisioning/alerting/notification-policies.yml
@@ -0,0 +1,9 @@
+apiVersion: 1
+
+policies:
+    - orgId: 1
+      receiver: scriptio-email
+      group_by: [alertname]
+      group_wait: 30s
+      group_interval: 5m
+      repeat_interval: 6h
diff --git a/monitoring/grafana/provisioning/alerting/rules.yml b/monitoring/grafana/provisioning/alerting/rules.yml
new file mode 100644
index 00000000..c78106dc
--- /dev/null
+++ b/monitoring/grafana/provisioning/alerting/rules.yml
@@ -0,0 +1,73 @@
+apiVersion: 1
+
+groups:
+    - orgId: 1
+      name: scriptio-app
+      folder: scriptio
+      interval: 1m
+      rules:
+          - uid: scriptio-http-error-rate
+            title: HighHttpErrorRate
+            condition: C
+            data:
+                - refId: A
+                  relativeTimeRange:
+                      from: 600
+                      to: 0
+                  datasourceUid: prometheus
+                  model:
+                      refId: A
+                      expr: sum(rate(http_requests_total{status=~"4..|5.."}[5m])) / sum(rate(http_requests_total[5m]))
+                      instant: true
+                - refId: C
+                  relativeTimeRange:
+                      from: 600
+                      to: 0
+                  datasourceUid: __expr__
+                  model:
+                      refId: C
+                      type: threshold
+                      expression: A
+                      conditions:
+                          - evaluator:
+                                type: gt
+                                params: [0.05]
+            for: 5m
+            noDataState: OK
+            execErrState: Error
+            annotations:
+                summary: HTTP error rate above 5%
+                description: "{{ $value | printf \"%.2f\" }} of requests in the last 5 minutes returned a 4xx/5xx status."
+
+          - uid: scriptio-db-almost-full
+            title: DbAlmostFull
+            condition: C
+            data:
+                - refId: A
+                  relativeTimeRange:
+                      from: 600
+                      to: 0
+                  datasourceUid: prometheus
+                  model:
+                      refId: A
+                      expr: scriptio_db_size_bytes / ${DB_SIZE_LIMIT_BYTES}
+                      instant: true
+                - refId: C
+                  relativeTimeRange:
+                      from: 600
+                      to: 0
+                  datasourceUid: __expr__
+                  model:
+                      refId: C
+                      type: threshold
+                      expression: A
+                      conditions:
+                          - evaluator:
+                                type: gt
+                                params: [0.85]
+            for: 10m
+            noDataState: OK
+            execErrState: Error
+            annotations:
+                summary: Database is approaching its capacity ceiling
+                description: "DB is at {{ $value | humanizePercentage }} of the configured DB_SIZE_LIMIT_BYTES."
diff --git a/monitoring/grafana/provisioning/dashboards/dashboards.yml b/monitoring/grafana/provisioning/dashboards/dashboards.yml
new file mode 100644
index 00000000..cba8dccc
--- /dev/null
+++ b/monitoring/grafana/provisioning/dashboards/dashboards.yml
@@ -0,0 +1,13 @@
+apiVersion: 1
+
+providers:
+    - name: scriptio
+      orgId: 1
+      folder: ""
+      type: file
+      disableDeletion: true
+      updateIntervalSeconds: 30
+      allowUiUpdates: false
+      options:
+          path: /etc/grafana/dashboards
+          foldersFromFilesStructure: false
diff --git a/monitoring/grafana/provisioning/datasources/prometheus.yml b/monitoring/grafana/provisioning/datasources/prometheus.yml
new file mode 100644
index 00000000..8967eb69
--- /dev/null
+++ b/monitoring/grafana/provisioning/datasources/prometheus.yml
@@ -0,0 +1,10 @@
+apiVersion: 1
+
+datasources:
+    - name: Prometheus
+      uid: prometheus
+      type: prometheus
+      access: proxy
+      url: http://prometheus:9090
+      isDefault: true
+      editable: false
diff --git a/monitoring/prometheus/prometheus.yml b/monitoring/prometheus/prometheus.yml
new file mode 100644
index 00000000..ea137064
--- /dev/null
+++ b/monitoring/prometheus/prometheus.yml
@@ -0,0 +1,13 @@
+global:
+    scrape_interval: 15s
+    evaluation_interval: 15s
+
+scrape_configs:
+    - job_name: app-prod
+      metrics_path: /api/metrics
+      scheme: http
+      authorization:
+          type: Bearer
+          credentials_file: /etc/prometheus/bearer-token
+      static_configs:
+          - targets: ["app-prod:3000"]
diff --git a/next.config.ts b/next.config.ts
index 7fac6fcd..6f17229b 100644
--- a/next.config.ts
+++ b/next.config.ts
@@ -22,4 +22,4 @@ const config: NextConfig = {
     },
 };
 
-module.exports = config;
+export default config;
diff --git a/package-lock.json b/package-lock.json
index 0a60567c..8ff438d4 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14,13 +14,13 @@
                 "@aws-sdk/s3-request-presigner": "^3.952.0",
                 "@choochmeque/tauri-plugin-iap-api": "^0.8.2",
                 "@formkit/auto-animate": "^0.7.0",
-                "@prisma/client": "^6.19.0",
+                "@prisma/adapter-pg": "^7.8.0",
+                "@prisma/client": "^7.7.0",
                 "@svgr/core": "^8.1.0",
                 "@tauri-apps/api": "2.10.1",
                 "@tauri-apps/plugin-dialog": "2.6.0",
                 "@tauri-apps/plugin-fs": "2.4.5",
                 "@tauri-apps/plugin-opener": "2.5.3",
-                "@tauri-apps/plugin-sql": "2.3.2",
                 "@tauri-apps/plugin-store": "^2.4.2",
                 "@tiptap/extension-bold": "^3.13.0",
                 "@tiptap/extension-collaboration": "^3.13.0",
@@ -52,6 +52,8 @@
                 "next-themes": "^0.2.0",
                 "nodemailer": "^7.0.12",
                 "pdfmake": "^0.2.9",
+                "pg": "^8.20.0",
+                "prom-client": "^15.1.3",
                 "react": "^19.2.4",
                 "react-chartjs-2": "^5.2.0",
                 "react-dom": "^19.2.4",
@@ -77,6 +79,7 @@
                 "@types/node": "20.11.0",
                 "@types/nodemailer": "^6.4.14",
                 "@types/pdfmake": "^0.2.12",
+                "@types/pg": "^8.20.0",
                 "@types/react": "^18.3.27",
                 "@types/react-dom": "^18.3.7",
                 "@types/uuid": "^10.0.0",
@@ -91,9 +94,9 @@
                 "eslint-plugin-react-hooks": "^7.0.1",
                 "patch-package": "^8.0.1",
                 "playwright": "^1.58.2",
-                "prisma": "^6.19.0",
+                "prisma": "^7.7.0",
                 "tsx": "^4.21.0",
-                "typescript": "^5.1.3",
+                "typescript": "^5.7.3",
                 "typescript-plugin-css-modules": "^5.2.0",
                 "vite": "^6.4.1",
                 "vitest": "^3.2.4",
@@ -3056,6 +3059,36 @@
                 "@jridgewell/sourcemap-codec": "^1.4.10"
             }
         },
+        "node_modules/@electric-sql/pglite": {
+            "version": "0.4.1",
+            "resolved": "https://registry.npmjs.org/@electric-sql/pglite/-/pglite-0.4.1.tgz",
+            "integrity": "sha512-mZ9NzzUSYPOCnxHH1oAHPRzoMFJHY472raDKwXl/+6oPbpdJ7g8LsCN4FSaIIfkiCKHhb3iF/Zqo3NYxaIhU7Q==",
+            "devOptional": true,
+            "license": "Apache-2.0"
+        },
+        "node_modules/@electric-sql/pglite-socket": {
+            "version": "0.1.1",
+            "resolved": "https://registry.npmjs.org/@electric-sql/pglite-socket/-/pglite-socket-0.1.1.tgz",
+            "integrity": "sha512-p2hoXw3Z3LQHwTeikdZNsFBOvXGqKY2hk51BBw+8NKND8eoH+8LFOtW9Z8CQKmTJ2qqGYu82ipqiyFZOTTXNfw==",
+            "devOptional": true,
+            "license": "Apache-2.0",
+            "bin": {
+                "pglite-server": "dist/scripts/server.js"
+            },
+            "peerDependencies": {
+                "@electric-sql/pglite": "0.4.1"
+            }
+        },
+        "node_modules/@electric-sql/pglite-tools": {
+            "version": "0.3.1",
+            "resolved": "https://registry.npmjs.org/@electric-sql/pglite-tools/-/pglite-tools-0.3.1.tgz",
+            "integrity": "sha512-C+T3oivmy9bpQvSxVqXA1UDY8cB9Eb9vZHL9zxWwEUfDixbXv4G3r2LjoTdR33LD8aomR3O9ZXEO3XEwr/cUCA==",
+            "devOptional": true,
+            "license": "Apache-2.0",
+            "peerDependencies": {
+                "@electric-sql/pglite": "0.4.1"
+            }
+        },
         "node_modules/@emnapi/core": {
             "version": "1.7.1",
             "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.7.1.tgz",
@@ -3904,6 +3937,19 @@
                 "@hapi/hoek": "^11.0.2"
             }
         },
+        "node_modules/@hono/node-server": {
+            "version": "1.19.11",
+            "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.11.tgz",
+            "integrity": "sha512-dr8/3zEaB+p0D2n/IUrlPF1HZm586qgJNXK1a9fhg/PzdtkK7Ksd5l312tJX2yBuALqDYBlG20QEbayqPyxn+g==",
+            "devOptional": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=18.14.1"
+            },
+            "peerDependencies": {
+                "hono": "^4"
+            }
+        },
         "node_modules/@humanfs/core": {
             "version": "0.19.1",
             "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
@@ -5320,6 +5366,15 @@
                 "node": ">=12.4.0"
             }
         },
+        "node_modules/@opentelemetry/api": {
+            "version": "1.9.1",
+            "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.1.tgz",
+            "integrity": "sha512-gLyJlPHPZYdAk1JENA9LeHejZe1Ti77/pTeFm/nMXmQH/HFZlcS/O2XJB+L8fkbrNSqhdtlvjBVjxwUYanNH5Q==",
+            "license": "Apache-2.0",
+            "engines": {
+                "node": ">=8.0.0"
+            }
+        },
         "node_modules/@panva/hkdf": {
             "version": "1.2.1",
             "resolved": "https://registry.npmjs.org/@panva/hkdf/-/hkdf-1.2.1.tgz",
@@ -5691,18 +5746,32 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/@prisma/adapter-pg": {
+            "version": "7.8.0",
+            "resolved": "https://registry.npmjs.org/@prisma/adapter-pg/-/adapter-pg-7.8.0.tgz",
+            "integrity": "sha512-ygb3UkerK3v8MDpXVgCISdRNDozpxh6+JVJgiIGbSr5KBgz10LLf5ejUskPGoXlsIjxsOu6nuy1JVQr2EKGSlg==",
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@prisma/driver-adapter-utils": "7.8.0",
+                "@types/pg": "^8.16.0",
+                "pg": "^8.16.3",
+                "postgres-array": "3.0.4"
+            }
+        },
         "node_modules/@prisma/client": {
-            "version": "6.19.1",
-            "resolved": "https://registry.npmjs.org/@prisma/client/-/client-6.19.1.tgz",
-            "integrity": "sha512-4SXj4Oo6HyQkLUWT8Ke5R0PTAfVOKip5Roo+6+b2EDTkFg5be0FnBWiuRJc0BC0sRQIWGMLKW1XguhVfW/z3/A==",
-            "hasInstallScript": true,
+            "version": "7.7.0",
+            "resolved": "https://registry.npmjs.org/@prisma/client/-/client-7.7.0.tgz",
+            "integrity": "sha512-5Ar4OsZpJ54s21sy5oDNNW9gQtd4NuxCaiM7+JDTOU07D6VvlpLjYzAVCMB1+JzokN+08dAVomlx+b7bhJd3ww==",
             "license": "Apache-2.0",
+            "dependencies": {
+                "@prisma/client-runtime-utils": "7.7.0"
+            },
             "engines": {
-                "node": ">=18.18"
+                "node": "^20.19 || ^22.12 || >=24.0"
             },
             "peerDependencies": {
                 "prisma": "*",
-                "typescript": ">=5.1.0"
+                "typescript": ">=5.4.0"
             },
             "peerDependenciesMeta": {
                 "prisma": {
@@ -5713,67 +5782,363 @@
                 }
             }
         },
+        "node_modules/@prisma/client-runtime-utils": {
+            "version": "7.7.0",
+            "resolved": "https://registry.npmjs.org/@prisma/client-runtime-utils/-/client-runtime-utils-7.7.0.tgz",
+            "integrity": "sha512-BLyd0UpFYOtyJFTHm7jS9vesHW7P83abibodQMiIofqjBKzDHQ1VAsQkdfvXyYDkPlONPfOTz7/rv3x/+CQqvQ==",
+            "license": "Apache-2.0"
+        },
         "node_modules/@prisma/config": {
-            "version": "6.19.1",
-            "resolved": "https://registry.npmjs.org/@prisma/config/-/config-6.19.1.tgz",
-            "integrity": "sha512-bUL/aYkGXLwxVGhJmQMtslLT7KPEfUqmRa919fKI4wQFX4bIFUKiY8Jmio/2waAjjPYrtuDHa7EsNCnJTXxiOw==",
+            "version": "7.7.0",
+            "resolved": "https://registry.npmjs.org/@prisma/config/-/config-7.7.0.tgz",
+            "integrity": "sha512-hmPI3tKLO2aP0Y5vugbjcnA9qqlfJndiT6ds4tw28U5hNHLWg+mHJEWAhjsSPgxjtmxhJ/EDIeIlyh+3Us0OPg==",
             "devOptional": true,
             "license": "Apache-2.0",
             "dependencies": {
                 "c12": "3.1.0",
                 "deepmerge-ts": "7.1.5",
-                "effect": "3.18.4",
+                "effect": "3.20.0",
                 "empathic": "2.0.0"
             }
         },
         "node_modules/@prisma/debug": {
-            "version": "6.19.1",
-            "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-6.19.1.tgz",
-            "integrity": "sha512-h1JImhlAd/s5nhY/e9qkAzausWldbeT+e4nZF7A4zjDYBF4BZmKDt4y0jK7EZapqOm1kW7V0e9agV/iFDy3fWw==",
-            "devOptional": true,
+            "version": "7.8.0",
+            "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-7.8.0.tgz",
+            "integrity": "sha512-p+QZReysDUqXC+mk17q9a+Y/qzh4c2KYliDK30buYUyfrGeTGSyfmc0AIrJRhZJrLHhRiJa9Au/J72h3C+szvA==",
             "license": "Apache-2.0"
         },
+        "node_modules/@prisma/dev": {
+            "version": "0.24.3",
+            "resolved": "https://registry.npmjs.org/@prisma/dev/-/dev-0.24.3.tgz",
+            "integrity": "sha512-ffHlQuKXZiaDt9Go0OnCTdJZrHxK0k7omJKNV86/VjpsXu5EIHZLK0T7JSWgvNlJwh56kW9JFu9v0qJciFzepg==",
+            "devOptional": true,
+            "license": "ISC",
+            "dependencies": {
+                "@electric-sql/pglite": "0.4.1",
+                "@electric-sql/pglite-socket": "0.1.1",
+                "@electric-sql/pglite-tools": "0.3.1",
+                "@hono/node-server": "1.19.11",
+                "@prisma/get-platform": "7.2.0",
+                "@prisma/query-plan-executor": "7.2.0",
+                "@prisma/streams-local": "0.1.2",
+                "foreground-child": "3.3.1",
+                "get-port-please": "3.2.0",
+                "hono": "^4.12.8",
+                "http-status-codes": "2.3.0",
+                "pathe": "2.0.3",
+                "proper-lockfile": "4.1.2",
+                "remeda": "2.33.4",
+                "std-env": "3.10.0",
+                "valibot": "1.2.0",
+                "zeptomatch": "2.1.0"
+            }
+        },
+        "node_modules/@prisma/driver-adapter-utils": {
+            "version": "7.8.0",
+            "resolved": "https://registry.npmjs.org/@prisma/driver-adapter-utils/-/driver-adapter-utils-7.8.0.tgz",
+            "integrity": "sha512-/Q13o0ZT0rjc1Xk0Q9KhZYwuq2EW/vSbWUBKfgEKkaCuB/Sg6bqnjmTZqC5cD4d6y1vfFAEwBRzfzoSMIVJ55A==",
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@prisma/debug": "7.8.0"
+            }
+        },
         "node_modules/@prisma/engines": {
-            "version": "6.19.1",
-            "resolved": "https://registry.npmjs.org/@prisma/engines/-/engines-6.19.1.tgz",
-            "integrity": "sha512-xy95dNJ7DiPf9IJ3oaVfX785nbFl7oNDzclUF+DIiJw6WdWCvPl0LPU0YqQLsrwv8N64uOQkH391ujo3wSo+Nw==",
+            "version": "7.7.0",
+            "resolved": "https://registry.npmjs.org/@prisma/engines/-/engines-7.7.0.tgz",
+            "integrity": "sha512-7fmcbT7HHXBq/b+3h/dO1JI3fd8l8q7erf7xP7pRprh58hmSSnG8mg9K3yjW3h9WaHWUwngVFpSxxxivaitQ2w==",
             "devOptional": true,
             "hasInstallScript": true,
             "license": "Apache-2.0",
             "dependencies": {
-                "@prisma/debug": "6.19.1",
-                "@prisma/engines-version": "7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",
-                "@prisma/fetch-engine": "6.19.1",
-                "@prisma/get-platform": "6.19.1"
+                "@prisma/debug": "7.7.0",
+                "@prisma/engines-version": "7.6.0-1.75cbdc1eb7150937890ad5465d861175c6624711",
+                "@prisma/fetch-engine": "7.7.0",
+                "@prisma/get-platform": "7.7.0"
             }
         },
         "node_modules/@prisma/engines-version": {
-            "version": "7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",
-            "resolved": "https://registry.npmjs.org/@prisma/engines-version/-/engines-version-7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7.tgz",
-            "integrity": "sha512-03bgb1VD5gvuumNf+7fVGBzfpJPjmqV423l/WxsWk2cNQ42JD0/SsFBPhN6z8iAvdHs07/7ei77SKu7aZfq8bA==",
+            "version": "7.6.0-1.75cbdc1eb7150937890ad5465d861175c6624711",
+            "resolved": "https://registry.npmjs.org/@prisma/engines-version/-/engines-version-7.6.0-1.75cbdc1eb7150937890ad5465d861175c6624711.tgz",
+            "integrity": "sha512-r51DLcJ8bDRSrBEJF3J4cinoWyGA7rfP2mG6lD90VqIbGNOkbfcLcXalSVjq5Y6brQS3vcjrq4GbyUb1Cb7vkw==",
+            "devOptional": true,
+            "license": "Apache-2.0"
+        },
+        "node_modules/@prisma/engines/node_modules/@prisma/debug": {
+            "version": "7.7.0",
+            "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-7.7.0.tgz",
+            "integrity": "sha512-12J62XdqCmpiwJHhHdQxZeY3ckVCWIFmcJP8hg5dPTceeiQ0wiojXGFYTluKqFQfu46fRLgb/rLALZMAx3+dTA==",
             "devOptional": true,
             "license": "Apache-2.0"
         },
+        "node_modules/@prisma/engines/node_modules/@prisma/get-platform": {
+            "version": "7.7.0",
+            "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-7.7.0.tgz",
+            "integrity": "sha512-MEUNzvKxvYnJ7kgvd6oNRnMmmiGNS9TYLB2weMeIXplnHdL/UWEGnvavYGnN7KLJ2n0iI4dDAyzSkHI3c7AscQ==",
+            "devOptional": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@prisma/debug": "7.7.0"
+            }
+        },
         "node_modules/@prisma/fetch-engine": {
-            "version": "6.19.1",
-            "resolved": "https://registry.npmjs.org/@prisma/fetch-engine/-/fetch-engine-6.19.1.tgz",
-            "integrity": "sha512-mmgcotdaq4VtAHO6keov3db+hqlBzQS6X7tR7dFCbvXjLVTxBYdSJFRWz+dq7F9p6dvWyy1X0v8BlfRixyQK6g==",
+            "version": "7.7.0",
+            "resolved": "https://registry.npmjs.org/@prisma/fetch-engine/-/fetch-engine-7.7.0.tgz",
+            "integrity": "sha512-TfyzveBQoK4xALzsTpVhB/0KG1N8zOK0ap+RnBMkzGUu3f98fnQ4QtXa2wlKPhsO2X8a3N5ugFQgcKNoHGmDfw==",
+            "devOptional": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@prisma/debug": "7.7.0",
+                "@prisma/engines-version": "7.6.0-1.75cbdc1eb7150937890ad5465d861175c6624711",
+                "@prisma/get-platform": "7.7.0"
+            }
+        },
+        "node_modules/@prisma/fetch-engine/node_modules/@prisma/debug": {
+            "version": "7.7.0",
+            "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-7.7.0.tgz",
+            "integrity": "sha512-12J62XdqCmpiwJHhHdQxZeY3ckVCWIFmcJP8hg5dPTceeiQ0wiojXGFYTluKqFQfu46fRLgb/rLALZMAx3+dTA==",
+            "devOptional": true,
+            "license": "Apache-2.0"
+        },
+        "node_modules/@prisma/fetch-engine/node_modules/@prisma/get-platform": {
+            "version": "7.7.0",
+            "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-7.7.0.tgz",
+            "integrity": "sha512-MEUNzvKxvYnJ7kgvd6oNRnMmmiGNS9TYLB2weMeIXplnHdL/UWEGnvavYGnN7KLJ2n0iI4dDAyzSkHI3c7AscQ==",
             "devOptional": true,
             "license": "Apache-2.0",
             "dependencies": {
-                "@prisma/debug": "6.19.1",
-                "@prisma/engines-version": "7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",
-                "@prisma/get-platform": "6.19.1"
+                "@prisma/debug": "7.7.0"
             }
         },
         "node_modules/@prisma/get-platform": {
-            "version": "6.19.1",
-            "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-6.19.1.tgz",
-            "integrity": "sha512-zsg44QUiQAnFUyh6Fbt7c9HjMXHwFTqtrgcX7DAZmRgnkPyYT7Sh8Mn8D5PuuDYNtMOYcpLGg576MLfIORsBYw==",
+            "version": "7.2.0",
+            "resolved": "https://registry.npmjs.org/@prisma/get-platform/-/get-platform-7.2.0.tgz",
+            "integrity": "sha512-k1V0l0Td1732EHpAfi2eySTezyllok9dXb6UQanajkJQzPUGi3vO2z7jdkz67SypFTdmbnyGYxvEvYZdZsMAVA==",
+            "devOptional": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@prisma/debug": "7.2.0"
+            }
+        },
+        "node_modules/@prisma/get-platform/node_modules/@prisma/debug": {
+            "version": "7.2.0",
+            "resolved": "https://registry.npmjs.org/@prisma/debug/-/debug-7.2.0.tgz",
+            "integrity": "sha512-YSGTiSlBAVJPzX4ONZmMotL+ozJwQjRmZweQNIq/ER0tQJKJynNkRB3kyvt37eOfsbMCXk3gnLF6J9OJ4QWftw==",
+            "devOptional": true,
+            "license": "Apache-2.0"
+        },
+        "node_modules/@prisma/query-plan-executor": {
+            "version": "7.2.0",
+            "resolved": "https://registry.npmjs.org/@prisma/query-plan-executor/-/query-plan-executor-7.2.0.tgz",
+            "integrity": "sha512-EOZmNzcV8uJ0mae3DhTsiHgoNCuu1J9mULQpGCh62zN3PxPTd+qI9tJvk5jOst8WHKQNwJWR3b39t0XvfBB0WQ==",
+            "devOptional": true,
+            "license": "Apache-2.0"
+        },
+        "node_modules/@prisma/streams-local": {
+            "version": "0.1.2",
+            "resolved": "https://registry.npmjs.org/@prisma/streams-local/-/streams-local-0.1.2.tgz",
+            "integrity": "sha512-l49yTxKKF2odFxaAXTmwmkBKL3+bVQ1tFOooGifu4xkdb9NMNLxHj27XAhTylWZod8I+ISGM5erU1xcl/oBCtg==",
+            "devOptional": true,
+            "license": "Apache-2.0",
+            "dependencies": {
+                "ajv": "^8.12.0",
+                "better-result": "^2.7.0",
+                "env-paths": "^3.0.0",
+                "proper-lockfile": "^4.1.2"
+            },
+            "engines": {
+                "bun": ">=1.3.6",
+                "node": ">=22.0.0"
+            }
+        },
+        "node_modules/@prisma/streams-local/node_modules/ajv": {
+            "version": "8.18.0",
+            "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.18.0.tgz",
+            "integrity": "sha512-PlXPeEWMXMZ7sPYOHqmDyCJzcfNrUr3fGNKtezX14ykXOEIvyK81d+qydx89KY5O71FKMPaQ2vBfBFI5NHR63A==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "fast-deep-equal": "^3.1.3",
+                "fast-uri": "^3.0.1",
+                "json-schema-traverse": "^1.0.0",
+                "require-from-string": "^2.0.2"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/epoberezkin"
+            }
+        },
+        "node_modules/@prisma/streams-local/node_modules/json-schema-traverse": {
+            "version": "1.0.0",
+            "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+            "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+            "devOptional": true,
+            "license": "MIT"
+        },
+        "node_modules/@prisma/studio-core": {
+            "version": "0.27.3",
+            "resolved": "https://registry.npmjs.org/@prisma/studio-core/-/studio-core-0.27.3.tgz",
+            "integrity": "sha512-AADjNFPdsrglxHQVTmHFqv6DuKQZ5WY4p5/gVFY017twvNrSwpLJ9lqUbYYxEu2W7nbvVxTZA8deJ8LseNALsw==",
             "devOptional": true,
             "license": "Apache-2.0",
             "dependencies": {
-                "@prisma/debug": "6.19.1"
+                "@radix-ui/react-toggle": "1.1.10",
+                "chart.js": "4.5.1"
+            },
+            "engines": {
+                "node": "^20.19 || ^22.12 || >=24.0",
+                "pnpm": "8"
+            },
+            "peerDependencies": {
+                "@types/react": "^18.0.0 || ^19.0.0",
+                "react": "^18.0.0 || ^19.0.0",
+                "react-dom": "^18.0.0 || ^19.0.0"
+            }
+        },
+        "node_modules/@prisma/studio-core/node_modules/@radix-ui/react-toggle": {
+            "version": "1.1.10",
+            "resolved": "https://registry.npmjs.org/@radix-ui/react-toggle/-/react-toggle-1.1.10.tgz",
+            "integrity": "sha512-lS1odchhFTeZv3xwHH31YPObmJn8gOg7Lq12inrr0+BH/l3Tsq32VfjqH1oh80ARM3mlkfMic15n0kg4sD1poQ==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "@radix-ui/primitive": "1.1.3",
+                "@radix-ui/react-primitive": "2.1.3",
+                "@radix-ui/react-use-controllable-state": "1.2.2"
+            },
+            "peerDependencies": {
+                "@types/react": "*",
+                "@types/react-dom": "*",
+                "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+                "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+            },
+            "peerDependenciesMeta": {
+                "@types/react": {
+                    "optional": true
+                },
+                "@types/react-dom": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@prisma/studio-core/node_modules/@radix-ui/react-toggle/node_modules/@radix-ui/react-primitive": {
+            "version": "2.1.3",
+            "resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
+            "integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "@radix-ui/react-slot": "1.2.3"
+            },
+            "peerDependencies": {
+                "@types/react": "*",
+                "@types/react-dom": "*",
+                "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+                "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+            },
+            "peerDependenciesMeta": {
+                "@types/react": {
+                    "optional": true
+                },
+                "@types/react-dom": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@radix-ui/primitive": {
+            "version": "1.1.3",
+            "resolved": "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.3.tgz",
+            "integrity": "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==",
+            "devOptional": true,
+            "license": "MIT"
+        },
+        "node_modules/@radix-ui/react-compose-refs": {
+            "version": "1.1.2",
+            "resolved": "https://registry.npmjs.org/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.2.tgz",
+            "integrity": "sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==",
+            "devOptional": true,
+            "license": "MIT",
+            "peerDependencies": {
+                "@types/react": "*",
+                "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+            },
+            "peerDependenciesMeta": {
+                "@types/react": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@radix-ui/react-slot": {
+            "version": "1.2.3",
+            "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+            "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "@radix-ui/react-compose-refs": "1.1.2"
+            },
+            "peerDependencies": {
+                "@types/react": "*",
+                "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+            },
+            "peerDependenciesMeta": {
+                "@types/react": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@radix-ui/react-use-controllable-state": {
+            "version": "1.2.2",
+            "resolved": "https://registry.npmjs.org/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz",
+            "integrity": "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "@radix-ui/react-use-effect-event": "0.0.2",
+                "@radix-ui/react-use-layout-effect": "1.1.1"
+            },
+            "peerDependencies": {
+                "@types/react": "*",
+                "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+            },
+            "peerDependenciesMeta": {
+                "@types/react": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@radix-ui/react-use-effect-event": {
+            "version": "0.0.2",
+            "resolved": "https://registry.npmjs.org/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz",
+            "integrity": "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "@radix-ui/react-use-layout-effect": "1.1.1"
+            },
+            "peerDependencies": {
+                "@types/react": "*",
+                "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+            },
+            "peerDependenciesMeta": {
+                "@types/react": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/@radix-ui/react-use-layout-effect": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz",
+            "integrity": "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==",
+            "devOptional": true,
+            "license": "MIT",
+            "peerDependencies": {
+                "@types/react": "*",
+                "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+            },
+            "peerDependenciesMeta": {
+                "@types/react": {
+                    "optional": true
+                }
             }
         },
         "node_modules/@remirror/core-constants": {
@@ -7604,15 +7969,6 @@
                 "@tauri-apps/api": "^2.8.0"
             }
         },
-        "node_modules/@tauri-apps/plugin-sql": {
-            "version": "2.3.2",
-            "resolved": "https://registry.npmjs.org/@tauri-apps/plugin-sql/-/plugin-sql-2.3.2.tgz",
-            "integrity": "sha512-4VDXhcKXVpyh5KKpnTGAn6q2DikPHH+TXGh9ZDQzULmG/JEz1RDvzQStgBJKddiukRbYEZ8CGIA2kskx+T+PpA==",
-            "license": "MIT OR Apache-2.0",
-            "dependencies": {
-                "@tauri-apps/api": "^2.10.1"
-            }
-        },
         "node_modules/@tauri-apps/plugin-store": {
             "version": "2.4.2",
             "resolved": "https://registry.npmjs.org/@tauri-apps/plugin-store/-/plugin-store-2.4.2.tgz",
@@ -8060,7 +8416,6 @@
             "version": "20.11.0",
             "resolved": "https://registry.npmjs.org/@types/node/-/node-20.11.0.tgz",
             "integrity": "sha512-o9bjXmDNcF7GbM4CNQpmi+TutCgap/K3w1JyKgxAjqx41zp9qlIAVFi0IhCNsJcXolEqLWhbFbEeL0PvYm4pcQ==",
-            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "undici-types": "~5.26.4"
@@ -8104,6 +8459,17 @@
                 "@types/pdfkit": "*"
             }
         },
+        "node_modules/@types/pg": {
+            "version": "8.20.0",
+            "resolved": "https://registry.npmjs.org/@types/pg/-/pg-8.20.0.tgz",
+            "integrity": "sha512-bEPFOaMAHTEP1EzpvHTbmwR8UsFyHSKsRisLIHVMXnpNefSbGA1bD6CVy+qKjGSqmZqNqBDV2azOBo8TgkcVow==",
+            "license": "MIT",
+            "dependencies": {
+                "@types/node": "*",
+                "pg-protocol": "*",
+                "pg-types": "^2.2.0"
+            }
+        },
         "node_modules/@types/postcss-modules-local-by-default": {
             "version": "4.0.2",
             "resolved": "https://registry.npmjs.org/@types/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.2.tgz",
@@ -9204,6 +9570,16 @@
                 "node": ">=6.0.0"
             }
         },
+        "node_modules/aws-ssl-profiles": {
+            "version": "1.1.2",
+            "resolved": "https://registry.npmjs.org/aws-ssl-profiles/-/aws-ssl-profiles-1.1.2.tgz",
+            "integrity": "sha512-NZKeq9AfyQvEeNlN0zSYAaWrmBffJh3IELMZfRpJVWgrpEbtEpnjvzqBPf+mxoI287JohRDoa+/nsfqqiZmF6g==",
+            "devOptional": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 6.0.0"
+            }
+        },
         "node_modules/axe-core": {
             "version": "4.11.0",
             "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.11.0.tgz",
@@ -9309,6 +9685,19 @@
                 "baseline-browser-mapping": "dist/cli.js"
             }
         },
+        "node_modules/better-result": {
+            "version": "2.8.2",
+            "resolved": "https://registry.npmjs.org/better-result/-/better-result-2.8.2.tgz",
+            "integrity": "sha512-YOf0VSj5nUPI27doTtXF+BBnsiRq3qY7avHqfIWnppxTLGyvkLq1QV2RTxkwoZwJ60ywLfZ0raFF4J/G886i7A==",
+            "devOptional": true,
+            "license": "MIT"
+        },
+        "node_modules/bintrees": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/bintrees/-/bintrees-1.0.2.tgz",
+            "integrity": "sha512-VOMgTMwjAaUG580SXn3LacVgjurrbMme7ZZNYGSSV7mmtY6QQRh0Eg3pwIcntQ77DErK1L0NxkbetjcoXzVwKw==",
+            "license": "MIT"
+        },
         "node_modules/blake3-wasm": {
             "version": "2.1.5",
             "resolved": "https://registry.npmjs.org/blake3-wasm/-/blake3-wasm-2.1.5.tgz",
@@ -9785,9 +10174,9 @@
             "license": "MIT"
         },
         "node_modules/confbox": {
-            "version": "0.2.2",
-            "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.2.2.tgz",
-            "integrity": "sha512-1NB+BKqhtNipMsov4xI/NnhCKp9XG9NamYp5PVm9klAT0fsrNPjaFICsCFhNhwZJKNh7zB/3q8qXz0E9oaMNtQ==",
+            "version": "0.2.4",
+            "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.2.4.tgz",
+            "integrity": "sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ==",
             "devOptional": true,
             "license": "MIT"
         },
@@ -9902,7 +10291,7 @@
             "version": "7.0.6",
             "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
             "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "path-key": "^3.1.0",
@@ -10229,9 +10618,9 @@
             }
         },
         "node_modules/defu": {
-            "version": "6.1.4",
-            "resolved": "https://registry.npmjs.org/defu/-/defu-6.1.4.tgz",
-            "integrity": "sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg==",
+            "version": "6.1.7",
+            "resolved": "https://registry.npmjs.org/defu/-/defu-6.1.7.tgz",
+            "integrity": "sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==",
             "devOptional": true,
             "license": "MIT"
         },
@@ -10244,6 +10633,16 @@
                 "node": ">=0.4.0"
             }
         },
+        "node_modules/denque": {
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
+            "integrity": "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==",
+            "devOptional": true,
+            "license": "Apache-2.0",
+            "engines": {
+                "node": ">=0.10"
+            }
+        },
         "node_modules/dequal": {
             "version": "2.0.3",
             "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
@@ -10399,9 +10798,9 @@
             }
         },
         "node_modules/effect": {
-            "version": "3.18.4",
-            "resolved": "https://registry.npmjs.org/effect/-/effect-3.18.4.tgz",
-            "integrity": "sha512-b1LXQJLe9D11wfnOKAk3PKxuqYshQ0Heez+y5pnkd3jLj1yx9QhM72zZ9uUrOQyNvrs2GZZd/3maL0ZV18YuDA==",
+            "version": "3.20.0",
+            "resolved": "https://registry.npmjs.org/effect/-/effect-3.20.0.tgz",
+            "integrity": "sha512-qMLfDJscrNG8p/aw+IkT9W7fgj50Z4wG5bLBy0Txsxz8iUHjDIkOgO3SV0WZfnQbNG2VJYb0b+rDLMrhM4+Krw==",
             "devOptional": true,
             "license": "MIT",
             "dependencies": {
@@ -10477,6 +10876,19 @@
                 "url": "https://github.com/fb55/entities?sponsor=1"
             }
         },
+        "node_modules/env-paths": {
+            "version": "3.0.0",
+            "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-3.0.0.tgz",
+            "integrity": "sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A==",
+            "devOptional": true,
+            "license": "MIT",
+            "engines": {
+                "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/sindresorhus"
+            }
+        },
         "node_modules/errno": {
             "version": "0.1.8",
             "resolved": "https://registry.npmjs.org/errno/-/errno-0.1.8.tgz",
@@ -11414,7 +11826,7 @@
             "version": "3.1.3",
             "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
             "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/fast-equals": {
@@ -11487,6 +11899,23 @@
             "integrity": "sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==",
             "license": "(MIT AND Zlib)"
         },
+        "node_modules/fast-uri": {
+            "version": "3.1.0",
+            "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
+            "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
+            "devOptional": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/fastify"
+                },
+                {
+                    "type": "opencollective",
+                    "url": "https://opencollective.com/fastify"
+                }
+            ],
+            "license": "BSD-3-Clause"
+        },
         "node_modules/fast-xml-parser": {
             "version": "5.3.5",
             "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.3.5.tgz",
@@ -11660,11 +12089,28 @@
                 "url": "https://github.com/sponsors/ljharb"
             }
         },
-        "node_modules/form-data": {
-            "version": "4.0.5",
-            "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
-            "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
-            "license": "MIT",
+        "node_modules/foreground-child": {
+            "version": "3.3.1",
+            "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
+            "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
+            "devOptional": true,
+            "license": "ISC",
+            "dependencies": {
+                "cross-spawn": "^7.0.6",
+                "signal-exit": "^4.0.1"
+            },
+            "engines": {
+                "node": ">=14"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/isaacs"
+            }
+        },
+        "node_modules/form-data": {
+            "version": "4.0.5",
+            "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+            "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+            "license": "MIT",
             "dependencies": {
                 "asynckit": "^0.4.0",
                 "combined-stream": "^1.0.8",
@@ -11753,6 +12199,16 @@
                 "url": "https://github.com/sponsors/ljharb"
             }
         },
+        "node_modules/generate-function": {
+            "version": "2.3.1",
+            "resolved": "https://registry.npmjs.org/generate-function/-/generate-function-2.3.1.tgz",
+            "integrity": "sha512-eeB5GfMNeevm/GRYq20ShmsaGcmI81kIX2K9XQx5miC8KdHaC6Jm0qQ8ZNeGOi7wYB8OsdxKs+Y2oVuTFuVwKQ==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "is-property": "^1.0.2"
+            }
+        },
         "node_modules/generator-function": {
             "version": "2.0.1",
             "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz",
@@ -11796,6 +12252,13 @@
                 "url": "https://github.com/sponsors/ljharb"
             }
         },
+        "node_modules/get-port-please": {
+            "version": "3.2.0",
+            "resolved": "https://registry.npmjs.org/get-port-please/-/get-port-please-3.2.0.tgz",
+            "integrity": "sha512-I9QVvBw5U/hw3RmWpYKRumUeaDgxTPd401x364rLmWBJcOQ753eov1eTgzDqRG9bqFIfDc7gfzcQEWrUri3o1A==",
+            "devOptional": true,
+            "license": "MIT"
+        },
         "node_modules/get-proto": {
             "version": "1.0.1",
             "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
@@ -11996,9 +12459,23 @@
             "version": "4.2.11",
             "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
             "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
-            "dev": true,
+            "devOptional": true,
             "license": "ISC"
         },
+        "node_modules/grammex": {
+            "version": "3.1.12",
+            "resolved": "https://registry.npmjs.org/grammex/-/grammex-3.1.12.tgz",
+            "integrity": "sha512-6ufJOsSA7LcQehIJNCO7HIBykfM7DXQual0Ny780/DEcJIpBlHRvcqEBWGPYd7hrXL2GJ3oJI1MIhaXjWmLQOQ==",
+            "devOptional": true,
+            "license": "MIT"
+        },
+        "node_modules/graphmatch": {
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/graphmatch/-/graphmatch-1.1.1.tgz",
+            "integrity": "sha512-5ykVn/EXM1hF0XCaWh05VbYvEiOL2lY1kBxZtaYsyvjp7cmWOU1XsAdfQBwClraEofXDT197lFbXOEVMHpvQOg==",
+            "devOptional": true,
+            "license": "MIT"
+        },
         "node_modules/has-bigints": {
             "version": "1.1.0",
             "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz",
@@ -12118,6 +12595,16 @@
                 "hulk": "bin/hulk"
             }
         },
+        "node_modules/hono": {
+            "version": "4.12.14",
+            "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.14.tgz",
+            "integrity": "sha512-am5zfg3yu6sqn5yjKBNqhnTX7Cv+m00ox+7jbaKkrLMRJ4rAdldd1xPd/JzbBWspqaQv6RSTrgFN95EsfhC+7w==",
+            "devOptional": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=16.9.0"
+            }
+        },
         "node_modules/href-content": {
             "version": "2.0.3",
             "resolved": "https://registry.npmjs.org/href-content/-/href-content-2.0.3.tgz",
@@ -12172,6 +12659,13 @@
                 "url": "https://github.com/fb55/entities?sponsor=1"
             }
         },
+        "node_modules/http-status-codes": {
+            "version": "2.3.0",
+            "resolved": "https://registry.npmjs.org/http-status-codes/-/http-status-codes-2.3.0.tgz",
+            "integrity": "sha512-RJ8XvFvpPM/Dmc5SV+dC4y5PCeOhT3x1Hq0NU3rjGeg5a/CqlhZ7uudknPwZFz4aeAXDcbAyaeP7GAo9lvngtA==",
+            "devOptional": true,
+            "license": "MIT"
+        },
         "node_modules/hunspell-asm": {
             "version": "4.0.2",
             "resolved": "https://registry.npmjs.org/hunspell-asm/-/hunspell-asm-4.0.2.tgz",
@@ -12705,6 +13199,13 @@
                 "url": "https://github.com/sponsors/ljharb"
             }
         },
+        "node_modules/is-property": {
+            "version": "1.0.2",
+            "resolved": "https://registry.npmjs.org/is-property/-/is-property-1.0.2.tgz",
+            "integrity": "sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g==",
+            "devOptional": true,
+            "license": "MIT"
+        },
         "node_modules/is-regex": {
             "version": "1.2.1",
             "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz",
@@ -12880,7 +13381,7 @@
             "version": "2.0.0",
             "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
             "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
-            "dev": true,
+            "devOptional": true,
             "license": "ISC"
         },
         "node_modules/isomorphic.js": {
@@ -13386,6 +13887,13 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/long": {
+            "version": "5.3.2",
+            "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+            "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+            "devOptional": true,
+            "license": "Apache-2.0"
+        },
         "node_modules/loose-envify": {
             "version": "1.4.0",
             "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
@@ -13424,6 +13932,22 @@
                 "yallist": "^3.0.2"
             }
         },
+        "node_modules/lru.min": {
+            "version": "1.1.4",
+            "resolved": "https://registry.npmjs.org/lru.min/-/lru.min-1.1.4.tgz",
+            "integrity": "sha512-DqC6n3QQ77zdFpCMASA1a3Jlb64Hv2N2DciFGkO/4L9+q/IpIAuRlKOvCXabtRW6cQf8usbmM6BE/TOPysCdIA==",
+            "devOptional": true,
+            "license": "MIT",
+            "engines": {
+                "bun": ">=1.0.0",
+                "deno": ">=1.30.0",
+                "node": ">=8.0.0"
+            },
+            "funding": {
+                "type": "github",
+                "url": "https://github.com/sponsors/wellwelwel"
+            }
+        },
         "node_modules/lucide-react": {
             "version": "0.562.0",
             "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.562.0.tgz",
@@ -13680,6 +14204,57 @@
             "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
             "license": "MIT"
         },
+        "node_modules/mysql2": {
+            "version": "3.15.3",
+            "resolved": "https://registry.npmjs.org/mysql2/-/mysql2-3.15.3.tgz",
+            "integrity": "sha512-FBrGau0IXmuqg4haEZRBfHNWB5mUARw6hNwPDXXGg0XzVJ50mr/9hb267lvpVMnhZ1FON3qNd4Xfcez1rbFwSg==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "aws-ssl-profiles": "^1.1.1",
+                "denque": "^2.1.0",
+                "generate-function": "^2.3.1",
+                "iconv-lite": "^0.7.0",
+                "long": "^5.2.1",
+                "lru.min": "^1.0.0",
+                "named-placeholders": "^1.1.3",
+                "seq-queue": "^0.0.5",
+                "sqlstring": "^2.3.2"
+            },
+            "engines": {
+                "node": ">= 8.0"
+            }
+        },
+        "node_modules/mysql2/node_modules/iconv-lite": {
+            "version": "0.7.2",
+            "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
+            "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "safer-buffer": ">= 2.1.2 < 3.0.0"
+            },
+            "engines": {
+                "node": ">=0.10.0"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/express"
+            }
+        },
+        "node_modules/named-placeholders": {
+            "version": "1.1.6",
+            "resolved": "https://registry.npmjs.org/named-placeholders/-/named-placeholders-1.1.6.tgz",
+            "integrity": "sha512-Tz09sEL2EEuv5fFowm419c1+a/jSMiBjI9gHxVLrVdbUkkNUUfjsVYs9pVZu5oCon/kmRh9TfLEObFtkVxmY0w==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "lru.min": "^1.1.0"
+            },
+            "engines": {
+                "node": ">=8.0.0"
+            }
+        },
         "node_modules/nanoid": {
             "version": "5.1.7",
             "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-5.1.7.tgz",
@@ -14025,25 +14600,30 @@
             }
         },
         "node_modules/nypm": {
-            "version": "0.6.2",
-            "resolved": "https://registry.npmjs.org/nypm/-/nypm-0.6.2.tgz",
-            "integrity": "sha512-7eM+hpOtrKrBDCh7Ypu2lJ9Z7PNZBdi/8AT3AX8xoCj43BBVHD0hPSTEvMtkMpfs8FCqBGhxB+uToIQimA111g==",
+            "version": "0.6.5",
+            "resolved": "https://registry.npmjs.org/nypm/-/nypm-0.6.5.tgz",
+            "integrity": "sha512-K6AJy1GMVyfyMXRVB88700BJqNUkByijGJM8kEHpLdcAt+vSQAVfkWWHYzuRXHSY6xA2sNc5RjTj0p9rE2izVQ==",
             "devOptional": true,
             "license": "MIT",
             "dependencies": {
-                "citty": "^0.1.6",
-                "consola": "^3.4.2",
+                "citty": "^0.2.0",
                 "pathe": "^2.0.3",
-                "pkg-types": "^2.3.0",
-                "tinyexec": "^1.0.1"
+                "tinyexec": "^1.0.2"
             },
             "bin": {
                 "nypm": "dist/cli.mjs"
             },
             "engines": {
-                "node": "^14.16.0 || >=16.10.0"
+                "node": ">=18"
             }
         },
+        "node_modules/nypm/node_modules/citty": {
+            "version": "0.2.2",
+            "resolved": "https://registry.npmjs.org/citty/-/citty-0.2.2.tgz",
+            "integrity": "sha512-+6vJA3L98yv+IdfKGZHBNiGW5KHn22e/JwID0Strsz8h4S/csAu/OuICwxrg44k5MRiZHWIo8XXuJgQTriRP4w==",
+            "devOptional": true,
+            "license": "MIT"
+        },
         "node_modules/oauth4webapi": {
             "version": "3.8.5",
             "resolved": "https://registry.npmjs.org/oauth4webapi/-/oauth4webapi-3.8.5.tgz",
@@ -14496,7 +15076,7 @@
             "version": "3.1.1",
             "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
             "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=8"
@@ -14612,6 +15192,104 @@
             "license": "MIT",
             "optional": true
         },
+        "node_modules/pg": {
+            "version": "8.20.0",
+            "resolved": "https://registry.npmjs.org/pg/-/pg-8.20.0.tgz",
+            "integrity": "sha512-ldhMxz2r8fl/6QkXnBD3CR9/xg694oT6DZQ2s6c/RI28OjtSOpxnPrUCGOBJ46RCUxcWdx3p6kw/xnDHjKvaRA==",
+            "license": "MIT",
+            "dependencies": {
+                "pg-connection-string": "^2.12.0",
+                "pg-pool": "^3.13.0",
+                "pg-protocol": "^1.13.0",
+                "pg-types": "2.2.0",
+                "pgpass": "1.0.5"
+            },
+            "engines": {
+                "node": ">= 16.0.0"
+            },
+            "optionalDependencies": {
+                "pg-cloudflare": "^1.3.0"
+            },
+            "peerDependencies": {
+                "pg-native": ">=3.0.1"
+            },
+            "peerDependenciesMeta": {
+                "pg-native": {
+                    "optional": true
+                }
+            }
+        },
+        "node_modules/pg-cloudflare": {
+            "version": "1.3.0",
+            "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.3.0.tgz",
+            "integrity": "sha512-6lswVVSztmHiRtD6I8hw4qP/nDm1EJbKMRhf3HCYaqud7frGysPv7FYJ5noZQdhQtN2xJnimfMtvQq21pdbzyQ==",
+            "license": "MIT",
+            "optional": true
+        },
+        "node_modules/pg-connection-string": {
+            "version": "2.12.0",
+            "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.12.0.tgz",
+            "integrity": "sha512-U7qg+bpswf3Cs5xLzRqbXbQl85ng0mfSV/J0nnA31MCLgvEaAo7CIhmeyrmJpOr7o+zm0rXK+hNnT5l9RHkCkQ==",
+            "license": "MIT"
+        },
+        "node_modules/pg-int8": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+            "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
+            "license": "ISC",
+            "engines": {
+                "node": ">=4.0.0"
+            }
+        },
+        "node_modules/pg-pool": {
+            "version": "3.13.0",
+            "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.13.0.tgz",
+            "integrity": "sha512-gB+R+Xud1gLFuRD/QgOIgGOBE2KCQPaPwkzBBGC9oG69pHTkhQeIuejVIk3/cnDyX39av2AxomQiyPT13WKHQA==",
+            "license": "MIT",
+            "peerDependencies": {
+                "pg": ">=8.0"
+            }
+        },
+        "node_modules/pg-protocol": {
+            "version": "1.13.0",
+            "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.13.0.tgz",
+            "integrity": "sha512-zzdvXfS6v89r6v7OcFCHfHlyG/wvry1ALxZo4LqgUoy7W9xhBDMaqOuMiF3qEV45VqsN6rdlcehHrfDtlCPc8w==",
+            "license": "MIT"
+        },
+        "node_modules/pg-types": {
+            "version": "2.2.0",
+            "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+            "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
+            "license": "MIT",
+            "dependencies": {
+                "pg-int8": "1.0.1",
+                "postgres-array": "~2.0.0",
+                "postgres-bytea": "~1.0.0",
+                "postgres-date": "~1.0.4",
+                "postgres-interval": "^1.1.0"
+            },
+            "engines": {
+                "node": ">=4"
+            }
+        },
+        "node_modules/pg-types/node_modules/postgres-array": {
+            "version": "2.0.0",
+            "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
+            "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
+            "license": "MIT",
+            "engines": {
+                "node": ">=4"
+            }
+        },
+        "node_modules/pgpass": {
+            "version": "1.0.5",
+            "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+            "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
+            "license": "MIT",
+            "dependencies": {
+                "split2": "^4.1.0"
+            }
+        },
         "node_modules/pick-util": {
             "version": "1.1.5",
             "resolved": "https://registry.npmjs.org/pick-util/-/pick-util-1.1.5.tgz",
@@ -14877,6 +15555,59 @@
                 "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
             }
         },
+        "node_modules/postgres": {
+            "version": "3.4.7",
+            "resolved": "https://registry.npmjs.org/postgres/-/postgres-3.4.7.tgz",
+            "integrity": "sha512-Jtc2612XINuBjIl/QTWsV5UvE8UHuNblcO3vVADSrKsrc6RqGX6lOW1cEo3CM2v0XG4Nat8nI+YM7/f26VxXLw==",
+            "devOptional": true,
+            "license": "Unlicense",
+            "engines": {
+                "node": ">=12"
+            },
+            "funding": {
+                "type": "individual",
+                "url": "https://github.com/sponsors/porsager"
+            }
+        },
+        "node_modules/postgres-array": {
+            "version": "3.0.4",
+            "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-3.0.4.tgz",
+            "integrity": "sha512-nAUSGfSDGOaOAEGwqsRY27GPOea7CNipJPOA7lPbdEpx5Kg3qzdP0AaWC5MlhTWV9s4hFX39nomVZ+C4tnGOJQ==",
+            "license": "MIT",
+            "engines": {
+                "node": ">=12"
+            }
+        },
+        "node_modules/postgres-bytea": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.1.tgz",
+            "integrity": "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==",
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/postgres-date": {
+            "version": "1.0.7",
+            "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
+            "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
+        "node_modules/postgres-interval": {
+            "version": "1.2.0",
+            "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
+            "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
+            "license": "MIT",
+            "dependencies": {
+                "xtend": "^4.0.0"
+            },
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
         "node_modules/preact": {
             "version": "10.24.3",
             "resolved": "https://registry.npmjs.org/preact/-/preact-10.24.3.tgz",
@@ -14942,26 +15673,34 @@
             "license": "MIT"
         },
         "node_modules/prisma": {
-            "version": "6.19.1",
-            "resolved": "https://registry.npmjs.org/prisma/-/prisma-6.19.1.tgz",
-            "integrity": "sha512-XRfmGzh6gtkc/Vq3LqZJcS2884dQQW3UhPo6jNRoiTW95FFQkXFg8vkYEy6og+Pyv0aY7zRQ7Wn1Cvr56XjhQQ==",
+            "version": "7.7.0",
+            "resolved": "https://registry.npmjs.org/prisma/-/prisma-7.7.0.tgz",
+            "integrity": "sha512-HlgwRBt1uEFB9LStHL4HLYDvoi4BNu1rYA0hPG0zCAEyK9SaZBqp7E5Rjpc3Qh8Lex/ye/svoHZ0OWoFNhWxuQ==",
             "devOptional": true,
             "hasInstallScript": true,
             "license": "Apache-2.0",
             "dependencies": {
-                "@prisma/config": "6.19.1",
-                "@prisma/engines": "6.19.1"
+                "@prisma/config": "7.7.0",
+                "@prisma/dev": "0.24.3",
+                "@prisma/engines": "7.7.0",
+                "@prisma/studio-core": "0.27.3",
+                "mysql2": "3.15.3",
+                "postgres": "3.4.7"
             },
             "bin": {
                 "prisma": "build/index.js"
             },
             "engines": {
-                "node": ">=18.18"
+                "node": "^20.19 || ^22.12 || >=24.0"
             },
             "peerDependencies": {
-                "typescript": ">=5.1.0"
+                "better-sqlite3": ">=9.0.0",
+                "typescript": ">=5.4.0"
             },
             "peerDependenciesMeta": {
+                "better-sqlite3": {
+                    "optional": true
+                },
                 "typescript": {
                     "optional": true
                 }
@@ -14977,6 +15716,19 @@
                 "node": ">= 0.6.0"
             }
         },
+        "node_modules/prom-client": {
+            "version": "15.1.3",
+            "resolved": "https://registry.npmjs.org/prom-client/-/prom-client-15.1.3.tgz",
+            "integrity": "sha512-6ZiOBfCywsD4k1BN9IX0uZhF+tJkV8q8llP64G5Hajs4JOeVLPCwpPVcpXy3BwYiUGgyJzsJJQeOIv7+hDSq8g==",
+            "license": "Apache-2.0",
+            "dependencies": {
+                "@opentelemetry/api": "^1.4.0",
+                "tdigest": "^0.1.1"
+            },
+            "engines": {
+                "node": "^16 || ^18 || >=20"
+            }
+        },
         "node_modules/prop-types": {
             "version": "15.8.1",
             "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
@@ -14989,6 +15741,25 @@
                 "react-is": "^16.13.1"
             }
         },
+        "node_modules/proper-lockfile": {
+            "version": "4.1.2",
+            "resolved": "https://registry.npmjs.org/proper-lockfile/-/proper-lockfile-4.1.2.tgz",
+            "integrity": "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "graceful-fs": "^4.2.4",
+                "retry": "^0.12.0",
+                "signal-exit": "^3.0.2"
+            }
+        },
+        "node_modules/proper-lockfile/node_modules/signal-exit": {
+            "version": "3.0.7",
+            "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+            "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+            "devOptional": true,
+            "license": "ISC"
+        },
         "node_modules/prosemirror-changeset": {
             "version": "2.3.1",
             "resolved": "https://registry.npmjs.org/prosemirror-changeset/-/prosemirror-changeset-2.3.1.tgz",
@@ -15498,6 +16269,16 @@
                 "regjsparser": "bin/parser"
             }
         },
+        "node_modules/remeda": {
+            "version": "2.33.4",
+            "resolved": "https://registry.npmjs.org/remeda/-/remeda-2.33.4.tgz",
+            "integrity": "sha512-ygHswjlc/opg2VrtiYvUOPLjxjtdKvjGz1/plDhkG66hjNjFr1xmfrs2ClNFo/E6TyUFiwYNh53bKV26oBoMGQ==",
+            "devOptional": true,
+            "license": "MIT",
+            "funding": {
+                "url": "https://github.com/sponsors/remeda"
+            }
+        },
         "node_modules/remote-content": {
             "version": "4.0.1",
             "resolved": "https://registry.npmjs.org/remote-content/-/remote-content-4.0.1.tgz",
@@ -15522,6 +16303,16 @@
                 "range-parser": "^1.2.1"
             }
         },
+        "node_modules/require-from-string": {
+            "version": "2.0.2",
+            "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+            "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+            "devOptional": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.10.0"
+            }
+        },
         "node_modules/reserved-words": {
             "version": "0.1.2",
             "resolved": "https://registry.npmjs.org/reserved-words/-/reserved-words-0.1.2.tgz",
@@ -15569,6 +16360,16 @@
                 "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
             }
         },
+        "node_modules/retry": {
+            "version": "0.12.0",
+            "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
+            "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
+            "devOptional": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 4"
+            }
+        },
         "node_modules/reusify": {
             "version": "1.1.0",
             "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
@@ -15800,6 +16601,12 @@
                 "semver": "bin/semver.js"
             }
         },
+        "node_modules/seq-queue": {
+            "version": "0.0.5",
+            "resolved": "https://registry.npmjs.org/seq-queue/-/seq-queue-0.0.5.tgz",
+            "integrity": "sha512-hr3Wtp/GZIc/6DAGPDcV4/9WoZhjrkXsi5B/07QgX8tsdc6ilr7BFM6PM6rbdAX1kFSDYeZGLipIZZKyQP0O5Q==",
+            "devOptional": true
+        },
         "node_modules/set-function-length": {
             "version": "1.2.2",
             "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
@@ -15909,7 +16716,7 @@
             "version": "2.0.0",
             "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
             "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "dependencies": {
                 "shebang-regex": "^3.0.0"
@@ -15922,7 +16729,7 @@
             "version": "3.0.0",
             "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
             "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT",
             "engines": {
                 "node": ">=8"
@@ -16011,6 +16818,19 @@
             "dev": true,
             "license": "ISC"
         },
+        "node_modules/signal-exit": {
+            "version": "4.1.0",
+            "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+            "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+            "devOptional": true,
+            "license": "ISC",
+            "engines": {
+                "node": ">=14"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/isaacs"
+            }
+        },
         "node_modules/simple-xml-to-json": {
             "version": "1.2.3",
             "resolved": "https://registry.npmjs.org/simple-xml-to-json/-/simple-xml-to-json-1.2.3.tgz",
@@ -16094,6 +16914,25 @@
                 "specificity": "bin/specificity"
             }
         },
+        "node_modules/split2": {
+            "version": "4.2.0",
+            "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+            "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+            "license": "ISC",
+            "engines": {
+                "node": ">= 10.x"
+            }
+        },
+        "node_modules/sqlstring": {
+            "version": "2.3.3",
+            "resolved": "https://registry.npmjs.org/sqlstring/-/sqlstring-2.3.3.tgz",
+            "integrity": "sha512-qC9iz2FlN7DQl3+wjwn3802RTyjCx7sDvfQEXchwa6CWOx07/WVfh91gBmQ9fahw8snwGEWU3xGzOt4tFyHLxg==",
+            "devOptional": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.6"
+            }
+        },
         "node_modules/stable-hash": {
             "version": "0.0.5",
             "resolved": "https://registry.npmjs.org/stable-hash/-/stable-hash-0.0.5.tgz",
@@ -16122,7 +16961,7 @@
             "version": "3.10.0",
             "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.10.0.tgz",
             "integrity": "sha512-5GS12FdOZNliM5mAOxFRg7Ir0pWz8MdpYm6AY6VPkGpbA7ZzmbzNcBJQ0GPvvyWgcY7QAhCgf9Uy89I03faLkg==",
-            "dev": true,
+            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/stop-iteration-iterator": {
@@ -16511,6 +17350,15 @@
                 "react": "^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
             }
         },
+        "node_modules/tdigest": {
+            "version": "0.1.2",
+            "resolved": "https://registry.npmjs.org/tdigest/-/tdigest-0.1.2.tgz",
+            "integrity": "sha512-+G0LLgjjo9BZX2MfdvPfH+MKLCrxlXSYec5DaPYP1fe6Iyhf0/fSmJ0bFiZ1F8BT6cGXl2LpltQptzjXKWEkKA==",
+            "license": "MIT",
+            "dependencies": {
+                "bintrees": "1.0.2"
+            }
+        },
         "node_modules/text-segmentation": {
             "version": "1.0.3",
             "resolved": "https://registry.npmjs.org/text-segmentation/-/text-segmentation-1.0.3.tgz",
@@ -16542,9 +17390,9 @@
             "license": "MIT"
         },
         "node_modules/tinyexec": {
-            "version": "1.0.2",
-            "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.2.tgz",
-            "integrity": "sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==",
+            "version": "1.1.1",
+            "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.1.1.tgz",
+            "integrity": "sha512-VKS/ZaQhhkKFMANmAOhhXVoIfBXblQxGX1myCQ2faQrfmobMftXeJPcZGp0gS07ocvGJWDLZGyOZDadDBqYIJg==",
             "devOptional": true,
             "license": "MIT",
             "engines": {
@@ -17051,7 +17899,6 @@
             "version": "5.26.5",
             "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
             "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
-            "devOptional": true,
             "license": "MIT"
         },
         "node_modules/unenv": {
@@ -17302,6 +18149,21 @@
                 "uuid": "dist-node/bin/uuid"
             }
         },
+        "node_modules/valibot": {
+            "version": "1.2.0",
+            "resolved": "https://registry.npmjs.org/valibot/-/valibot-1.2.0.tgz",
+            "integrity": "sha512-mm1rxUsmOxzrwnX5arGS+U4T25RdvpPjPN4yR0u9pUBov9+zGVtO84tif1eY4r6zWxVxu3KzIyknJy3rxfRZZg==",
+            "devOptional": true,
+            "license": "MIT",
+            "peerDependencies": {
+                "typescript": ">=5"
+            },
+            "peerDependenciesMeta": {
+                "typescript": {
+                    "optional": true
+                }
+            }
+        },
         "node_modules/vite": {
             "version": "6.4.1",
             "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
@@ -18136,7 +18998,7 @@
             "version": "2.0.2",
             "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
             "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
-            "dev": true,
+            "devOptional": true,
             "license": "ISC",
             "dependencies": {
                 "isexe": "^2.0.0"
@@ -18390,6 +19252,15 @@
                 "sax": "^1.2.4"
             }
         },
+        "node_modules/xtend": {
+            "version": "4.0.2",
+            "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+            "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+            "license": "MIT",
+            "engines": {
+                "node": ">=0.4"
+            }
+        },
         "node_modules/y-indexeddb": {
             "version": "9.0.12",
             "resolved": "https://registry.npmjs.org/y-indexeddb/-/y-indexeddb-9.0.12.tgz",
@@ -18566,6 +19437,17 @@
                 "url": "https://opencollective.com/express"
             }
         },
+        "node_modules/zeptomatch": {
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/zeptomatch/-/zeptomatch-2.1.0.tgz",
+            "integrity": "sha512-KiGErG2J0G82LSpniV0CtIzjlJ10E04j02VOudJsPyPwNZgGnRKQy7I1R7GMyg/QswnE4l7ohSGrQbQbjXPPDA==",
+            "devOptional": true,
+            "license": "MIT",
+            "dependencies": {
+                "grammex": "^3.1.11",
+                "graphmatch": "^1.1.0"
+            }
+        },
         "node_modules/zod": {
             "version": "4.2.1",
             "resolved": "https://registry.npmjs.org/zod/-/zod-4.2.1.tgz",
diff --git a/package.json b/package.json
index 3b0736cf..61e0385b 100644
--- a/package.json
+++ b/package.json
@@ -2,13 +2,14 @@
     "name": "scriptio",
     "private": true,
     "version": "2.1.0",
+    "type": "module",
     "scripts": {
         "postinstall": "patch-package",
         "dev": "docker compose --profile dev up -d --wait && npx prisma db push && next dev",
         "build": "npx prisma generate && next build",
-        "build:tauri": "npx prisma generate && npx tsx src/build-tauri.ts",
-        "worker:dev": "wrangler dev -c src/lib/collaboration/wrangler.toml",
-        "worker:deploy": "wrangler deploy -c src/lib/collaboration/wrangler.toml",
+        "build:tauri": "npx prisma generate && npx tsx scripts/build-tauri.ts",
+        "worker:dev": "wrangler dev -c src/lib/cloud/wrangler.toml",
+        "worker:deploy": "wrangler deploy -c src/lib/cloud/wrangler.toml",
         "stripe:dev": "stripe listen --forward-to localhost:3000/api/webhooks/stripe",
         "tauri": "tauri",
         "tauri:dev": "tauri dev",
@@ -32,7 +33,8 @@
         "@aws-sdk/s3-request-presigner": "^3.952.0",
         "@choochmeque/tauri-plugin-iap-api": "^0.8.2",
         "@formkit/auto-animate": "^0.7.0",
-        "@prisma/client": "^6.19.0",
+        "@prisma/adapter-pg": "^7.8.0",
+        "@prisma/client": "^7.7.0",
         "@svgr/core": "^8.1.0",
         "@tauri-apps/api": "2.10.1",
         "@tauri-apps/plugin-dialog": "2.6.0",
@@ -69,6 +71,8 @@
         "next-themes": "^0.2.0",
         "nodemailer": "^7.0.12",
         "pdfmake": "^0.2.9",
+        "pg": "^8.20.0",
+        "prom-client": "^15.1.3",
         "react": "^19.2.4",
         "react-chartjs-2": "^5.2.0",
         "react-dom": "^19.2.4",
@@ -94,6 +98,7 @@
         "@types/node": "20.11.0",
         "@types/nodemailer": "^6.4.14",
         "@types/pdfmake": "^0.2.12",
+        "@types/pg": "^8.20.0",
         "@types/react": "^18.3.27",
         "@types/react-dom": "^18.3.7",
         "@types/uuid": "^10.0.0",
@@ -108,9 +113,9 @@
         "eslint-plugin-react-hooks": "^7.0.1",
         "patch-package": "^8.0.1",
         "playwright": "^1.58.2",
-        "prisma": "^6.19.0",
+        "prisma": "^7.7.0",
         "tsx": "^4.21.0",
-        "typescript": "^5.1.3",
+        "typescript": "^5.7.3",
         "typescript-plugin-css-modules": "^5.2.0",
         "vite": "^6.4.1",
         "vitest": "^3.2.4",
diff --git a/prisma.config.ts b/prisma.config.ts
new file mode 100644
index 00000000..6bab5632
--- /dev/null
+++ b/prisma.config.ts
@@ -0,0 +1,14 @@
+import "dotenv/config";
+import { defineConfig } from "prisma/config";
+
+export default defineConfig({
+  schema: "prisma/schema.prisma",
+  datasource: {
+    // env() throws if the variable is absent (even for generate-only commands).
+    // process.env with a fallback keeps prisma generate working in CI without a DB.
+    url: process.env.DATABASE_URL ?? "postgresql://localhost/build",
+  },
+  migrations: {
+    seed: "tsx prisma/seed.ts",
+  },
+});
diff --git a/prisma/migrations/20260422105711_init/migration.sql b/prisma/migrations/20260422105711_init/migration.sql
deleted file mode 100644
index 061247ac..00000000
--- a/prisma/migrations/20260422105711_init/migration.sql
+++ /dev/null
@@ -1,168 +0,0 @@
--- CreateEnum
-CREATE TYPE "ProjectRole" AS ENUM ('OWNER', 'ADMIN', 'EDITOR', 'VIEWER');
-
--- CreateEnum
-CREATE TYPE "SubscriptionProvider" AS ENUM ('STRIPE', 'APPLE');
-
--- CreateTable
-CREATE TABLE "User" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "email" TEXT NOT NULL,
-    "emailVerified" TIMESTAMP(3),
-    "username" TEXT,
-    "color" TEXT,
-    "isProUntil" TIMESTAMP(3),
-    "isSubscriptionCancelled" BOOLEAN NOT NULL DEFAULT false,
-    "subscriptionProvider" "SubscriptionProvider",
-    "settings" JSONB,
-
-    CONSTRAINT "User_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "Account" (
-    "id" TEXT NOT NULL,
-    "userId" TEXT NOT NULL,
-    "type" TEXT NOT NULL,
-    "provider" TEXT NOT NULL,
-    "providerAccountId" TEXT NOT NULL,
-    "refresh_token" TEXT,
-    "access_token" TEXT,
-    "expires_at" INTEGER,
-    "token_type" TEXT,
-    "scope" TEXT,
-    "id_token" TEXT,
-    "session_state" TEXT,
-
-    CONSTRAINT "Account_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "Session" (
-    "id" TEXT NOT NULL,
-    "sessionToken" TEXT NOT NULL,
-    "userId" TEXT NOT NULL,
-    "expires" TIMESTAMP(3) NOT NULL,
-
-    CONSTRAINT "Session_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "VerificationToken" (
-    "identifier" TEXT NOT NULL,
-    "token" TEXT NOT NULL,
-    "expires" TIMESTAMP(3) NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "MagicLinkToken" (
-    "id" SERIAL NOT NULL,
-    "email" TEXT NOT NULL,
-    "tokenHash" TEXT NOT NULL,
-    "expiresAt" TIMESTAMP(3) NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "desktopNonce" TEXT,
-    "inviteToken" TEXT,
-
-    CONSTRAINT "MagicLinkToken_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "Transaction" (
-    "id" SERIAL NOT NULL,
-    "userId" TEXT NOT NULL,
-    "provider" "SubscriptionProvider" NOT NULL,
-    "transactionId" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-
-    CONSTRAINT "Transaction_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "Project" (
-    "id" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "updatedAt" TIMESTAMP(3) NOT NULL,
-    "title" TEXT NOT NULL,
-    "description" TEXT,
-    "author" TEXT,
-    "hasPoster" BOOLEAN NOT NULL DEFAULT false,
-
-    CONSTRAINT "Project_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "ProjectMember" (
-    "id" SERIAL NOT NULL,
-    "role" "ProjectRole" NOT NULL DEFAULT 'VIEWER',
-    "userId" TEXT NOT NULL,
-    "projectId" TEXT NOT NULL,
-
-    CONSTRAINT "ProjectMember_pkey" PRIMARY KEY ("id")
-);
-
--- CreateTable
-CREATE TABLE "ProjectInvitation" (
-    "id" SERIAL NOT NULL,
-    "token" TEXT NOT NULL,
-    "email" TEXT NOT NULL,
-    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    "projectId" TEXT NOT NULL,
-
-    CONSTRAINT "ProjectInvitation_pkey" PRIMARY KEY ("id")
-);
-
--- CreateIndex
-CREATE UNIQUE INDEX "User_email_key" ON "User"("email");
-
--- CreateIndex
-CREATE UNIQUE INDEX "Account_provider_providerAccountId_key" ON "Account"("provider", "providerAccountId");
-
--- CreateIndex
-CREATE UNIQUE INDEX "Session_sessionToken_key" ON "Session"("sessionToken");
-
--- CreateIndex
-CREATE UNIQUE INDEX "VerificationToken_token_key" ON "VerificationToken"("token");
-
--- CreateIndex
-CREATE UNIQUE INDEX "VerificationToken_identifier_token_key" ON "VerificationToken"("identifier", "token");
-
--- CreateIndex
-CREATE UNIQUE INDEX "MagicLinkToken_tokenHash_key" ON "MagicLinkToken"("tokenHash");
-
--- CreateIndex
-CREATE INDEX "MagicLinkToken_email_createdAt_idx" ON "MagicLinkToken"("email", "createdAt");
-
--- CreateIndex
-CREATE INDEX "Transaction_userId_idx" ON "Transaction"("userId");
-
--- CreateIndex
-CREATE INDEX "Transaction_transactionId_idx" ON "Transaction"("transactionId");
-
--- CreateIndex
-CREATE UNIQUE INDEX "ProjectMember_userId_projectId_key" ON "ProjectMember"("userId", "projectId");
-
--- CreateIndex
-CREATE UNIQUE INDEX "ProjectInvitation_token_key" ON "ProjectInvitation"("token");
-
--- CreateIndex
-CREATE UNIQUE INDEX "ProjectInvitation_email_projectId_key" ON "ProjectInvitation"("email", "projectId");
-
--- AddForeignKey
-ALTER TABLE "Account" ADD CONSTRAINT "Account_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "Session" ADD CONSTRAINT "Session_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "Transaction" ADD CONSTRAINT "Transaction_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "ProjectMember" ADD CONSTRAINT "ProjectMember_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "ProjectMember" ADD CONSTRAINT "ProjectMember_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
-
--- AddForeignKey
-ALTER TABLE "ProjectInvitation" ADD CONSTRAINT "ProjectInvitation_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/prisma/migrations/migration_lock.toml b/prisma/migrations/migration_lock.toml
deleted file mode 100644
index 044d57cd..00000000
--- a/prisma/migrations/migration_lock.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-# Please do not edit this file manually
-# It should be added in your version-control system (e.g., Git)
-provider = "postgresql"
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index 8115d82b..8ee20c7e 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -2,12 +2,12 @@
 // learn more about it in the docs: https://pris.ly/d/prisma-schema
 
 generator client {
-  provider = "prisma-client-js"
+  provider = "prisma-client"
+  output   = "../src/generated/client"
 }
 
 datasource db {
   provider = "postgresql"
-  url      = env("DATABASE_URL")
 }
 
 enum ProjectRole {
@@ -17,6 +17,11 @@ enum ProjectRole {
   VIEWER
 }
 
+enum UserRole {
+  USER
+  ADMIN
+}
+
 enum SubscriptionProvider {
   STRIPE
   APPLE
@@ -29,6 +34,7 @@ model User {
   emailVerified       DateTime?
   username            String?
   color               String?
+  role                UserRole    @default(USER)
 
   isProUntil                  DateTime?
   isSubscriptionCancelled     Boolean   @default(false)
diff --git a/prisma/seed.ts b/prisma/seed.ts
new file mode 100644
index 00000000..1094a2ff
--- /dev/null
+++ b/prisma/seed.ts
@@ -0,0 +1,38 @@
+import "dotenv/config";
+import { PrismaClient, UserRole } from "../src/generated/client/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+import pg from "pg";
+
+const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });
+const adapter = new PrismaPg(pool);
+const prisma = new PrismaClient({ adapter });
+
+async function main() {
+    const adminEmail = process.env.SEED_ADMIN_EMAIL;
+
+    if (!adminEmail) {
+        console.log("No SEED_ADMIN_EMAIL set — skipping admin promotion.");
+        return;
+    }
+
+    const user = await prisma.user.upsert({
+        where: { email: adminEmail },
+        update: { role: UserRole.ADMIN },
+        create: {
+            email: adminEmail,
+            emailVerified: new Date(),
+            role: UserRole.ADMIN,
+        },
+    });
+
+    console.log(`Admin set: ${user.email} (id: ${user.id})`);
+}
+
+main()
+    .catch((e) => {
+        console.error(e);
+        process.exit(1);
+    })
+    .finally(async () => {
+        await prisma.$disconnect();
+    });
diff --git a/src/build-tauri.ts b/scripts/build-tauri.ts
similarity index 53%
rename from src/build-tauri.ts
rename to scripts/build-tauri.ts
index fe6d8f92..b4a57872 100644
--- a/src/build-tauri.ts
+++ b/scripts/build-tauri.ts
@@ -3,20 +3,28 @@ import { join } from "path";
 import { execSync } from "child_process";
 
 const apiDir = join("src", "app", "api");
-const hiddenDir = join("src", "app", "_api");
+const hiddenApiDir = join("src", "app", "_api");
+const adminDir = join("src", "app", "admin");
+const hiddenAdminDir = join("src", "app", "_admin");
 
 // Clean .next cache to avoid stale type references to API routes
 rmSync(".next", { recursive: true, force: true });
 
 // Prefix with _ so Next.js ignores the API routes during static export
 if (existsSync(apiDir)) {
-    renameSync(apiDir, hiddenDir);
+    renameSync(apiDir, hiddenApiDir);
+}
+if (existsSync(adminDir)) {
+    renameSync(adminDir, hiddenAdminDir);
 }
 
 try {
     execSync("npx cross-env TAURI_BUILD=true next build", { stdio: "inherit" });
 } finally {
-    if (existsSync(hiddenDir)) {
-        renameSync(hiddenDir, apiDir);
+    if (existsSync(hiddenApiDir)) {
+        renameSync(hiddenApiDir, apiDir);
+    }
+    if (existsSync(hiddenAdminDir)) {
+        renameSync(hiddenAdminDir, adminDir);
     }
 }
diff --git a/scripts/generate-apple-jwt.ts b/scripts/generate-apple-jwt.ts
index fdb971ca..600ec68f 100644
--- a/scripts/generate-apple-jwt.ts
+++ b/scripts/generate-apple-jwt.ts
@@ -35,8 +35,7 @@ export async function generateAppleJWT({
 }
 
 // --- CLI Execution Logic ---
-// In TS, we check if this file is the entry point differently depending on your runner
-if (require.main === module || process.argv[1]?.includes("generate-apple-jwt")) {
+if (process.argv[1]?.includes("generate-apple-jwt")) {
     const config: AppleAuthConfig = {
         teamId: process.env.AUTH_APPLE_TEAM_ID!,
         clientId: process.env.AUTH_APPLE_CLIENT_ID!,
diff --git a/launch.sh b/scripts/launch.sh
old mode 100755
new mode 100644
similarity index 100%
rename from launch.sh
rename to scripts/launch.sh
diff --git a/src/app/admin/layout.tsx b/src/app/admin/layout.tsx
new file mode 100644
index 00000000..d486309f
--- /dev/null
+++ b/src/app/admin/layout.tsx
@@ -0,0 +1,15 @@
+import { ReactNode } from "react";
+import { redirect } from "next/navigation";
+import { UserRole } from "../../generated/client/client";
+import { auth } from "@src/auth";
+
+export default async function AdminLayout({ children }: { children: ReactNode }) {
+    const session = await auth();
+    const role = (session?.user as unknown as { role?: UserRole } | undefined)?.role;
+
+    if (!session?.user || role !== UserRole.ADMIN) {
+        redirect("/");
+    }
+
+    return <>{children}</>;
+}
diff --git a/src/app/admin/page.tsx b/src/app/admin/page.tsx
new file mode 100644
index 00000000..56f39e72
--- /dev/null
+++ b/src/app/admin/page.tsx
@@ -0,0 +1,14 @@
+import { auth } from "@src/auth";
+import AdminShell from "@components/admin/AdminShell";
+import StatsCards from "@components/admin/StatsCards";
+
+export default async function AdminHomePage() {
+    const session = await auth();
+    const email = session?.user?.email ?? "";
+
+    return (
+        <AdminShell email={email} title="Overview" subtitle="Platform-wide metrics">
+            <StatsCards />
+        </AdminShell>
+    );
+}
diff --git a/src/app/admin/projects/[projectId]/page.tsx b/src/app/admin/projects/[projectId]/page.tsx
new file mode 100644
index 00000000..950d41dd
--- /dev/null
+++ b/src/app/admin/projects/[projectId]/page.tsx
@@ -0,0 +1,16 @@
+import { auth } from "@src/auth";
+import AdminShell from "@components/admin/AdminShell";
+import ProjectDetail from "@components/admin/ProjectDetail";
+
+type Props = { params: Promise<{ projectId: string }> };
+
+export default async function AdminProjectDetailPage({ params }: Props) {
+    const [session, { projectId }] = await Promise.all([auth(), params]);
+    const email = session?.user?.email ?? "";
+
+    return (
+        <AdminShell email={email} title="Project detail">
+            <ProjectDetail projectId={projectId} />
+        </AdminShell>
+    );
+}
diff --git a/src/app/admin/projects/page.tsx b/src/app/admin/projects/page.tsx
new file mode 100644
index 00000000..ce0e40b7
--- /dev/null
+++ b/src/app/admin/projects/page.tsx
@@ -0,0 +1,14 @@
+import { auth } from "@src/auth";
+import AdminShell from "@components/admin/AdminShell";
+import ProjectSearch from "@components/admin/ProjectSearch";
+
+export default async function AdminProjectsPage() {
+    const session = await auth();
+    const email = session?.user?.email ?? "";
+
+    return (
+        <AdminShell email={email} title="Projects" subtitle="Search by title or project ID">
+            <ProjectSearch />
+        </AdminShell>
+    );
+}
diff --git a/src/app/admin/users/[userId]/page.tsx b/src/app/admin/users/[userId]/page.tsx
new file mode 100644
index 00000000..f2853441
--- /dev/null
+++ b/src/app/admin/users/[userId]/page.tsx
@@ -0,0 +1,17 @@
+import { auth } from "@src/auth";
+import AdminShell from "@components/admin/AdminShell";
+import UserDetail from "@components/admin/UserDetail";
+
+type Props = { params: Promise<{ userId: string }> };
+
+export default async function AdminUserDetailPage({ params }: Props) {
+    const session = await auth();
+    const email = session?.user?.email ?? "";
+    const { userId } = await params;
+
+    return (
+        <AdminShell email={email} title="User detail">
+            <UserDetail userId={userId} />
+        </AdminShell>
+    );
+}
diff --git a/src/app/admin/users/page.tsx b/src/app/admin/users/page.tsx
new file mode 100644
index 00000000..92cc9fb7
--- /dev/null
+++ b/src/app/admin/users/page.tsx
@@ -0,0 +1,14 @@
+import { auth } from "@src/auth";
+import AdminShell from "@components/admin/AdminShell";
+import UserSearch from "@components/admin/UserSearch";
+
+export default async function AdminUsersPage() {
+    const session = await auth();
+    const email = session?.user?.email ?? "";
+
+    return (
+        <AdminShell email={email} title="Users" subtitle="Search by email or user ID">
+            <UserSearch />
+        </AdminShell>
+    );
+}
diff --git a/src/app/api/admin/projects/[projectId]/invites/route.ts b/src/app/api/admin/projects/[projectId]/invites/route.ts
new file mode 100644
index 00000000..850f845e
--- /dev/null
+++ b/src/app/api/admin/projects/[projectId]/invites/route.ts
@@ -0,0 +1,19 @@
+import { NextRequest } from "next/server";
+import z from "zod";
+
+import * as ProjectService from "@src/server/service/project-service";
+import { Success, validate } from "@src/lib/utils/api-utils";
+import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
+import { assertAdmin } from "@src/lib/utils/admin-guard";
+
+const ParamsSchema = z.object({ projectId: z.string().min(1) });
+
+async function getProjectInvites(req: NextRequest, { routeParams, user }: AuthApiContext) {
+    await assertAdmin(user);
+    const { projectId } = validate(ParamsSchema, routeParams);
+
+    const invites = await ProjectService.getInvitesWithMeta(projectId);
+    return Success(invites);
+}
+
+export const GET = apiHandler(getProjectInvites);
diff --git a/src/app/api/admin/projects/[projectId]/members/route.ts b/src/app/api/admin/projects/[projectId]/members/route.ts
new file mode 100644
index 00000000..4c76dd8c
--- /dev/null
+++ b/src/app/api/admin/projects/[projectId]/members/route.ts
@@ -0,0 +1,19 @@
+import { NextRequest } from "next/server";
+import z from "zod";
+
+import * as ProjectService from "@src/server/service/project-service";
+import { Success, validate } from "@src/lib/utils/api-utils";
+import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
+import { assertAdmin } from "@src/lib/utils/admin-guard";
+
+const ParamsSchema = z.object({ projectId: z.string().min(1) });
+
+async function getProjectMembers(req: NextRequest, { routeParams, user }: AuthApiContext) {
+    await assertAdmin(user);
+    const { projectId } = validate(ParamsSchema, routeParams);
+
+    const collaborators = await ProjectService.getCollaborators(projectId);
+    return Success(collaborators);
+}
+
+export const GET = apiHandler(getProjectMembers);
diff --git a/src/app/api/admin/projects/[projectId]/route.ts b/src/app/api/admin/projects/[projectId]/route.ts
new file mode 100644
index 00000000..b0da7c0d
--- /dev/null
+++ b/src/app/api/admin/projects/[projectId]/route.ts
@@ -0,0 +1,21 @@
+import { NextRequest } from "next/server";
+import z from "zod";
+
+import * as ProjectService from "@src/server/service/project-service";
+import { Success, validate, NotFoundError } from "@src/lib/utils/api-utils";
+import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
+import { assertAdmin } from "@src/lib/utils/admin-guard";
+
+const ParamsSchema = z.object({ projectId: z.string().min(1) });
+
+async function getProject(req: NextRequest, { routeParams, user }: AuthApiContext) {
+    await assertAdmin(user);
+    const { projectId } = validate(ParamsSchema, routeParams);
+
+    const project = await ProjectService.getProjectById(projectId);
+    if (!project) throw new NotFoundError();
+
+    return Success(project);
+}
+
+export const GET = apiHandler(getProject);
diff --git a/src/app/api/admin/projects/route.ts b/src/app/api/admin/projects/route.ts
new file mode 100644
index 00000000..003a394f
--- /dev/null
+++ b/src/app/api/admin/projects/route.ts
@@ -0,0 +1,33 @@
+import { NextRequest } from "next/server";
+import z from "zod";
+
+import * as ProjectService from "@src/server/service/project-service";
+import { Success, validate } from "@src/lib/utils/api-utils";
+import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
+import { assertAdmin } from "@src/lib/utils/admin-guard";
+
+const QuerySchema = z.object({
+    q: z.string().trim().min(1).max(256).optional(),
+    limit: z.coerce.number().int().min(1).max(100).optional(),
+    cursor: z.coerce.number().int().min(0).optional(),
+});
+
+async function searchProjects(req: NextRequest, { searchParams, user }: AuthApiContext) {
+    await assertAdmin(user);
+
+    const { q, limit = 25, cursor } = validate(QuerySchema, searchParams);
+    const term = (q ?? "").trim();
+
+    if (!term) {
+        return Success({ projects: [], nextCursor: null });
+    }
+
+    const projects = await ProjectService.searchProjects(term, limit + 1, cursor);
+    const hasMore = projects.length > limit;
+    const page = hasMore ? projects.slice(0, limit) : projects;
+    const nextCursor = hasMore ? (cursor ?? 0) + limit : null;
+
+    return Success({ projects: page, nextCursor });
+}
+
+export const GET = apiHandler(searchProjects);
diff --git a/src/app/api/admin/stats/route.ts b/src/app/api/admin/stats/route.ts
new file mode 100644
index 00000000..2a9e3cf8
--- /dev/null
+++ b/src/app/api/admin/stats/route.ts
@@ -0,0 +1,32 @@
+import { NextRequest } from "next/server";
+
+import * as UserService from "@src/server/service/user-service";
+import * as ProjectService from "@src/server/service/project-service";
+import * as TransactionService from "@src/server/service/transaction-service";
+import { Success } from "@src/lib/utils/api-utils";
+import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
+import { assertAdmin } from "@src/lib/utils/admin-guard";
+
+async function getStats(req: NextRequest, { user }: AuthApiContext) {
+    await assertAdmin(user);
+
+    const startOfMonth = new Date();
+    startOfMonth.setUTCDate(1);
+    startOfMonth.setUTCHours(0, 0, 0, 0);
+
+    const [userCount, activeProCount, projectCount, transactionsThisMonth] = await Promise.all([
+        UserService.countUsers(),
+        UserService.countActiveProUsers(),
+        ProjectService.countProjects(),
+        TransactionService.countTransactionsSince(startOfMonth),
+    ]);
+
+    return Success({
+        userCount,
+        activeProCount,
+        projectCount,
+        transactionsThisMonth,
+    });
+}
+
+export const GET = apiHandler(getStats);
diff --git a/src/app/api/admin/users/[userId]/projects/route.ts b/src/app/api/admin/users/[userId]/projects/route.ts
new file mode 100644
index 00000000..b78f4297
--- /dev/null
+++ b/src/app/api/admin/users/[userId]/projects/route.ts
@@ -0,0 +1,19 @@
+import { NextRequest } from "next/server";
+import z from "zod";
+
+import * as ProjectService from "@src/server/service/project-service";
+import { Success, validate } from "@src/lib/utils/api-utils";
+import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
+import { assertAdmin } from "@src/lib/utils/admin-guard";
+
+const ParamsSchema = z.object({ userId: z.string().min(1) });
+
+async function getUserProjects(req: NextRequest, { routeParams, user }: AuthApiContext) {
+    await assertAdmin(user);
+    const { userId } = validate(ParamsSchema, routeParams);
+
+    const memberships = await ProjectService.getMemberships(userId);
+    return Success(memberships ?? []);
+}
+
+export const GET = apiHandler(getUserProjects);
diff --git a/src/app/api/admin/users/[userId]/route.ts b/src/app/api/admin/users/[userId]/route.ts
new file mode 100644
index 00000000..8d79a2c7
--- /dev/null
+++ b/src/app/api/admin/users/[userId]/route.ts
@@ -0,0 +1,42 @@
+import { NextRequest } from "next/server";
+import z from "zod";
+
+import * as UserService from "@src/server/service/user-service";
+import * as ProjectService from "@src/server/service/project-service";
+import * as TransactionService from "@src/server/service/transaction-service";
+import { Success, UserNotFoundError, validate } from "@src/lib/utils/api-utils";
+import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
+import { assertAdmin } from "@src/lib/utils/admin-guard";
+
+const ParamsSchema = z.object({ userId: z.string().min(1) });
+
+async function getUserDetail(req: NextRequest, { routeParams, user }: AuthApiContext) {
+    await assertAdmin(user);
+    const { userId } = validate(ParamsSchema, routeParams);
+
+    const target = await UserService.getUserFromId(userId);
+    if (!target) throw new UserNotFoundError();
+
+    const [projectCount, transactionCount] = await Promise.all([
+        ProjectService.countMembershipsByUser(userId),
+        TransactionService.countTransactionsByUser(userId),
+    ]);
+
+    return Success({
+        user: {
+            id: target.id,
+            email: target.email,
+            createdAt: target.createdAt,
+            emailVerified: target.emailVerified,
+            username: target.username,
+            role: target.role,
+            isProUntil: target.isProUntil,
+            isSubscriptionCancelled: target.isSubscriptionCancelled,
+            subscriptionProvider: target.subscriptionProvider,
+        },
+        projectCount,
+        transactionCount,
+    });
+}
+
+export const GET = apiHandler(getUserDetail);
diff --git a/src/app/api/admin/users/[userId]/transactions/route.ts b/src/app/api/admin/users/[userId]/transactions/route.ts
new file mode 100644
index 00000000..a5881d08
--- /dev/null
+++ b/src/app/api/admin/users/[userId]/transactions/route.ts
@@ -0,0 +1,19 @@
+import { NextRequest } from "next/server";
+import z from "zod";
+
+import * as TransactionService from "@src/server/service/transaction-service";
+import { Success, validate } from "@src/lib/utils/api-utils";
+import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
+import { assertAdmin } from "@src/lib/utils/admin-guard";
+
+const ParamsSchema = z.object({ userId: z.string().min(1) });
+
+async function getUserTransactions(req: NextRequest, { routeParams, user }: AuthApiContext) {
+    await assertAdmin(user);
+    const { userId } = validate(ParamsSchema, routeParams);
+
+    const transactions = await TransactionService.getTransactionsByUser(userId);
+    return Success(transactions);
+}
+
+export const GET = apiHandler(getUserTransactions);
diff --git a/src/app/api/admin/users/route.ts b/src/app/api/admin/users/route.ts
new file mode 100644
index 00000000..c134b4bb
--- /dev/null
+++ b/src/app/api/admin/users/route.ts
@@ -0,0 +1,33 @@
+import { NextRequest } from "next/server";
+import z from "zod";
+
+import * as UserService from "@src/server/service/user-service";
+import { Success, validate } from "@src/lib/utils/api-utils";
+import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
+import { assertAdmin } from "@src/lib/utils/admin-guard";
+
+const QuerySchema = z.object({
+    q: z.string().trim().min(1).max(256).optional(),
+    limit: z.coerce.number().int().min(1).max(100).optional(),
+    cursor: z.coerce.number().int().min(0).optional(),
+});
+
+async function searchUsers(req: NextRequest, { searchParams, user }: AuthApiContext) {
+    await assertAdmin(user);
+
+    const { q, limit = 25, cursor } = validate(QuerySchema, searchParams);
+    const term = (q ?? "").trim();
+
+    if (!term) {
+        return Success({ users: [], nextCursor: null });
+    }
+
+    const users = await UserService.searchUsers(term, limit + 1, cursor);
+    const hasMore = users.length > limit;
+    const page = hasMore ? users.slice(0, limit) : users;
+    const nextCursor = hasMore ? (cursor ?? 0) + limit : null;
+
+    return Success({ users: page, nextCursor });
+}
+
+export const GET = apiHandler(searchUsers);
diff --git a/src/app/api/metrics/route.ts b/src/app/api/metrics/route.ts
new file mode 100644
index 00000000..17645d93
--- /dev/null
+++ b/src/app/api/metrics/route.ts
@@ -0,0 +1,30 @@
+import { NextRequest, NextResponse } from "next/server";
+import { timingSafeEqual } from "crypto";
+import { registry } from "../../../lib/metrics/registry";
+import { startDbSizeCollector } from "../../../lib/metrics/db-size-collector";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+startDbSizeCollector();
+
+const isAuthorized = (header: string | null): boolean => {
+    const expected = process.env.METRICS_BEARER_TOKEN;
+    if (!expected || !header?.startsWith("Bearer ")) return false;
+    const provided = header.slice("Bearer ".length);
+    const a = new Uint8Array(Buffer.from(provided));
+    const b = new Uint8Array(Buffer.from(expected));
+    if (a.length !== b.length) return false;
+    return timingSafeEqual(a, b);
+};
+
+export const GET = async (req: NextRequest) => {
+    if (!isAuthorized(req.headers.get("authorization"))) {
+        return new NextResponse("Unauthorized", { status: 401 });
+    }
+    const body = await registry.metrics();
+    return new NextResponse(body, {
+        status: 200,
+        headers: { "Content-Type": registry.contentType },
+    });
+};
diff --git a/src/app/api/projects/[projectId]/invite/route.ts b/src/app/api/projects/[projectId]/invite/route.ts
index 4879bb01..c6f3a99c 100644
--- a/src/app/api/projects/[projectId]/invite/route.ts
+++ b/src/app/api/projects/[projectId]/invite/route.ts
@@ -1,5 +1,5 @@
 import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
-import { ProjectRole } from "@prisma/client";
+import { ProjectRole } from "../../../../../generated/client/client";
 import {
     ForbiddenError,
     InternalServerError,
diff --git a/src/app/api/projects/[projectId]/members/[userId]/route.ts b/src/app/api/projects/[projectId]/members/[userId]/route.ts
index 8a89ae1f..3ad9c65d 100644
--- a/src/app/api/projects/[projectId]/members/[userId]/route.ts
+++ b/src/app/api/projects/[projectId]/members/[userId]/route.ts
@@ -1,4 +1,4 @@
-import { ProjectRole } from "@prisma/client";
+import { ProjectRole } from "../../../../../../generated/client/client";
 import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
 import {
     ForbiddenError,
@@ -12,7 +12,7 @@ import {
 
 import * as Roles from "@src/lib/utils/roles";
 import * as ProjectService from "@src/server/service/project-service";
-import * as CollabUtils from "@src/lib/collaboration/utils";
+import * as CollabUtils from "@src/lib/cloud/utils";
 
 import z from "zod";
 import { NextRequest } from "next/server";
diff --git a/src/app/api/projects/[projectId]/route.ts b/src/app/api/projects/[projectId]/route.ts
index 9e39e2da..e88c9ac3 100644
--- a/src/app/api/projects/[projectId]/route.ts
+++ b/src/app/api/projects/[projectId]/route.ts
@@ -1,4 +1,4 @@
-import { ProjectRole } from "@prisma/client";
+import { ProjectRole } from "../../../../generated/client/client";
 
 import * as S3 from "@src/lib/s3";
 import * as ProjectService from "@src/server/service/project-service";
diff --git a/src/app/api/projects/[projectId]/saves/manual/route.ts b/src/app/api/projects/[projectId]/saves/manual/route.ts
index ad318231..03628455 100644
--- a/src/app/api/projects/[projectId]/saves/manual/route.ts
+++ b/src/app/api/projects/[projectId]/saves/manual/route.ts
@@ -1,4 +1,4 @@
-import { ProjectRole } from "@prisma/client";
+import { ProjectRole } from "../../../../../../generated/client/client";
 import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
 import {
     ForbiddenError,
diff --git a/src/app/api/projects/[projectId]/saves/restore/route.ts b/src/app/api/projects/[projectId]/saves/restore/route.ts
index fcc4338e..baa5e054 100644
--- a/src/app/api/projects/[projectId]/saves/restore/route.ts
+++ b/src/app/api/projects/[projectId]/saves/restore/route.ts
@@ -1,4 +1,4 @@
-import { ProjectRole } from "@prisma/client";
+import { ProjectRole } from "../../../../../../generated/client/client";
 import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
 import { ForbiddenError, getCollabHttpUrl, Success, validate } from "@src/lib/utils/api-utils";
 
diff --git a/src/app/api/projects/[projectId]/saves/route.ts b/src/app/api/projects/[projectId]/saves/route.ts
index 99ca56e1..b329c024 100644
--- a/src/app/api/projects/[projectId]/saves/route.ts
+++ b/src/app/api/projects/[projectId]/saves/route.ts
@@ -1,4 +1,4 @@
-import { ProjectRole } from "@prisma/client";
+import { ProjectRole } from "../../../../../generated/client/client";
 import { apiHandler, AuthApiContext } from "@src/lib/utils/api-handler";
 import { ForbiddenError, getCollabHttpUrl, Success, validate } from "@src/lib/utils/api-utils";
 
diff --git a/src/auth.ts b/src/auth.ts
index 4510fcdb..d0bd650d 100644
--- a/src/auth.ts
+++ b/src/auth.ts
@@ -2,6 +2,7 @@ import NextAuth from "next-auth";
 import Google from "next-auth/providers/google";
 import Apple from "next-auth/providers/apple";
 import { PrismaAdapter } from "@auth/prisma-adapter";
+import { UserRole } from "./generated/client/client";
 
 import prisma from "@src/server/db";
 import * as UserService from "@src/server/service/user-service";
@@ -26,13 +27,19 @@ export const { handlers, auth, signIn, signOut } = NextAuth({
             if (user) {
                 token.id = user.id;
                 token.email = user.email;
-                // `createdAt` is set on programmatic sign-in (string) and missing for OAuth — fill it in
+                // `createdAt` may be available on programmatic sign-in but not OAuth.
                 const extUser = user as typeof user & { createdAt?: string };
                 if (extUser.createdAt) {
                     token.createdAt = extUser.createdAt;
-                } else if (token.id && !token.createdAt) {
-                    const dbUser = await UserService.getUserFromId(token.id as string);
-                    if (dbUser) token.createdAt = dbUser.createdAt.toISOString();
+                }
+            }
+            // Always sync from DB so role changes (e.g. granting admin) are reflected
+            // without requiring a sign-out. Called on every auth() invocation.
+            if (token.id) {
+                const dbUser = await UserService.getUserFromId(token.id as string);
+                if (dbUser) {
+                    if (!token.createdAt) token.createdAt = dbUser.createdAt.toISOString();
+                    token.role = dbUser.role;
                 }
             }
             return token;
@@ -44,7 +51,13 @@ export const { handlers, auth, signIn, signOut } = NextAuth({
                     id: token.id as string,
                     email: token.email as string,
                     createdAt: token.createdAt ? new Date(token.createdAt as string) : new Date(),
-                } as typeof session.user & { id: string; email: string; createdAt: Date };
+                    role: (token.role as UserRole) ?? UserRole.USER,
+                } as typeof session.user & {
+                    id: string;
+                    email: string;
+                    createdAt: Date;
+                    role: UserRole;
+                };
             }
             return session;
         },
diff --git a/src/context/ProjectContext.tsx b/src/context/ProjectContext.tsx
index c1e2144e..84511436 100644
--- a/src/context/ProjectContext.tsx
+++ b/src/context/ProjectContext.tsx
@@ -1,6 +1,14 @@
 "use client";
 
-import { createContext, ReactNode, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import {
+    createContext,
+    ReactNode,
+    useCallback,
+    useContext,
+    useEffect,
+    useMemo,
+    useState,
+} from "react";
 import { Editor } from "@tiptap/react";
 import { CharacterMap, mergeCharactersData } from "@src/lib/screenplay/characters";
 import { LocationMap, mergeLocationsData } from "@src/lib/screenplay/locations";
@@ -22,7 +30,7 @@ import { ScreenplayElement, TitlePageElement, Style, PageFormat } from "@src/lib
 import { SearchMatch } from "@src/lib/screenplay/extensions/search-highlight-extension";
 
 // Import types only - these don't cause module loading
-import type { ThrottledWebsocketProvider } from "@src/lib/collaboration/utils";
+import type { ThrottledWebsocketProvider } from "@src/lib/cloud/utils";
 import type { ProjectRepository } from "@src/lib/project/project-repository";
 
 // -------------------------------- //
@@ -258,7 +266,9 @@ export const ProjectProvider = ({ children, projectId }: ProjectProviderProps) =
     const [characters, setCharacters] = useState<CharacterMap | undefined>(undefined);
     const [locations, setLocations] = useState<LocationMap | undefined>(undefined);
     const [scenes, setScenes] = useState<Scene[]>([]);
-    const [selectedElement, setSelectedElementState] = useState<ScreenplayElement>(ScreenplayElement.Action);
+    const [selectedElement, setSelectedElementState] = useState<ScreenplayElement>(
+        ScreenplayElement.Action,
+    );
     const [selectedStyles, setSelectedStylesState] = useState<Style>(Style.None);
     const [highlightedCharacters, setHighlightedCharacters] = useState<Set<string>>(new Set());
     const [pageFormat, setPageFormatState] = useState<PageFormat>("LETTER");
@@ -268,7 +278,9 @@ export const ProjectProvider = ({ children, projectId }: ProjectProviderProps) =
     const [sceneNumberOnRight, setSceneNumberOnRightState] = useState<boolean>(false);
     const [contdLabel, setContdLabelState] = useState<string>("(CONT'D)");
     const [moreLabel, setMoreLabelState] = useState<string>("(MORE)");
-    const [elementMargins, setElementMarginsState] = useState<Record<string, { left: number; right: number }>>({});
+    const [elementMargins, setElementMarginsState] = useState<
+        Record<string, { left: number; right: number }>
+    >({});
     const [elementStyles, setElementStylesState] = useState<Record<string, ElementStyle>>({});
     const [connectionStatus, setConnectionStatus] = useState<ConnectionStatus>("disconnected");
     const [users, setUsers] = useState<CollaboratorInfo[]>([]);
@@ -300,7 +312,9 @@ export const ProjectProvider = ({ children, projectId }: ProjectProviderProps) =
     );
 
     // Focus tracking state
-    const [focusedEditorType, setFocusedEditorTypeState] = useState<"screenplay" | "title" | "draft" | null>(null);
+    const [focusedEditorType, setFocusedEditorTypeState] = useState<
+        "screenplay" | "title" | "draft" | null
+    >(null);
 
     // Draft editor state
     const [draftEditor, setDraftEditor] = useState<Editor | null>(null);
@@ -308,7 +322,10 @@ export const ProjectProvider = ({ children, projectId }: ProjectProviderProps) =
 
     // Shelf state
     const [shelfEntries, setShelfEntries] = useState<Record<string, ShelfEntry>>({});
-    const [activeShelfVersion, setActiveShelfVersion] = useState<{ nodeId: string; versionId: string } | null>(null);
+    const [activeShelfVersion, setActiveShelfVersion] = useState<{
+        nodeId: string;
+        versionId: string;
+    } | null>(null);
 
     // Create repository instance when ydoc is available (dynamically imported)
     useEffect(() => {
@@ -378,7 +395,10 @@ export const ProjectProvider = ({ children, projectId }: ProjectProviderProps) =
         // elementStyles starts as {} and defaults always win).
         const initialLayout = repository.getLayout();
         if (initialLayout) {
-            if (initialLayout.pageSize && (initialLayout.pageSize === "A4" || initialLayout.pageSize === "LETTER")) {
+            if (
+                initialLayout.pageSize &&
+                (initialLayout.pageSize === "A4" || initialLayout.pageSize === "LETTER")
+            ) {
                 setPageFormatState(initialLayout.pageSize);
             }
             if (initialLayout.pageMargins !== undefined) {
@@ -522,7 +542,8 @@ export const ProjectProvider = ({ children, projectId }: ProjectProviderProps) =
             const hasTitle = !!repository.getTitle();
             const hasAuthor = !!repository.getAuthor();
             if (hasTitle && hasAuthor) return;
-            const { getCachedProject } = await import("@src/lib/persistence/storage-provider/local-persistence");
+            const { getCachedProject } =
+                await import("@src/lib/persistence/storage-provider/local-persistence");
             const local = await getCachedProject(projectId);
             if (!local) return;
             if (!hasTitle && local.title) repository.setTitle(local.title);
@@ -819,7 +840,10 @@ export const ProjectProvider = ({ children, projectId }: ProjectProviderProps) =
         ],
     );
 
-    const readyValue = useMemo(() => ({ isYjsReady, isProjectUnavailable }), [isYjsReady, isProjectUnavailable]);
+    const readyValue = useMemo(
+        () => ({ isYjsReady, isProjectUnavailable }),
+        [isYjsReady, isProjectUnavailable],
+    );
 
     return (
         <ProjectReadyContext.Provider value={readyValue}>
diff --git a/src/generated/client/browser.ts b/src/generated/client/browser.ts
new file mode 100644
index 00000000..67c129be
--- /dev/null
+++ b/src/generated/client/browser.ts
@@ -0,0 +1,64 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma-related types and utilities in a browser. 
+ * Use it to get access to models, enums, and input types.
+ * 
+ * This file does not contain a `PrismaClient` class, nor several other helpers that are intended as server-side only.
+ * See `client.ts` for the standard, server-side entry point.
+ *
+ * 🟢 You can import this file directly.
+ */
+
+import * as Prisma from './internal/prismaNamespaceBrowser'
+export { Prisma }
+export * as $Enums from './enums'
+export * from './enums';
+/**
+ * Model User
+ * 
+ */
+export type User = Prisma.UserModel
+/**
+ * Model Account
+ * 
+ */
+export type Account = Prisma.AccountModel
+/**
+ * Model Session
+ * 
+ */
+export type Session = Prisma.SessionModel
+/**
+ * Model VerificationToken
+ * 
+ */
+export type VerificationToken = Prisma.VerificationTokenModel
+/**
+ * Model MagicLinkToken
+ * 
+ */
+export type MagicLinkToken = Prisma.MagicLinkTokenModel
+/**
+ * Model Transaction
+ * 
+ */
+export type Transaction = Prisma.TransactionModel
+/**
+ * Model Project
+ * 
+ */
+export type Project = Prisma.ProjectModel
+/**
+ * Model ProjectMember
+ * 
+ */
+export type ProjectMember = Prisma.ProjectMemberModel
+/**
+ * Model ProjectInvitation
+ * 
+ */
+export type ProjectInvitation = Prisma.ProjectInvitationModel
diff --git a/src/generated/client/client.ts b/src/generated/client/client.ts
new file mode 100644
index 00000000..659230b0
--- /dev/null
+++ b/src/generated/client/client.ts
@@ -0,0 +1,88 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma. Through it you get access to all the models, enums, and input types.
+ * If you're looking for something you can import in the client-side of your application, please refer to the `browser.ts` file instead.
+ *
+ * 🟢 You can import this file directly.
+ */
+
+import * as process from 'node:process'
+import * as path from 'node:path'
+import { fileURLToPath } from 'node:url'
+globalThis['__dirname'] = path.dirname(fileURLToPath(import.meta.url))
+
+import * as runtime from "@prisma/client/runtime/client"
+import * as $Enums from "./enums"
+import * as $Class from "./internal/class"
+import * as Prisma from "./internal/prismaNamespace"
+
+export * as $Enums from './enums'
+export * from "./enums"
+/**
+ * ## Prisma Client
+ * 
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more Users
+ * const users = await prisma.user.findMany()
+ * ```
+ * 
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+export const PrismaClient = $Class.getPrismaClientClass()
+export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs>
+export { Prisma }
+
+/**
+ * Model User
+ * 
+ */
+export type User = Prisma.UserModel
+/**
+ * Model Account
+ * 
+ */
+export type Account = Prisma.AccountModel
+/**
+ * Model Session
+ * 
+ */
+export type Session = Prisma.SessionModel
+/**
+ * Model VerificationToken
+ * 
+ */
+export type VerificationToken = Prisma.VerificationTokenModel
+/**
+ * Model MagicLinkToken
+ * 
+ */
+export type MagicLinkToken = Prisma.MagicLinkTokenModel
+/**
+ * Model Transaction
+ * 
+ */
+export type Transaction = Prisma.TransactionModel
+/**
+ * Model Project
+ * 
+ */
+export type Project = Prisma.ProjectModel
+/**
+ * Model ProjectMember
+ * 
+ */
+export type ProjectMember = Prisma.ProjectMemberModel
+/**
+ * Model ProjectInvitation
+ * 
+ */
+export type ProjectInvitation = Prisma.ProjectInvitationModel
diff --git a/src/generated/client/commonInputTypes.ts b/src/generated/client/commonInputTypes.ts
new file mode 100644
index 00000000..fa37c0df
--- /dev/null
+++ b/src/generated/client/commonInputTypes.ts
@@ -0,0 +1,617 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports various common sort, input & filter types that are not directly linked to a particular model.
+ *
+ * 🟢 You can import this file directly.
+ */
+
+import type * as runtime from "@prisma/client/runtime/client"
+import * as $Enums from "./enums"
+import type * as Prisma from "./internal/prismaNamespace"
+
+
+export type StringFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  mode?: Prisma.QueryMode
+  not?: Prisma.NestedStringFilter<$PrismaModel> | string
+}
+
+export type DateTimeFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeFilter<$PrismaModel> | Date | string
+}
+
+export type DateTimeNullableFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
+}
+
+export type StringNullableFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  mode?: Prisma.QueryMode
+  not?: Prisma.NestedStringNullableFilter<$PrismaModel> | string | null
+}
+
+export type EnumUserRoleFilter<$PrismaModel = never> = {
+  equals?: $Enums.UserRole | Prisma.EnumUserRoleFieldRefInput<$PrismaModel>
+  in?: $Enums.UserRole[] | Prisma.ListEnumUserRoleFieldRefInput<$PrismaModel>
+  notIn?: $Enums.UserRole[] | Prisma.ListEnumUserRoleFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumUserRoleFilter<$PrismaModel> | $Enums.UserRole
+}
+
+export type BoolFilter<$PrismaModel = never> = {
+  equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedBoolFilter<$PrismaModel> | boolean
+}
+
+export type EnumSubscriptionProviderNullableFilter<$PrismaModel = never> = {
+  equals?: $Enums.SubscriptionProvider | Prisma.EnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  in?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  notIn?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  not?: Prisma.NestedEnumSubscriptionProviderNullableFilter<$PrismaModel> | $Enums.SubscriptionProvider | null
+}
+
+export type JsonNullableFilter<$PrismaModel = never> =
+| Prisma.PatchUndefined<
+    Prisma.Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>,
+    Required<JsonNullableFilterBase<$PrismaModel>>
+  >
+| Prisma.OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>
+
+export type JsonNullableFilterBase<$PrismaModel = never> = {
+  equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+  path?: string[]
+  mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
+  string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+}
+
+export type SortOrderInput = {
+  sort: Prisma.SortOrder
+  nulls?: Prisma.NullsOrder
+}
+
+export type StringWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  mode?: Prisma.QueryMode
+  not?: Prisma.NestedStringWithAggregatesFilter<$PrismaModel> | string
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedStringFilter<$PrismaModel>
+  _max?: Prisma.NestedStringFilter<$PrismaModel>
+}
+
+export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedDateTimeFilter<$PrismaModel>
+  _max?: Prisma.NestedDateTimeFilter<$PrismaModel>
+}
+
+export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedDateTimeNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedDateTimeNullableFilter<$PrismaModel>
+}
+
+export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  mode?: Prisma.QueryMode
+  not?: Prisma.NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedStringNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedStringNullableFilter<$PrismaModel>
+}
+
+export type EnumUserRoleWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.UserRole | Prisma.EnumUserRoleFieldRefInput<$PrismaModel>
+  in?: $Enums.UserRole[] | Prisma.ListEnumUserRoleFieldRefInput<$PrismaModel>
+  notIn?: $Enums.UserRole[] | Prisma.ListEnumUserRoleFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumUserRoleWithAggregatesFilter<$PrismaModel> | $Enums.UserRole
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumUserRoleFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumUserRoleFilter<$PrismaModel>
+}
+
+export type BoolWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedBoolFilter<$PrismaModel>
+  _max?: Prisma.NestedBoolFilter<$PrismaModel>
+}
+
+export type EnumSubscriptionProviderNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.SubscriptionProvider | Prisma.EnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  in?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  notIn?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  not?: Prisma.NestedEnumSubscriptionProviderNullableWithAggregatesFilter<$PrismaModel> | $Enums.SubscriptionProvider | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumSubscriptionProviderNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumSubscriptionProviderNullableFilter<$PrismaModel>
+}
+
+export type JsonNullableWithAggregatesFilter<$PrismaModel = never> =
+| Prisma.PatchUndefined<
+    Prisma.Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
+    Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>
+  >
+| Prisma.OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>
+
+export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
+  equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+  path?: string[]
+  mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
+  string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedJsonNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedJsonNullableFilter<$PrismaModel>
+}
+
+export type IntNullableFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntNullableFilter<$PrismaModel> | number | null
+}
+
+export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _avg?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+  _sum?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedIntNullableFilter<$PrismaModel>
+}
+
+export type IntFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntFilter<$PrismaModel> | number
+}
+
+export type IntWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntWithAggregatesFilter<$PrismaModel> | number
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _avg?: Prisma.NestedFloatFilter<$PrismaModel>
+  _sum?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedIntFilter<$PrismaModel>
+  _max?: Prisma.NestedIntFilter<$PrismaModel>
+}
+
+export type EnumSubscriptionProviderFilter<$PrismaModel = never> = {
+  equals?: $Enums.SubscriptionProvider | Prisma.EnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  in?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  notIn?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumSubscriptionProviderFilter<$PrismaModel> | $Enums.SubscriptionProvider
+}
+
+export type EnumSubscriptionProviderWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.SubscriptionProvider | Prisma.EnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  in?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  notIn?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumSubscriptionProviderWithAggregatesFilter<$PrismaModel> | $Enums.SubscriptionProvider
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumSubscriptionProviderFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumSubscriptionProviderFilter<$PrismaModel>
+}
+
+export type EnumProjectRoleFilter<$PrismaModel = never> = {
+  equals?: $Enums.ProjectRole | Prisma.EnumProjectRoleFieldRefInput<$PrismaModel>
+  in?: $Enums.ProjectRole[] | Prisma.ListEnumProjectRoleFieldRefInput<$PrismaModel>
+  notIn?: $Enums.ProjectRole[] | Prisma.ListEnumProjectRoleFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumProjectRoleFilter<$PrismaModel> | $Enums.ProjectRole
+}
+
+export type EnumProjectRoleWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.ProjectRole | Prisma.EnumProjectRoleFieldRefInput<$PrismaModel>
+  in?: $Enums.ProjectRole[] | Prisma.ListEnumProjectRoleFieldRefInput<$PrismaModel>
+  notIn?: $Enums.ProjectRole[] | Prisma.ListEnumProjectRoleFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumProjectRoleWithAggregatesFilter<$PrismaModel> | $Enums.ProjectRole
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumProjectRoleFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumProjectRoleFilter<$PrismaModel>
+}
+
+export type NestedStringFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedStringFilter<$PrismaModel> | string
+}
+
+export type NestedDateTimeFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeFilter<$PrismaModel> | Date | string
+}
+
+export type NestedDateTimeNullableFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
+}
+
+export type NestedStringNullableFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedStringNullableFilter<$PrismaModel> | string | null
+}
+
+export type NestedEnumUserRoleFilter<$PrismaModel = never> = {
+  equals?: $Enums.UserRole | Prisma.EnumUserRoleFieldRefInput<$PrismaModel>
+  in?: $Enums.UserRole[] | Prisma.ListEnumUserRoleFieldRefInput<$PrismaModel>
+  notIn?: $Enums.UserRole[] | Prisma.ListEnumUserRoleFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumUserRoleFilter<$PrismaModel> | $Enums.UserRole
+}
+
+export type NestedBoolFilter<$PrismaModel = never> = {
+  equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedBoolFilter<$PrismaModel> | boolean
+}
+
+export type NestedEnumSubscriptionProviderNullableFilter<$PrismaModel = never> = {
+  equals?: $Enums.SubscriptionProvider | Prisma.EnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  in?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  notIn?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  not?: Prisma.NestedEnumSubscriptionProviderNullableFilter<$PrismaModel> | $Enums.SubscriptionProvider | null
+}
+
+export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel>
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedStringWithAggregatesFilter<$PrismaModel> | string
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedStringFilter<$PrismaModel>
+  _max?: Prisma.NestedStringFilter<$PrismaModel>
+}
+
+export type NestedIntFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntFilter<$PrismaModel> | number
+}
+
+export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel>
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedDateTimeFilter<$PrismaModel>
+  _max?: Prisma.NestedDateTimeFilter<$PrismaModel>
+}
+
+export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel> | null
+  in?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  notIn?: Date[] | string[] | Prisma.ListDateTimeFieldRefInput<$PrismaModel> | null
+  lt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  lte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gt?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  gte?: Date | string | Prisma.DateTimeFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedDateTimeNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedDateTimeNullableFilter<$PrismaModel>
+}
+
+export type NestedIntNullableFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntNullableFilter<$PrismaModel> | number | null
+}
+
+export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: string | Prisma.StringFieldRefInput<$PrismaModel> | null
+  in?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  notIn?: string[] | Prisma.ListStringFieldRefInput<$PrismaModel> | null
+  lt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  lte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gt?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  gte?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  startsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  endsWith?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedStringNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedStringNullableFilter<$PrismaModel>
+}
+
+export type NestedEnumUserRoleWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.UserRole | Prisma.EnumUserRoleFieldRefInput<$PrismaModel>
+  in?: $Enums.UserRole[] | Prisma.ListEnumUserRoleFieldRefInput<$PrismaModel>
+  notIn?: $Enums.UserRole[] | Prisma.ListEnumUserRoleFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumUserRoleWithAggregatesFilter<$PrismaModel> | $Enums.UserRole
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumUserRoleFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumUserRoleFilter<$PrismaModel>
+}
+
+export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: boolean | Prisma.BooleanFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedBoolFilter<$PrismaModel>
+  _max?: Prisma.NestedBoolFilter<$PrismaModel>
+}
+
+export type NestedEnumSubscriptionProviderNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.SubscriptionProvider | Prisma.EnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  in?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  notIn?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel> | null
+  not?: Prisma.NestedEnumSubscriptionProviderNullableWithAggregatesFilter<$PrismaModel> | $Enums.SubscriptionProvider | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumSubscriptionProviderNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumSubscriptionProviderNullableFilter<$PrismaModel>
+}
+
+export type NestedJsonNullableFilter<$PrismaModel = never> =
+| Prisma.PatchUndefined<
+    Prisma.Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>,
+    Required<NestedJsonNullableFilterBase<$PrismaModel>>
+  >
+| Prisma.OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>
+
+export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
+  equals?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+  path?: string[]
+  mode?: Prisma.QueryMode | Prisma.EnumQueryModeFieldRefInput<$PrismaModel>
+  string_contains?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_starts_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  string_ends_with?: string | Prisma.StringFieldRefInput<$PrismaModel>
+  array_starts_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_ends_with?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  array_contains?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | null
+  lt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  lte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gt?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  gte?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel>
+  not?: runtime.InputJsonValue | Prisma.JsonFieldRefInput<$PrismaModel> | Prisma.JsonNullValueFilter
+}
+
+export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
+  _count?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _avg?: Prisma.NestedFloatNullableFilter<$PrismaModel>
+  _sum?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _min?: Prisma.NestedIntNullableFilter<$PrismaModel>
+  _max?: Prisma.NestedIntNullableFilter<$PrismaModel>
+}
+
+export type NestedFloatNullableFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.FloatFieldRefInput<$PrismaModel> | null
+  in?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null
+  notIn?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel> | null
+  lt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedFloatNullableFilter<$PrismaModel> | number | null
+}
+
+export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  in?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  notIn?: number[] | Prisma.ListIntFieldRefInput<$PrismaModel>
+  lt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.IntFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedIntWithAggregatesFilter<$PrismaModel> | number
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _avg?: Prisma.NestedFloatFilter<$PrismaModel>
+  _sum?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedIntFilter<$PrismaModel>
+  _max?: Prisma.NestedIntFilter<$PrismaModel>
+}
+
+export type NestedFloatFilter<$PrismaModel = never> = {
+  equals?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  in?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel>
+  notIn?: number[] | Prisma.ListFloatFieldRefInput<$PrismaModel>
+  lt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  lte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gt?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  gte?: number | Prisma.FloatFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedFloatFilter<$PrismaModel> | number
+}
+
+export type NestedEnumSubscriptionProviderFilter<$PrismaModel = never> = {
+  equals?: $Enums.SubscriptionProvider | Prisma.EnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  in?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  notIn?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumSubscriptionProviderFilter<$PrismaModel> | $Enums.SubscriptionProvider
+}
+
+export type NestedEnumSubscriptionProviderWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.SubscriptionProvider | Prisma.EnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  in?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  notIn?: $Enums.SubscriptionProvider[] | Prisma.ListEnumSubscriptionProviderFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumSubscriptionProviderWithAggregatesFilter<$PrismaModel> | $Enums.SubscriptionProvider
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumSubscriptionProviderFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumSubscriptionProviderFilter<$PrismaModel>
+}
+
+export type NestedEnumProjectRoleFilter<$PrismaModel = never> = {
+  equals?: $Enums.ProjectRole | Prisma.EnumProjectRoleFieldRefInput<$PrismaModel>
+  in?: $Enums.ProjectRole[] | Prisma.ListEnumProjectRoleFieldRefInput<$PrismaModel>
+  notIn?: $Enums.ProjectRole[] | Prisma.ListEnumProjectRoleFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumProjectRoleFilter<$PrismaModel> | $Enums.ProjectRole
+}
+
+export type NestedEnumProjectRoleWithAggregatesFilter<$PrismaModel = never> = {
+  equals?: $Enums.ProjectRole | Prisma.EnumProjectRoleFieldRefInput<$PrismaModel>
+  in?: $Enums.ProjectRole[] | Prisma.ListEnumProjectRoleFieldRefInput<$PrismaModel>
+  notIn?: $Enums.ProjectRole[] | Prisma.ListEnumProjectRoleFieldRefInput<$PrismaModel>
+  not?: Prisma.NestedEnumProjectRoleWithAggregatesFilter<$PrismaModel> | $Enums.ProjectRole
+  _count?: Prisma.NestedIntFilter<$PrismaModel>
+  _min?: Prisma.NestedEnumProjectRoleFilter<$PrismaModel>
+  _max?: Prisma.NestedEnumProjectRoleFilter<$PrismaModel>
+}
+
+
diff --git a/src/generated/client/enums.ts b/src/generated/client/enums.ts
new file mode 100644
index 00000000..fa949563
--- /dev/null
+++ b/src/generated/client/enums.ts
@@ -0,0 +1,35 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+* This file exports all enum related types from the schema.
+*
+* 🟢 You can import this file directly.
+*/
+
+export const ProjectRole = {
+  OWNER: 'OWNER',
+  ADMIN: 'ADMIN',
+  EDITOR: 'EDITOR',
+  VIEWER: 'VIEWER'
+} as const
+
+export type ProjectRole = (typeof ProjectRole)[keyof typeof ProjectRole]
+
+
+export const UserRole = {
+  USER: 'USER',
+  ADMIN: 'ADMIN'
+} as const
+
+export type UserRole = (typeof UserRole)[keyof typeof UserRole]
+
+
+export const SubscriptionProvider = {
+  STRIPE: 'STRIPE',
+  APPLE: 'APPLE'
+} as const
+
+export type SubscriptionProvider = (typeof SubscriptionProvider)[keyof typeof SubscriptionProvider]
diff --git a/src/generated/client/internal/class.ts b/src/generated/client/internal/class.ts
new file mode 100644
index 00000000..2c766b49
--- /dev/null
+++ b/src/generated/client/internal/class.ts
@@ -0,0 +1,284 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * WARNING: This is an internal file that is subject to change!
+ *
+ * 🛑 Under no circumstances should you import this file directly! 🛑
+ *
+ * Please import the `PrismaClient` class from the `client.ts` file instead.
+ */
+
+import * as runtime from "@prisma/client/runtime/client"
+import type * as Prisma from "./prismaNamespace"
+
+
+const config: runtime.GetPrismaClientConfig = {
+  "previewFeatures": [],
+  "clientVersion": "7.7.0",
+  "engineVersion": "75cbdc1eb7150937890ad5465d861175c6624711",
+  "activeProvider": "postgresql",
+  "inlineSchema": "// This is your Prisma schema file,\n// learn more about it in the docs: https://pris.ly/d/prisma-schema\n\ngenerator client {\n  provider = \"prisma-client\"\n  output   = \"../src/generated/client\"\n}\n\ndatasource db {\n  provider = \"postgresql\"\n}\n\nenum ProjectRole {\n  OWNER\n  ADMIN\n  EDITOR\n  VIEWER\n}\n\nenum UserRole {\n  USER\n  ADMIN\n}\n\nenum SubscriptionProvider {\n  STRIPE\n  APPLE\n}\n\nmodel User {\n  id            String    @id @default(uuid(7))\n  createdAt     DateTime  @default(now())\n  email         String    @unique\n  emailVerified DateTime?\n  username      String?\n  color         String?\n  role          UserRole  @default(USER)\n\n  isProUntil              DateTime?\n  isSubscriptionCancelled Boolean               @default(false)\n  subscriptionProvider    SubscriptionProvider?\n\n  settings Json?\n\n  accounts     Account[]\n  sessions     Session[]\n  projects     ProjectMember[]\n  transactions Transaction[]\n}\n\nmodel Account {\n  id                String  @id @default(cuid())\n  userId            String\n  type              String\n  provider          String\n  providerAccountId String\n  refresh_token     String? @db.Text\n  access_token      String? @db.Text\n  expires_at        Int?\n  token_type        String?\n  scope             String?\n  id_token          String? @db.Text\n  session_state     String?\n\n  user User @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@unique([provider, providerAccountId])\n}\n\nmodel Session {\n  id           String   @id @default(cuid())\n  sessionToken String   @unique\n  userId       String\n  expires      DateTime\n  user         User     @relation(fields: [userId], references: [id], onDelete: Cascade)\n}\n\nmodel VerificationToken {\n  identifier String\n  token      String   @unique\n  expires    DateTime\n\n  @@unique([identifier, token])\n}\n\nmodel MagicLinkToken {\n  id        Int      @id @default(autoincrement())\n  email     String\n  tokenHash String   @unique\n  expiresAt DateTime\n  createdAt DateTime @default(now())\n\n  desktopNonce String?\n  inviteToken  String?\n\n  @@index([email, createdAt])\n}\n\nmodel Transaction {\n  id            Int                  @id @default(autoincrement())\n  userId        String\n  provider      SubscriptionProvider\n  transactionId String\n  createdAt     DateTime             @default(now())\n\n  user User @relation(fields: [userId], references: [id], onDelete: Cascade)\n\n  @@index([userId])\n  @@index([transactionId])\n}\n\nmodel Project {\n  id        String   @id @default(uuid(7))\n  createdAt DateTime @default(now())\n  updatedAt DateTime @updatedAt\n\n  title       String\n  description String?\n  author      String?\n  hasPoster   Boolean @default(false)\n\n  members     ProjectMember[]\n  invitations ProjectInvitation[]\n}\n\nmodel ProjectMember {\n  id   Int         @id @default(autoincrement())\n  role ProjectRole @default(VIEWER)\n\n  user      User    @relation(fields: [userId], references: [id])\n  userId    String\n  project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade)\n  projectId String\n\n  @@unique([userId, projectId])\n}\n\nmodel ProjectInvitation {\n  id        Int      @id @default(autoincrement())\n  token     String   @unique\n  email     String\n  createdAt DateTime @default(now())\n\n  project   Project @relation(fields: [projectId], references: [id], onDelete: Cascade)\n  projectId String\n\n  @@unique([email, projectId])\n}\n",
+  "runtimeDataModel": {
+    "models": {},
+    "enums": {},
+    "types": {}
+  },
+  "parameterizationSchema": {
+    "strings": [],
+    "graph": ""
+  }
+}
+
+config.runtimeDataModel = JSON.parse("{\"models\":{\"User\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"email\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"emailVerified\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"username\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"color\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"role\",\"kind\":\"enum\",\"type\":\"UserRole\"},{\"name\":\"isProUntil\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"isSubscriptionCancelled\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"subscriptionProvider\",\"kind\":\"enum\",\"type\":\"SubscriptionProvider\"},{\"name\":\"settings\",\"kind\":\"scalar\",\"type\":\"Json\"},{\"name\":\"accounts\",\"kind\":\"object\",\"type\":\"Account\",\"relationName\":\"AccountToUser\"},{\"name\":\"sessions\",\"kind\":\"object\",\"type\":\"Session\",\"relationName\":\"SessionToUser\"},{\"name\":\"projects\",\"kind\":\"object\",\"type\":\"ProjectMember\",\"relationName\":\"ProjectMemberToUser\"},{\"name\":\"transactions\",\"kind\":\"object\",\"type\":\"Transaction\",\"relationName\":\"TransactionToUser\"}],\"dbName\":null},\"Account\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"type\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"provider\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"providerAccountId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"refresh_token\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"access_token\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expires_at\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"token_type\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"scope\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"id_token\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"session_state\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"AccountToUser\"}],\"dbName\":null},\"Session\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"sessionToken\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expires\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"SessionToUser\"}],\"dbName\":null},\"VerificationToken\":{\"fields\":[{\"name\":\"identifier\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"token\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expires\",\"kind\":\"scalar\",\"type\":\"DateTime\"}],\"dbName\":null},\"MagicLinkToken\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"email\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"tokenHash\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"expiresAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"desktopNonce\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"inviteToken\",\"kind\":\"scalar\",\"type\":\"String\"}],\"dbName\":null},\"Transaction\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"provider\",\"kind\":\"enum\",\"type\":\"SubscriptionProvider\"},{\"name\":\"transactionId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"TransactionToUser\"}],\"dbName\":null},\"Project\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"title\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"description\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"author\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"hasPoster\",\"kind\":\"scalar\",\"type\":\"Boolean\"},{\"name\":\"members\",\"kind\":\"object\",\"type\":\"ProjectMember\",\"relationName\":\"ProjectToProjectMember\"},{\"name\":\"invitations\",\"kind\":\"object\",\"type\":\"ProjectInvitation\",\"relationName\":\"ProjectToProjectInvitation\"}],\"dbName\":null},\"ProjectMember\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"role\",\"kind\":\"enum\",\"type\":\"ProjectRole\"},{\"name\":\"user\",\"kind\":\"object\",\"type\":\"User\",\"relationName\":\"ProjectMemberToUser\"},{\"name\":\"userId\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"project\",\"kind\":\"object\",\"type\":\"Project\",\"relationName\":\"ProjectToProjectMember\"},{\"name\":\"projectId\",\"kind\":\"scalar\",\"type\":\"String\"}],\"dbName\":null},\"ProjectInvitation\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"token\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"email\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"project\",\"kind\":\"object\",\"type\":\"Project\",\"relationName\":\"ProjectToProjectInvitation\"},{\"name\":\"projectId\",\"kind\":\"scalar\",\"type\":\"String\"}],\"dbName\":null}},\"enums\":{},\"types\":{}}")
+config.parameterizationSchema = {
+  strings: JSON.parse("[\"where\",\"orderBy\",\"cursor\",\"user\",\"accounts\",\"sessions\",\"members\",\"project\",\"invitations\",\"_count\",\"projects\",\"transactions\",\"User.findUnique\",\"User.findUniqueOrThrow\",\"User.findFirst\",\"User.findFirstOrThrow\",\"User.findMany\",\"data\",\"User.createOne\",\"User.createMany\",\"User.createManyAndReturn\",\"User.updateOne\",\"User.updateMany\",\"User.updateManyAndReturn\",\"create\",\"update\",\"User.upsertOne\",\"User.deleteOne\",\"User.deleteMany\",\"having\",\"_min\",\"_max\",\"User.groupBy\",\"User.aggregate\",\"Account.findUnique\",\"Account.findUniqueOrThrow\",\"Account.findFirst\",\"Account.findFirstOrThrow\",\"Account.findMany\",\"Account.createOne\",\"Account.createMany\",\"Account.createManyAndReturn\",\"Account.updateOne\",\"Account.updateMany\",\"Account.updateManyAndReturn\",\"Account.upsertOne\",\"Account.deleteOne\",\"Account.deleteMany\",\"_avg\",\"_sum\",\"Account.groupBy\",\"Account.aggregate\",\"Session.findUnique\",\"Session.findUniqueOrThrow\",\"Session.findFirst\",\"Session.findFirstOrThrow\",\"Session.findMany\",\"Session.createOne\",\"Session.createMany\",\"Session.createManyAndReturn\",\"Session.updateOne\",\"Session.updateMany\",\"Session.updateManyAndReturn\",\"Session.upsertOne\",\"Session.deleteOne\",\"Session.deleteMany\",\"Session.groupBy\",\"Session.aggregate\",\"VerificationToken.findUnique\",\"VerificationToken.findUniqueOrThrow\",\"VerificationToken.findFirst\",\"VerificationToken.findFirstOrThrow\",\"VerificationToken.findMany\",\"VerificationToken.createOne\",\"VerificationToken.createMany\",\"VerificationToken.createManyAndReturn\",\"VerificationToken.updateOne\",\"VerificationToken.updateMany\",\"VerificationToken.updateManyAndReturn\",\"VerificationToken.upsertOne\",\"VerificationToken.deleteOne\",\"VerificationToken.deleteMany\",\"VerificationToken.groupBy\",\"VerificationToken.aggregate\",\"MagicLinkToken.findUnique\",\"MagicLinkToken.findUniqueOrThrow\",\"MagicLinkToken.findFirst\",\"MagicLinkToken.findFirstOrThrow\",\"MagicLinkToken.findMany\",\"MagicLinkToken.createOne\",\"MagicLinkToken.createMany\",\"MagicLinkToken.createManyAndReturn\",\"MagicLinkToken.updateOne\",\"MagicLinkToken.updateMany\",\"MagicLinkToken.updateManyAndReturn\",\"MagicLinkToken.upsertOne\",\"MagicLinkToken.deleteOne\",\"MagicLinkToken.deleteMany\",\"MagicLinkToken.groupBy\",\"MagicLinkToken.aggregate\",\"Transaction.findUnique\",\"Transaction.findUniqueOrThrow\",\"Transaction.findFirst\",\"Transaction.findFirstOrThrow\",\"Transaction.findMany\",\"Transaction.createOne\",\"Transaction.createMany\",\"Transaction.createManyAndReturn\",\"Transaction.updateOne\",\"Transaction.updateMany\",\"Transaction.updateManyAndReturn\",\"Transaction.upsertOne\",\"Transaction.deleteOne\",\"Transaction.deleteMany\",\"Transaction.groupBy\",\"Transaction.aggregate\",\"Project.findUnique\",\"Project.findUniqueOrThrow\",\"Project.findFirst\",\"Project.findFirstOrThrow\",\"Project.findMany\",\"Project.createOne\",\"Project.createMany\",\"Project.createManyAndReturn\",\"Project.updateOne\",\"Project.updateMany\",\"Project.updateManyAndReturn\",\"Project.upsertOne\",\"Project.deleteOne\",\"Project.deleteMany\",\"Project.groupBy\",\"Project.aggregate\",\"ProjectMember.findUnique\",\"ProjectMember.findUniqueOrThrow\",\"ProjectMember.findFirst\",\"ProjectMember.findFirstOrThrow\",\"ProjectMember.findMany\",\"ProjectMember.createOne\",\"ProjectMember.createMany\",\"ProjectMember.createManyAndReturn\",\"ProjectMember.updateOne\",\"ProjectMember.updateMany\",\"ProjectMember.updateManyAndReturn\",\"ProjectMember.upsertOne\",\"ProjectMember.deleteOne\",\"ProjectMember.deleteMany\",\"ProjectMember.groupBy\",\"ProjectMember.aggregate\",\"ProjectInvitation.findUnique\",\"ProjectInvitation.findUniqueOrThrow\",\"ProjectInvitation.findFirst\",\"ProjectInvitation.findFirstOrThrow\",\"ProjectInvitation.findMany\",\"ProjectInvitation.createOne\",\"ProjectInvitation.createMany\",\"ProjectInvitation.createManyAndReturn\",\"ProjectInvitation.updateOne\",\"ProjectInvitation.updateMany\",\"ProjectInvitation.updateManyAndReturn\",\"ProjectInvitation.upsertOne\",\"ProjectInvitation.deleteOne\",\"ProjectInvitation.deleteMany\",\"ProjectInvitation.groupBy\",\"ProjectInvitation.aggregate\",\"AND\",\"OR\",\"NOT\",\"id\",\"token\",\"email\",\"createdAt\",\"projectId\",\"equals\",\"in\",\"notIn\",\"lt\",\"lte\",\"gt\",\"gte\",\"not\",\"contains\",\"startsWith\",\"endsWith\",\"ProjectRole\",\"role\",\"userId\",\"updatedAt\",\"title\",\"description\",\"author\",\"hasPoster\",\"every\",\"some\",\"none\",\"SubscriptionProvider\",\"provider\",\"transactionId\",\"tokenHash\",\"expiresAt\",\"desktopNonce\",\"inviteToken\",\"identifier\",\"expires\",\"identifier_token\",\"sessionToken\",\"type\",\"providerAccountId\",\"refresh_token\",\"access_token\",\"expires_at\",\"token_type\",\"scope\",\"id_token\",\"session_state\",\"emailVerified\",\"username\",\"color\",\"UserRole\",\"isProUntil\",\"isSubscriptionCancelled\",\"subscriptionProvider\",\"settings\",\"string_contains\",\"string_starts_with\",\"string_ends_with\",\"array_starts_with\",\"array_ends_with\",\"array_contains\",\"email_projectId\",\"userId_projectId\",\"provider_providerAccountId\",\"is\",\"isNot\",\"connectOrCreate\",\"upsert\",\"createMany\",\"set\",\"disconnect\",\"delete\",\"connect\",\"updateMany\",\"deleteMany\",\"increment\",\"decrement\",\"multiply\",\"divide\"]"),
+  graph: "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"
+}
+
+async function decodeBase64AsWasm(wasmBase64: string): Promise<WebAssembly.Module> {
+  const { Buffer } = await import('node:buffer')
+  const wasmArray = Buffer.from(wasmBase64, 'base64')
+  return new WebAssembly.Module(wasmArray)
+}
+
+config.compilerWasm = {
+  getRuntime: async () => await import("@prisma/client/runtime/query_compiler_fast_bg.postgresql.mjs"),
+
+  getQueryCompilerWasmModule: async () => {
+    const { wasm } = await import("@prisma/client/runtime/query_compiler_fast_bg.postgresql.wasm-base64.mjs")
+    return await decodeBase64AsWasm(wasm)
+  },
+
+  importName: "./query_compiler_fast_bg.js"
+}
+
+
+
+export type LogOptions<ClientOptions extends Prisma.PrismaClientOptions> =
+  'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never
+
+export interface PrismaClientConstructor {
+    /**
+   * ## Prisma Client
+   * 
+   * Type-safe database client for TypeScript
+   * @example
+   * ```
+   * const prisma = new PrismaClient({
+   *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+   * })
+   * // Fetch zero or more Users
+   * const users = await prisma.user.findMany()
+   * ```
+   * 
+   * Read more in our [docs](https://pris.ly/d/client).
+   */
+
+  new <
+    Options extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
+    LogOpts extends LogOptions<Options> = LogOptions<Options>,
+    OmitOpts extends Prisma.PrismaClientOptions['omit'] = Options extends { omit: infer U } ? U : Prisma.PrismaClientOptions['omit'],
+    ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs
+  >(options: Prisma.Subset<Options, Prisma.PrismaClientOptions> ): PrismaClient<LogOpts, OmitOpts, ExtArgs>
+}
+
+/**
+ * ## Prisma Client
+ * 
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more Users
+ * const users = await prisma.user.findMany()
+ * ```
+ * 
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+
+export interface PrismaClient<
+  in LogOpts extends Prisma.LogLevel = never,
+  in out OmitOpts extends Prisma.PrismaClientOptions['omit'] = undefined,
+  in out ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs
+> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }
+
+  $on<V extends LogOpts>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient;
+
+  /**
+   * Connect with the database
+   */
+  $connect(): runtime.Types.Utils.JsPromise<void>;
+
+  /**
+   * Disconnect from the database
+   */
+  $disconnect(): runtime.Types.Utils.JsPromise<void>;
+
+/**
+   * Executes a prepared raw query and returns the number of affected rows.
+   * @example
+   * ```
+   * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
+   * ```
+   *
+   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   */
+  $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
+
+  /**
+   * Executes a raw query and returns the number of affected rows.
+   * Susceptible to SQL injections, see documentation.
+   * @example
+   * ```
+   * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
+   * ```
+   *
+   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   */
+  $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;
+
+  /**
+   * Performs a prepared raw query and returns the `SELECT` data.
+   * @example
+   * ```
+   * const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
+   * ```
+   *
+   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   */
+  $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
+
+  /**
+   * Performs a raw query and returns the `SELECT` data.
+   * Susceptible to SQL injections, see documentation.
+   * @example
+   * ```
+   * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
+   * ```
+   *
+   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   */
+  $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;
+
+
+  /**
+   * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
+   * @example
+   * ```
+   * const [george, bob, alice] = await prisma.$transaction([
+   *   prisma.user.create({ data: { name: 'George' } }),
+   *   prisma.user.create({ data: { name: 'Bob' } }),
+   *   prisma.user.create({ data: { name: 'Alice' } }),
+   * ])
+   * ```
+   * 
+   * Read more in our [docs](https://www.prisma.io/docs/orm/prisma-client/queries/transactions).
+   */
+  $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): runtime.Types.Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>
+
+  $transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => runtime.Types.Utils.JsPromise<R>, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): runtime.Types.Utils.JsPromise<R>
+
+  $extends: runtime.Types.Extensions.ExtendsHook<"extends", Prisma.TypeMapCb<OmitOpts>, ExtArgs, runtime.Types.Utils.Call<Prisma.TypeMapCb<OmitOpts>, {
+    extArgs: ExtArgs
+  }>>
+
+      /**
+   * `prisma.user`: Exposes CRUD operations for the **User** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Users
+    * const users = await prisma.user.findMany()
+    * ```
+    */
+  get user(): Prisma.UserDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.account`: Exposes CRUD operations for the **Account** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Accounts
+    * const accounts = await prisma.account.findMany()
+    * ```
+    */
+  get account(): Prisma.AccountDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.session`: Exposes CRUD operations for the **Session** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Sessions
+    * const sessions = await prisma.session.findMany()
+    * ```
+    */
+  get session(): Prisma.SessionDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.verificationToken`: Exposes CRUD operations for the **VerificationToken** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more VerificationTokens
+    * const verificationTokens = await prisma.verificationToken.findMany()
+    * ```
+    */
+  get verificationToken(): Prisma.VerificationTokenDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.magicLinkToken`: Exposes CRUD operations for the **MagicLinkToken** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more MagicLinkTokens
+    * const magicLinkTokens = await prisma.magicLinkToken.findMany()
+    * ```
+    */
+  get magicLinkToken(): Prisma.MagicLinkTokenDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.transaction`: Exposes CRUD operations for the **Transaction** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Transactions
+    * const transactions = await prisma.transaction.findMany()
+    * ```
+    */
+  get transaction(): Prisma.TransactionDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.project`: Exposes CRUD operations for the **Project** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more Projects
+    * const projects = await prisma.project.findMany()
+    * ```
+    */
+  get project(): Prisma.ProjectDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.projectMember`: Exposes CRUD operations for the **ProjectMember** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more ProjectMembers
+    * const projectMembers = await prisma.projectMember.findMany()
+    * ```
+    */
+  get projectMember(): Prisma.ProjectMemberDelegate<ExtArgs, { omit: OmitOpts }>;
+
+  /**
+   * `prisma.projectInvitation`: Exposes CRUD operations for the **ProjectInvitation** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more ProjectInvitations
+    * const projectInvitations = await prisma.projectInvitation.findMany()
+    * ```
+    */
+  get projectInvitation(): Prisma.ProjectInvitationDelegate<ExtArgs, { omit: OmitOpts }>;
+}
+
+export function getPrismaClientClass(): PrismaClientConstructor {
+  return runtime.getPrismaClient(config) as unknown as PrismaClientConstructor
+}
diff --git a/src/generated/client/internal/prismaNamespace.ts b/src/generated/client/internal/prismaNamespace.ts
new file mode 100644
index 00000000..9e34c497
--- /dev/null
+++ b/src/generated/client/internal/prismaNamespace.ts
@@ -0,0 +1,1563 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * WARNING: This is an internal file that is subject to change!
+ *
+ * 🛑 Under no circumstances should you import this file directly! 🛑
+ *
+ * All exports from this file are wrapped under a `Prisma` namespace object in the client.ts file.
+ * While this enables partial backward compatibility, it is not part of the stable public API.
+ *
+ * If you are looking for your Models, Enums, and Input Types, please import them from the respective
+ * model files in the `model` directory!
+ */
+
+import * as runtime from "@prisma/client/runtime/client"
+import type * as Prisma from "../models"
+import { type PrismaClient } from "./class"
+
+export type * from '../models'
+
+export type DMMF = typeof runtime.DMMF
+
+export type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T>
+
+/**
+ * Prisma Errors
+ */
+
+export const PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
+export type PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
+
+export const PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
+export type PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
+
+export const PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
+export type PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
+
+export const PrismaClientInitializationError = runtime.PrismaClientInitializationError
+export type PrismaClientInitializationError = runtime.PrismaClientInitializationError
+
+export const PrismaClientValidationError = runtime.PrismaClientValidationError
+export type PrismaClientValidationError = runtime.PrismaClientValidationError
+
+/**
+ * Re-export of sql-template-tag
+ */
+export const sql = runtime.sqltag
+export const empty = runtime.empty
+export const join = runtime.join
+export const raw = runtime.raw
+export const Sql = runtime.Sql
+export type Sql = runtime.Sql
+
+
+
+/**
+ * Decimal.js
+ */
+export const Decimal = runtime.Decimal
+export type Decimal = runtime.Decimal
+
+export type DecimalJsLike = runtime.DecimalJsLike
+
+/**
+* Extensions
+*/
+export type Extension = runtime.Types.Extensions.UserArgs
+export const getExtensionContext = runtime.Extensions.getExtensionContext
+export type Args<T, F extends runtime.Operation> = runtime.Types.Public.Args<T, F>
+export type Payload<T, F extends runtime.Operation = never> = runtime.Types.Public.Payload<T, F>
+export type Result<T, A, F extends runtime.Operation> = runtime.Types.Public.Result<T, A, F>
+export type Exact<A, W> = runtime.Types.Public.Exact<A, W>
+
+export type PrismaVersion = {
+  client: string
+  engine: string
+}
+
+/**
+ * Prisma Client JS version: 7.7.0
+ * Query Engine version: 75cbdc1eb7150937890ad5465d861175c6624711
+ */
+export const prismaVersion: PrismaVersion = {
+  client: "7.7.0",
+  engine: "75cbdc1eb7150937890ad5465d861175c6624711"
+}
+
+/**
+ * Utility Types
+ */
+
+export type Bytes = runtime.Bytes
+export type JsonObject = runtime.JsonObject
+export type JsonArray = runtime.JsonArray
+export type JsonValue = runtime.JsonValue
+export type InputJsonObject = runtime.InputJsonObject
+export type InputJsonArray = runtime.InputJsonArray
+export type InputJsonValue = runtime.InputJsonValue
+
+
+export const NullTypes = {
+  DbNull: runtime.NullTypes.DbNull as (new (secret: never) => typeof runtime.DbNull),
+  JsonNull: runtime.NullTypes.JsonNull as (new (secret: never) => typeof runtime.JsonNull),
+  AnyNull: runtime.NullTypes.AnyNull as (new (secret: never) => typeof runtime.AnyNull),
+}
+/**
+ * Helper for filtering JSON entries that have `null` on the database (empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const DbNull = runtime.DbNull
+
+/**
+ * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const JsonNull = runtime.JsonNull
+
+/**
+ * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const AnyNull = runtime.AnyNull
+
+
+type SelectAndInclude = {
+  select: any
+  include: any
+}
+
+type SelectAndOmit = {
+  select: any
+  omit: any
+}
+
+/**
+ * From T, pick a set of properties whose keys are in the union K
+ */
+type Prisma__Pick<T, K extends keyof T> = {
+    [P in K]: T[P];
+};
+
+export type Enumerable<T> = T | Array<T>;
+
+/**
+ * Subset
+ * @desc From `T` pick properties that exist in `U`. Simple version of Intersection
+ */
+export type Subset<T, U> = {
+  [key in keyof T]: key extends keyof U ? T[key] : never;
+};
+
+/**
+ * SelectSubset
+ * @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
+ * Additionally, it validates, if both select and include are present. If the case, it errors.
+ */
+export type SelectSubset<T, U> = {
+  [key in keyof T]: key extends keyof U ? T[key] : never
+} &
+  (T extends SelectAndInclude
+    ? 'Please either choose `select` or `include`.'
+    : T extends SelectAndOmit
+      ? 'Please either choose `select` or `omit`.'
+      : {})
+
+/**
+ * Subset + Intersection
+ * @desc From `T` pick properties that exist in `U` and intersect `K`
+ */
+export type SubsetIntersection<T, U, K> = {
+  [key in keyof T]: key extends keyof U ? T[key] : never
+} &
+  K
+
+type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
+
+/**
+ * XOR is needed to have a real mutually exclusive union type
+ * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
+ */
+export type XOR<T, U> =
+  T extends object ?
+  U extends object ?
+    (Without<T, U> & U) | (Without<U, T> & T)
+  : U : T
+
+
+/**
+ * Is T a Record?
+ */
+type IsObject<T extends any> = T extends Array<any>
+? False
+: T extends Date
+? False
+: T extends Uint8Array
+? False
+: T extends BigInt
+? False
+: T extends object
+? True
+: False
+
+
+/**
+ * If it's T[], return T
+ */
+export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T
+
+/**
+ * From ts-toolbelt
+ */
+
+type __Either<O extends object, K extends Key> = Omit<O, K> &
+  {
+    // Merge all but K
+    [P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities
+  }[K]
+
+type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>
+
+type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>
+
+type _Either<
+  O extends object,
+  K extends Key,
+  strict extends Boolean
+> = {
+  1: EitherStrict<O, K>
+  0: EitherLoose<O, K>
+}[strict]
+
+export type Either<
+  O extends object,
+  K extends Key,
+  strict extends Boolean = 1
+> = O extends unknown ? _Either<O, K, strict> : never
+
+export type Union = any
+
+export type PatchUndefined<O extends object, O1 extends object> = {
+  [K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K]
+} & {}
+
+/** Helper Types for "Merge" **/
+export type IntersectOf<U extends Union> = (
+  U extends unknown ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never
+
+export type Overwrite<O extends object, O1 extends object> = {
+    [K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
+} & {};
+
+type _Merge<U extends object> = IntersectOf<Overwrite<U, {
+    [K in keyof U]-?: At<U, K>;
+}>>;
+
+type Key = string | number | symbol;
+type AtStrict<O extends object, K extends Key> = O[K & keyof O];
+type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
+export type At<O extends object, K extends Key, strict extends Boolean = 1> = {
+    1: AtStrict<O, K>;
+    0: AtLoose<O, K>;
+}[strict];
+
+export type ComputeRaw<A extends any> = A extends Function ? A : {
+  [K in keyof A]: A[K];
+} & {};
+
+export type OptionalFlat<O> = {
+  [K in keyof O]?: O[K];
+} & {};
+
+type _Record<K extends keyof any, T> = {
+  [P in K]: T;
+};
+
+// cause typescript not to expand types and preserve names
+type NoExpand<T> = T extends unknown ? T : never;
+
+// this type assumes the passed object is entirely optional
+export type AtLeast<O extends object, K extends string> = NoExpand<
+  O extends unknown
+  ? | (K extends keyof O ? { [P in K]: O[P] } & O : O)
+    | {[P in keyof O as P extends K ? P : never]-?: O[P]} & O
+  : never>;
+
+type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;
+
+export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
+/** End Helper Types for "Merge" **/
+
+export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
+
+export type Boolean = True | False
+
+export type True = 1
+
+export type False = 0
+
+export type Not<B extends Boolean> = {
+  0: 1
+  1: 0
+}[B]
+
+export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
+  ? 0 // anything `never` is false
+  : A1 extends A2
+  ? 1
+  : 0
+
+export type Has<U extends Union, U1 extends Union> = Not<
+  Extends<Exclude<U1, U>, U1>
+>
+
+export type Or<B1 extends Boolean, B2 extends Boolean> = {
+  0: {
+    0: 0
+    1: 1
+  }
+  1: {
+    0: 1
+    1: 1
+  }
+}[B1][B2]
+
+export type Keys<U extends Union> = U extends unknown ? keyof U : never
+
+export type GetScalarType<T, O> = O extends object ? {
+  [P in keyof T]: P extends keyof O
+    ? O[P]
+    : never
+} : never
+
+type FieldPaths<
+  T,
+  U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>
+> = IsObject<T> extends True ? U : T
+
+export type GetHavingFields<T> = {
+  [K in keyof T]: Or<
+    Or<Extends<'OR', K>, Extends<'AND', K>>,
+    Extends<'NOT', K>
+  > extends True
+    ? // infer is only needed to not hit TS limit
+      // based on the brilliant idea of Pierre-Antoine Mills
+      // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
+      T[K] extends infer TK
+      ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never>
+      : never
+    : {} extends FieldPaths<T[K]>
+    ? never
+    : K
+}[keyof T]
+
+/**
+ * Convert tuple to union
+ */
+type _TupleToUnion<T> = T extends (infer E)[] ? E : never
+type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
+export type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T
+
+/**
+ * Like `Pick`, but additionally can also accept an array of keys
+ */
+export type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>
+
+/**
+ * Exclude all keys with underscores
+ */
+export type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T
+
+
+export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>
+
+type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>
+
+
+export const ModelName = {
+  User: 'User',
+  Account: 'Account',
+  Session: 'Session',
+  VerificationToken: 'VerificationToken',
+  MagicLinkToken: 'MagicLinkToken',
+  Transaction: 'Transaction',
+  Project: 'Project',
+  ProjectMember: 'ProjectMember',
+  ProjectInvitation: 'ProjectInvitation'
+} as const
+
+export type ModelName = (typeof ModelName)[keyof typeof ModelName]
+
+
+
+export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.Fn<{extArgs: runtime.Types.Extensions.InternalArgs }, runtime.Types.Utils.Record<string, any>> {
+  returns: TypeMap<this['params']['extArgs'], GlobalOmitOptions>
+}
+
+export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
+  globalOmitOptions: {
+    omit: GlobalOmitOptions
+  }
+  meta: {
+    modelProps: "user" | "account" | "session" | "verificationToken" | "magicLinkToken" | "transaction" | "project" | "projectMember" | "projectInvitation"
+    txIsolationLevel: TransactionIsolationLevel
+  }
+  model: {
+    User: {
+      payload: Prisma.$UserPayload<ExtArgs>
+      fields: Prisma.UserFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.UserFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        findFirst: {
+          args: Prisma.UserFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        findMany: {
+          args: Prisma.UserFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[]
+        }
+        create: {
+          args: Prisma.UserCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        createMany: {
+          args: Prisma.UserCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[]
+        }
+        delete: {
+          args: Prisma.UserDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        update: {
+          args: Prisma.UserUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        deleteMany: {
+          args: Prisma.UserDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.UserUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[]
+        }
+        upsert: {
+          args: Prisma.UserUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>
+        }
+        aggregate: {
+          args: Prisma.UserAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateUser>
+        }
+        groupBy: {
+          args: Prisma.UserGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.UserGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.UserCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.UserCountAggregateOutputType> | number
+        }
+      }
+    }
+    Account: {
+      payload: Prisma.$AccountPayload<ExtArgs>
+      fields: Prisma.AccountFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.AccountFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.AccountFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload>
+        }
+        findFirst: {
+          args: Prisma.AccountFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.AccountFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload>
+        }
+        findMany: {
+          args: Prisma.AccountFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload>[]
+        }
+        create: {
+          args: Prisma.AccountCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload>
+        }
+        createMany: {
+          args: Prisma.AccountCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.AccountCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload>[]
+        }
+        delete: {
+          args: Prisma.AccountDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload>
+        }
+        update: {
+          args: Prisma.AccountUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload>
+        }
+        deleteMany: {
+          args: Prisma.AccountDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.AccountUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.AccountUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload>[]
+        }
+        upsert: {
+          args: Prisma.AccountUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$AccountPayload>
+        }
+        aggregate: {
+          args: Prisma.AccountAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateAccount>
+        }
+        groupBy: {
+          args: Prisma.AccountGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AccountGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.AccountCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AccountCountAggregateOutputType> | number
+        }
+      }
+    }
+    Session: {
+      payload: Prisma.$SessionPayload<ExtArgs>
+      fields: Prisma.SessionFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.SessionFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>
+        }
+        findFirst: {
+          args: Prisma.SessionFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>
+        }
+        findMany: {
+          args: Prisma.SessionFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[]
+        }
+        create: {
+          args: Prisma.SessionCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>
+        }
+        createMany: {
+          args: Prisma.SessionCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.SessionCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[]
+        }
+        delete: {
+          args: Prisma.SessionDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>
+        }
+        update: {
+          args: Prisma.SessionUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>
+        }
+        deleteMany: {
+          args: Prisma.SessionDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.SessionUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.SessionUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[]
+        }
+        upsert: {
+          args: Prisma.SessionUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>
+        }
+        aggregate: {
+          args: Prisma.SessionAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateSession>
+        }
+        groupBy: {
+          args: Prisma.SessionGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.SessionGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.SessionCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.SessionCountAggregateOutputType> | number
+        }
+      }
+    }
+    VerificationToken: {
+      payload: Prisma.$VerificationTokenPayload<ExtArgs>
+      fields: Prisma.VerificationTokenFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.VerificationTokenFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.VerificationTokenFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
+        }
+        findFirst: {
+          args: Prisma.VerificationTokenFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.VerificationTokenFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
+        }
+        findMany: {
+          args: Prisma.VerificationTokenFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[]
+        }
+        create: {
+          args: Prisma.VerificationTokenCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
+        }
+        createMany: {
+          args: Prisma.VerificationTokenCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.VerificationTokenCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[]
+        }
+        delete: {
+          args: Prisma.VerificationTokenDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
+        }
+        update: {
+          args: Prisma.VerificationTokenUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
+        }
+        deleteMany: {
+          args: Prisma.VerificationTokenDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.VerificationTokenUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.VerificationTokenUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>[]
+        }
+        upsert: {
+          args: Prisma.VerificationTokenUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$VerificationTokenPayload>
+        }
+        aggregate: {
+          args: Prisma.VerificationTokenAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateVerificationToken>
+        }
+        groupBy: {
+          args: Prisma.VerificationTokenGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.VerificationTokenGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.VerificationTokenCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.VerificationTokenCountAggregateOutputType> | number
+        }
+      }
+    }
+    MagicLinkToken: {
+      payload: Prisma.$MagicLinkTokenPayload<ExtArgs>
+      fields: Prisma.MagicLinkTokenFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.MagicLinkTokenFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.MagicLinkTokenFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload>
+        }
+        findFirst: {
+          args: Prisma.MagicLinkTokenFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.MagicLinkTokenFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload>
+        }
+        findMany: {
+          args: Prisma.MagicLinkTokenFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload>[]
+        }
+        create: {
+          args: Prisma.MagicLinkTokenCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload>
+        }
+        createMany: {
+          args: Prisma.MagicLinkTokenCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.MagicLinkTokenCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload>[]
+        }
+        delete: {
+          args: Prisma.MagicLinkTokenDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload>
+        }
+        update: {
+          args: Prisma.MagicLinkTokenUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload>
+        }
+        deleteMany: {
+          args: Prisma.MagicLinkTokenDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.MagicLinkTokenUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.MagicLinkTokenUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload>[]
+        }
+        upsert: {
+          args: Prisma.MagicLinkTokenUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$MagicLinkTokenPayload>
+        }
+        aggregate: {
+          args: Prisma.MagicLinkTokenAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateMagicLinkToken>
+        }
+        groupBy: {
+          args: Prisma.MagicLinkTokenGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.MagicLinkTokenGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.MagicLinkTokenCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.MagicLinkTokenCountAggregateOutputType> | number
+        }
+      }
+    }
+    Transaction: {
+      payload: Prisma.$TransactionPayload<ExtArgs>
+      fields: Prisma.TransactionFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.TransactionFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.TransactionFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload>
+        }
+        findFirst: {
+          args: Prisma.TransactionFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.TransactionFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload>
+        }
+        findMany: {
+          args: Prisma.TransactionFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload>[]
+        }
+        create: {
+          args: Prisma.TransactionCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload>
+        }
+        createMany: {
+          args: Prisma.TransactionCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.TransactionCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload>[]
+        }
+        delete: {
+          args: Prisma.TransactionDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload>
+        }
+        update: {
+          args: Prisma.TransactionUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload>
+        }
+        deleteMany: {
+          args: Prisma.TransactionDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.TransactionUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.TransactionUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload>[]
+        }
+        upsert: {
+          args: Prisma.TransactionUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$TransactionPayload>
+        }
+        aggregate: {
+          args: Prisma.TransactionAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateTransaction>
+        }
+        groupBy: {
+          args: Prisma.TransactionGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.TransactionGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.TransactionCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.TransactionCountAggregateOutputType> | number
+        }
+      }
+    }
+    Project: {
+      payload: Prisma.$ProjectPayload<ExtArgs>
+      fields: Prisma.ProjectFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.ProjectFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.ProjectFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload>
+        }
+        findFirst: {
+          args: Prisma.ProjectFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.ProjectFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload>
+        }
+        findMany: {
+          args: Prisma.ProjectFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload>[]
+        }
+        create: {
+          args: Prisma.ProjectCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload>
+        }
+        createMany: {
+          args: Prisma.ProjectCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.ProjectCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload>[]
+        }
+        delete: {
+          args: Prisma.ProjectDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload>
+        }
+        update: {
+          args: Prisma.ProjectUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload>
+        }
+        deleteMany: {
+          args: Prisma.ProjectDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.ProjectUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.ProjectUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload>[]
+        }
+        upsert: {
+          args: Prisma.ProjectUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectPayload>
+        }
+        aggregate: {
+          args: Prisma.ProjectAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateProject>
+        }
+        groupBy: {
+          args: Prisma.ProjectGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.ProjectGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.ProjectCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.ProjectCountAggregateOutputType> | number
+        }
+      }
+    }
+    ProjectMember: {
+      payload: Prisma.$ProjectMemberPayload<ExtArgs>
+      fields: Prisma.ProjectMemberFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.ProjectMemberFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.ProjectMemberFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload>
+        }
+        findFirst: {
+          args: Prisma.ProjectMemberFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.ProjectMemberFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload>
+        }
+        findMany: {
+          args: Prisma.ProjectMemberFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload>[]
+        }
+        create: {
+          args: Prisma.ProjectMemberCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload>
+        }
+        createMany: {
+          args: Prisma.ProjectMemberCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.ProjectMemberCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload>[]
+        }
+        delete: {
+          args: Prisma.ProjectMemberDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload>
+        }
+        update: {
+          args: Prisma.ProjectMemberUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload>
+        }
+        deleteMany: {
+          args: Prisma.ProjectMemberDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.ProjectMemberUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.ProjectMemberUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload>[]
+        }
+        upsert: {
+          args: Prisma.ProjectMemberUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectMemberPayload>
+        }
+        aggregate: {
+          args: Prisma.ProjectMemberAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateProjectMember>
+        }
+        groupBy: {
+          args: Prisma.ProjectMemberGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.ProjectMemberGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.ProjectMemberCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.ProjectMemberCountAggregateOutputType> | number
+        }
+      }
+    }
+    ProjectInvitation: {
+      payload: Prisma.$ProjectInvitationPayload<ExtArgs>
+      fields: Prisma.ProjectInvitationFieldRefs
+      operations: {
+        findUnique: {
+          args: Prisma.ProjectInvitationFindUniqueArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload> | null
+        }
+        findUniqueOrThrow: {
+          args: Prisma.ProjectInvitationFindUniqueOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload>
+        }
+        findFirst: {
+          args: Prisma.ProjectInvitationFindFirstArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload> | null
+        }
+        findFirstOrThrow: {
+          args: Prisma.ProjectInvitationFindFirstOrThrowArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload>
+        }
+        findMany: {
+          args: Prisma.ProjectInvitationFindManyArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload>[]
+        }
+        create: {
+          args: Prisma.ProjectInvitationCreateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload>
+        }
+        createMany: {
+          args: Prisma.ProjectInvitationCreateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        createManyAndReturn: {
+          args: Prisma.ProjectInvitationCreateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload>[]
+        }
+        delete: {
+          args: Prisma.ProjectInvitationDeleteArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload>
+        }
+        update: {
+          args: Prisma.ProjectInvitationUpdateArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload>
+        }
+        deleteMany: {
+          args: Prisma.ProjectInvitationDeleteManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateMany: {
+          args: Prisma.ProjectInvitationUpdateManyArgs<ExtArgs>
+          result: BatchPayload
+        }
+        updateManyAndReturn: {
+          args: Prisma.ProjectInvitationUpdateManyAndReturnArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload>[]
+        }
+        upsert: {
+          args: Prisma.ProjectInvitationUpsertArgs<ExtArgs>
+          result: runtime.Types.Utils.PayloadToResult<Prisma.$ProjectInvitationPayload>
+        }
+        aggregate: {
+          args: Prisma.ProjectInvitationAggregateArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.AggregateProjectInvitation>
+        }
+        groupBy: {
+          args: Prisma.ProjectInvitationGroupByArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.ProjectInvitationGroupByOutputType>[]
+        }
+        count: {
+          args: Prisma.ProjectInvitationCountArgs<ExtArgs>
+          result: runtime.Types.Utils.Optional<Prisma.ProjectInvitationCountAggregateOutputType> | number
+        }
+      }
+    }
+  }
+} & {
+  other: {
+    payload: any
+    operations: {
+      $executeRaw: {
+        args: [query: TemplateStringsArray | Sql, ...values: any[]],
+        result: any
+      }
+      $executeRawUnsafe: {
+        args: [query: string, ...values: any[]],
+        result: any
+      }
+      $queryRaw: {
+        args: [query: TemplateStringsArray | Sql, ...values: any[]],
+        result: any
+      }
+      $queryRawUnsafe: {
+        args: [query: string, ...values: any[]],
+        result: any
+      }
+    }
+  }
+}
+
+/**
+ * Enums
+ */
+
+export const TransactionIsolationLevel = runtime.makeStrictEnum({
+  ReadUncommitted: 'ReadUncommitted',
+  ReadCommitted: 'ReadCommitted',
+  RepeatableRead: 'RepeatableRead',
+  Serializable: 'Serializable'
+} as const)
+
+export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
+
+
+export const UserScalarFieldEnum = {
+  id: 'id',
+  createdAt: 'createdAt',
+  email: 'email',
+  emailVerified: 'emailVerified',
+  username: 'username',
+  color: 'color',
+  role: 'role',
+  isProUntil: 'isProUntil',
+  isSubscriptionCancelled: 'isSubscriptionCancelled',
+  subscriptionProvider: 'subscriptionProvider',
+  settings: 'settings'
+} as const
+
+export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]
+
+
+export const AccountScalarFieldEnum = {
+  id: 'id',
+  userId: 'userId',
+  type: 'type',
+  provider: 'provider',
+  providerAccountId: 'providerAccountId',
+  refresh_token: 'refresh_token',
+  access_token: 'access_token',
+  expires_at: 'expires_at',
+  token_type: 'token_type',
+  scope: 'scope',
+  id_token: 'id_token',
+  session_state: 'session_state'
+} as const
+
+export type AccountScalarFieldEnum = (typeof AccountScalarFieldEnum)[keyof typeof AccountScalarFieldEnum]
+
+
+export const SessionScalarFieldEnum = {
+  id: 'id',
+  sessionToken: 'sessionToken',
+  userId: 'userId',
+  expires: 'expires'
+} as const
+
+export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum]
+
+
+export const VerificationTokenScalarFieldEnum = {
+  identifier: 'identifier',
+  token: 'token',
+  expires: 'expires'
+} as const
+
+export type VerificationTokenScalarFieldEnum = (typeof VerificationTokenScalarFieldEnum)[keyof typeof VerificationTokenScalarFieldEnum]
+
+
+export const MagicLinkTokenScalarFieldEnum = {
+  id: 'id',
+  email: 'email',
+  tokenHash: 'tokenHash',
+  expiresAt: 'expiresAt',
+  createdAt: 'createdAt',
+  desktopNonce: 'desktopNonce',
+  inviteToken: 'inviteToken'
+} as const
+
+export type MagicLinkTokenScalarFieldEnum = (typeof MagicLinkTokenScalarFieldEnum)[keyof typeof MagicLinkTokenScalarFieldEnum]
+
+
+export const TransactionScalarFieldEnum = {
+  id: 'id',
+  userId: 'userId',
+  provider: 'provider',
+  transactionId: 'transactionId',
+  createdAt: 'createdAt'
+} as const
+
+export type TransactionScalarFieldEnum = (typeof TransactionScalarFieldEnum)[keyof typeof TransactionScalarFieldEnum]
+
+
+export const ProjectScalarFieldEnum = {
+  id: 'id',
+  createdAt: 'createdAt',
+  updatedAt: 'updatedAt',
+  title: 'title',
+  description: 'description',
+  author: 'author',
+  hasPoster: 'hasPoster'
+} as const
+
+export type ProjectScalarFieldEnum = (typeof ProjectScalarFieldEnum)[keyof typeof ProjectScalarFieldEnum]
+
+
+export const ProjectMemberScalarFieldEnum = {
+  id: 'id',
+  role: 'role',
+  userId: 'userId',
+  projectId: 'projectId'
+} as const
+
+export type ProjectMemberScalarFieldEnum = (typeof ProjectMemberScalarFieldEnum)[keyof typeof ProjectMemberScalarFieldEnum]
+
+
+export const ProjectInvitationScalarFieldEnum = {
+  id: 'id',
+  token: 'token',
+  email: 'email',
+  createdAt: 'createdAt',
+  projectId: 'projectId'
+} as const
+
+export type ProjectInvitationScalarFieldEnum = (typeof ProjectInvitationScalarFieldEnum)[keyof typeof ProjectInvitationScalarFieldEnum]
+
+
+export const SortOrder = {
+  asc: 'asc',
+  desc: 'desc'
+} as const
+
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]
+
+
+export const NullableJsonNullValueInput = {
+  DbNull: DbNull,
+  JsonNull: JsonNull
+} as const
+
+export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput]
+
+
+export const QueryMode = {
+  default: 'default',
+  insensitive: 'insensitive'
+} as const
+
+export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]
+
+
+export const JsonNullValueFilter = {
+  DbNull: DbNull,
+  JsonNull: JsonNull,
+  AnyNull: AnyNull
+} as const
+
+export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]
+
+
+export const NullsOrder = {
+  first: 'first',
+  last: 'last'
+} as const
+
+export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]
+
+
+
+/**
+ * Field references
+ */
+
+
+/**
+ * Reference to a field of type 'String'
+ */
+export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
+    
+
+
+/**
+ * Reference to a field of type 'String[]'
+ */
+export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>
+    
+
+
+/**
+ * Reference to a field of type 'DateTime'
+ */
+export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
+    
+
+
+/**
+ * Reference to a field of type 'DateTime[]'
+ */
+export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
+    
+
+
+/**
+ * Reference to a field of type 'UserRole'
+ */
+export type EnumUserRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserRole'>
+    
+
+
+/**
+ * Reference to a field of type 'UserRole[]'
+ */
+export type ListEnumUserRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'UserRole[]'>
+    
+
+
+/**
+ * Reference to a field of type 'Boolean'
+ */
+export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
+    
+
+
+/**
+ * Reference to a field of type 'SubscriptionProvider'
+ */
+export type EnumSubscriptionProviderFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SubscriptionProvider'>
+    
+
+
+/**
+ * Reference to a field of type 'SubscriptionProvider[]'
+ */
+export type ListEnumSubscriptionProviderFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'SubscriptionProvider[]'>
+    
+
+
+/**
+ * Reference to a field of type 'Json'
+ */
+export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
+    
+
+
+/**
+ * Reference to a field of type 'QueryMode'
+ */
+export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>
+    
+
+
+/**
+ * Reference to a field of type 'Int'
+ */
+export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
+    
+
+
+/**
+ * Reference to a field of type 'Int[]'
+ */
+export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>
+    
+
+
+/**
+ * Reference to a field of type 'ProjectRole'
+ */
+export type EnumProjectRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ProjectRole'>
+    
+
+
+/**
+ * Reference to a field of type 'ProjectRole[]'
+ */
+export type ListEnumProjectRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ProjectRole[]'>
+    
+
+
+/**
+ * Reference to a field of type 'Float'
+ */
+export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
+    
+
+
+/**
+ * Reference to a field of type 'Float[]'
+ */
+export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
+    
+
+/**
+ * Batch Payload for updateMany & deleteMany & createMany
+ */
+export type BatchPayload = {
+  count: number
+}
+
+export const defineExtension = runtime.Extensions.defineExtension as unknown as runtime.Types.Extensions.ExtendsHook<"define", TypeMapCb, runtime.Types.Extensions.DefaultArgs>
+export type DefaultPrismaClient = PrismaClient
+export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
+export type PrismaClientOptions = ({
+  /**
+   * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-pg`.
+   */
+  adapter: runtime.SqlDriverAdapterFactory
+  accelerateUrl?: never
+} | {
+  /**
+   * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
+   */
+  accelerateUrl: string
+  adapter?: never
+}) & {
+  /**
+   * @default "colorless"
+   */
+  errorFormat?: ErrorFormat
+  /**
+   * @example
+   * ```
+   * // Shorthand for `emit: 'stdout'`
+   * log: ['query', 'info', 'warn', 'error']
+   * 
+   * // Emit as events only
+   * log: [
+   *   { emit: 'event', level: 'query' },
+   *   { emit: 'event', level: 'info' },
+   *   { emit: 'event', level: 'warn' }
+   *   { emit: 'event', level: 'error' }
+   * ]
+   * 
+   * / Emit as events and log to stdout
+   * og: [
+   *  { emit: 'stdout', level: 'query' },
+   *  { emit: 'stdout', level: 'info' },
+   *  { emit: 'stdout', level: 'warn' }
+   *  { emit: 'stdout', level: 'error' }
+   * 
+   * ```
+   * Read more in our [docs](https://pris.ly/d/logging).
+   */
+  log?: (LogLevel | LogDefinition)[]
+  /**
+   * The default values for transactionOptions
+   * maxWait ?= 2000
+   * timeout ?= 5000
+   */
+  transactionOptions?: {
+    maxWait?: number
+    timeout?: number
+    isolationLevel?: TransactionIsolationLevel
+  }
+  /**
+   * Global configuration for omitting model fields by default.
+   * 
+   * @example
+   * ```
+   * const prisma = new PrismaClient({
+   *   omit: {
+   *     user: {
+   *       password: true
+   *     }
+   *   }
+   * })
+   * ```
+   */
+  omit?: GlobalOmitConfig
+  /**
+   * SQL commenter plugins that add metadata to SQL queries as comments.
+   * Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
+   * 
+   * @example
+   * ```
+   * const prisma = new PrismaClient({
+   *   adapter,
+   *   comments: [
+   *     traceContext(),
+   *     queryInsights(),
+   *   ],
+   * })
+   * ```
+   */
+  comments?: runtime.SqlCommenterPlugin[]
+}
+export type GlobalOmitConfig = {
+  user?: Prisma.UserOmit
+  account?: Prisma.AccountOmit
+  session?: Prisma.SessionOmit
+  verificationToken?: Prisma.VerificationTokenOmit
+  magicLinkToken?: Prisma.MagicLinkTokenOmit
+  transaction?: Prisma.TransactionOmit
+  project?: Prisma.ProjectOmit
+  projectMember?: Prisma.ProjectMemberOmit
+  projectInvitation?: Prisma.ProjectInvitationOmit
+}
+
+/* Types for Logging */
+export type LogLevel = 'info' | 'query' | 'warn' | 'error'
+export type LogDefinition = {
+  level: LogLevel
+  emit: 'stdout' | 'event'
+}
+
+export type CheckIsLogLevel<T> = T extends LogLevel ? T : never;
+
+export type GetLogType<T> = CheckIsLogLevel<
+  T extends LogDefinition ? T['level'] : T
+>;
+
+export type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition>
+  ? GetLogType<T[number]>
+  : never;
+
+export type QueryEvent = {
+  timestamp: Date
+  query: string
+  params: string
+  duration: number
+  target: string
+}
+
+export type LogEvent = {
+  timestamp: Date
+  message: string
+  target: string
+}
+/* End Types for Logging */
+
+
+export type PrismaAction =
+  | 'findUnique'
+  | 'findUniqueOrThrow'
+  | 'findMany'
+  | 'findFirst'
+  | 'findFirstOrThrow'
+  | 'create'
+  | 'createMany'
+  | 'createManyAndReturn'
+  | 'update'
+  | 'updateMany'
+  | 'updateManyAndReturn'
+  | 'upsert'
+  | 'delete'
+  | 'deleteMany'
+  | 'executeRaw'
+  | 'queryRaw'
+  | 'aggregate'
+  | 'count'
+  | 'runCommandRaw'
+  | 'findRaw'
+  | 'groupBy'
+
+/**
+ * `PrismaClient` proxy available in interactive transactions.
+ */
+export type TransactionClient = Omit<DefaultPrismaClient, runtime.ITXClientDenyList>
+
diff --git a/src/generated/client/internal/prismaNamespaceBrowser.ts b/src/generated/client/internal/prismaNamespaceBrowser.ts
new file mode 100644
index 00000000..c67ed3f2
--- /dev/null
+++ b/src/generated/client/internal/prismaNamespaceBrowser.ts
@@ -0,0 +1,232 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * WARNING: This is an internal file that is subject to change!
+ *
+ * 🛑 Under no circumstances should you import this file directly! 🛑
+ *
+ * All exports from this file are wrapped under a `Prisma` namespace object in the browser.ts file.
+ * While this enables partial backward compatibility, it is not part of the stable public API.
+ *
+ * If you are looking for your Models, Enums, and Input Types, please import them from the respective
+ * model files in the `model` directory!
+ */
+
+import * as runtime from "@prisma/client/runtime/index-browser"
+
+export type * from '../models'
+export type * from './prismaNamespace'
+
+export const Decimal = runtime.Decimal
+
+
+export const NullTypes = {
+  DbNull: runtime.NullTypes.DbNull as (new (secret: never) => typeof runtime.DbNull),
+  JsonNull: runtime.NullTypes.JsonNull as (new (secret: never) => typeof runtime.JsonNull),
+  AnyNull: runtime.NullTypes.AnyNull as (new (secret: never) => typeof runtime.AnyNull),
+}
+/**
+ * Helper for filtering JSON entries that have `null` on the database (empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const DbNull = runtime.DbNull
+
+/**
+ * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const JsonNull = runtime.JsonNull
+
+/**
+ * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const AnyNull = runtime.AnyNull
+
+
+export const ModelName = {
+  User: 'User',
+  Account: 'Account',
+  Session: 'Session',
+  VerificationToken: 'VerificationToken',
+  MagicLinkToken: 'MagicLinkToken',
+  Transaction: 'Transaction',
+  Project: 'Project',
+  ProjectMember: 'ProjectMember',
+  ProjectInvitation: 'ProjectInvitation'
+} as const
+
+export type ModelName = (typeof ModelName)[keyof typeof ModelName]
+
+/*
+ * Enums
+ */
+
+export const TransactionIsolationLevel = runtime.makeStrictEnum({
+  ReadUncommitted: 'ReadUncommitted',
+  ReadCommitted: 'ReadCommitted',
+  RepeatableRead: 'RepeatableRead',
+  Serializable: 'Serializable'
+} as const)
+
+export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
+
+
+export const UserScalarFieldEnum = {
+  id: 'id',
+  createdAt: 'createdAt',
+  email: 'email',
+  emailVerified: 'emailVerified',
+  username: 'username',
+  color: 'color',
+  role: 'role',
+  isProUntil: 'isProUntil',
+  isSubscriptionCancelled: 'isSubscriptionCancelled',
+  subscriptionProvider: 'subscriptionProvider',
+  settings: 'settings'
+} as const
+
+export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]
+
+
+export const AccountScalarFieldEnum = {
+  id: 'id',
+  userId: 'userId',
+  type: 'type',
+  provider: 'provider',
+  providerAccountId: 'providerAccountId',
+  refresh_token: 'refresh_token',
+  access_token: 'access_token',
+  expires_at: 'expires_at',
+  token_type: 'token_type',
+  scope: 'scope',
+  id_token: 'id_token',
+  session_state: 'session_state'
+} as const
+
+export type AccountScalarFieldEnum = (typeof AccountScalarFieldEnum)[keyof typeof AccountScalarFieldEnum]
+
+
+export const SessionScalarFieldEnum = {
+  id: 'id',
+  sessionToken: 'sessionToken',
+  userId: 'userId',
+  expires: 'expires'
+} as const
+
+export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum]
+
+
+export const VerificationTokenScalarFieldEnum = {
+  identifier: 'identifier',
+  token: 'token',
+  expires: 'expires'
+} as const
+
+export type VerificationTokenScalarFieldEnum = (typeof VerificationTokenScalarFieldEnum)[keyof typeof VerificationTokenScalarFieldEnum]
+
+
+export const MagicLinkTokenScalarFieldEnum = {
+  id: 'id',
+  email: 'email',
+  tokenHash: 'tokenHash',
+  expiresAt: 'expiresAt',
+  createdAt: 'createdAt',
+  desktopNonce: 'desktopNonce',
+  inviteToken: 'inviteToken'
+} as const
+
+export type MagicLinkTokenScalarFieldEnum = (typeof MagicLinkTokenScalarFieldEnum)[keyof typeof MagicLinkTokenScalarFieldEnum]
+
+
+export const TransactionScalarFieldEnum = {
+  id: 'id',
+  userId: 'userId',
+  provider: 'provider',
+  transactionId: 'transactionId',
+  createdAt: 'createdAt'
+} as const
+
+export type TransactionScalarFieldEnum = (typeof TransactionScalarFieldEnum)[keyof typeof TransactionScalarFieldEnum]
+
+
+export const ProjectScalarFieldEnum = {
+  id: 'id',
+  createdAt: 'createdAt',
+  updatedAt: 'updatedAt',
+  title: 'title',
+  description: 'description',
+  author: 'author',
+  hasPoster: 'hasPoster'
+} as const
+
+export type ProjectScalarFieldEnum = (typeof ProjectScalarFieldEnum)[keyof typeof ProjectScalarFieldEnum]
+
+
+export const ProjectMemberScalarFieldEnum = {
+  id: 'id',
+  role: 'role',
+  userId: 'userId',
+  projectId: 'projectId'
+} as const
+
+export type ProjectMemberScalarFieldEnum = (typeof ProjectMemberScalarFieldEnum)[keyof typeof ProjectMemberScalarFieldEnum]
+
+
+export const ProjectInvitationScalarFieldEnum = {
+  id: 'id',
+  token: 'token',
+  email: 'email',
+  createdAt: 'createdAt',
+  projectId: 'projectId'
+} as const
+
+export type ProjectInvitationScalarFieldEnum = (typeof ProjectInvitationScalarFieldEnum)[keyof typeof ProjectInvitationScalarFieldEnum]
+
+
+export const SortOrder = {
+  asc: 'asc',
+  desc: 'desc'
+} as const
+
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]
+
+
+export const NullableJsonNullValueInput = {
+  DbNull: DbNull,
+  JsonNull: JsonNull
+} as const
+
+export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput]
+
+
+export const QueryMode = {
+  default: 'default',
+  insensitive: 'insensitive'
+} as const
+
+export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]
+
+
+export const JsonNullValueFilter = {
+  DbNull: DbNull,
+  JsonNull: JsonNull,
+  AnyNull: AnyNull
+} as const
+
+export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]
+
+
+export const NullsOrder = {
+  first: 'first',
+  last: 'last'
+} as const
+
+export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]
+
diff --git a/src/generated/client/models.ts b/src/generated/client/models.ts
new file mode 100644
index 00000000..2db97a39
--- /dev/null
+++ b/src/generated/client/models.ts
@@ -0,0 +1,20 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This is a barrel export file for all models and their related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+export type * from './models/User'
+export type * from './models/Account'
+export type * from './models/Session'
+export type * from './models/VerificationToken'
+export type * from './models/MagicLinkToken'
+export type * from './models/Transaction'
+export type * from './models/Project'
+export type * from './models/ProjectMember'
+export type * from './models/ProjectInvitation'
+export type * from './commonInputTypes'
\ No newline at end of file
diff --git a/src/generated/client/models/Account.ts b/src/generated/client/models/Account.ts
new file mode 100644
index 00000000..068b2bd1
--- /dev/null
+++ b/src/generated/client/models/Account.ts
@@ -0,0 +1,1648 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `Account` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model Account
+ * 
+ */
+export type AccountModel = runtime.Types.Result.DefaultSelection<Prisma.$AccountPayload>
+
+export type AggregateAccount = {
+  _count: AccountCountAggregateOutputType | null
+  _avg: AccountAvgAggregateOutputType | null
+  _sum: AccountSumAggregateOutputType | null
+  _min: AccountMinAggregateOutputType | null
+  _max: AccountMaxAggregateOutputType | null
+}
+
+export type AccountAvgAggregateOutputType = {
+  expires_at: number | null
+}
+
+export type AccountSumAggregateOutputType = {
+  expires_at: number | null
+}
+
+export type AccountMinAggregateOutputType = {
+  id: string | null
+  userId: string | null
+  type: string | null
+  provider: string | null
+  providerAccountId: string | null
+  refresh_token: string | null
+  access_token: string | null
+  expires_at: number | null
+  token_type: string | null
+  scope: string | null
+  id_token: string | null
+  session_state: string | null
+}
+
+export type AccountMaxAggregateOutputType = {
+  id: string | null
+  userId: string | null
+  type: string | null
+  provider: string | null
+  providerAccountId: string | null
+  refresh_token: string | null
+  access_token: string | null
+  expires_at: number | null
+  token_type: string | null
+  scope: string | null
+  id_token: string | null
+  session_state: string | null
+}
+
+export type AccountCountAggregateOutputType = {
+  id: number
+  userId: number
+  type: number
+  provider: number
+  providerAccountId: number
+  refresh_token: number
+  access_token: number
+  expires_at: number
+  token_type: number
+  scope: number
+  id_token: number
+  session_state: number
+  _all: number
+}
+
+
+export type AccountAvgAggregateInputType = {
+  expires_at?: true
+}
+
+export type AccountSumAggregateInputType = {
+  expires_at?: true
+}
+
+export type AccountMinAggregateInputType = {
+  id?: true
+  userId?: true
+  type?: true
+  provider?: true
+  providerAccountId?: true
+  refresh_token?: true
+  access_token?: true
+  expires_at?: true
+  token_type?: true
+  scope?: true
+  id_token?: true
+  session_state?: true
+}
+
+export type AccountMaxAggregateInputType = {
+  id?: true
+  userId?: true
+  type?: true
+  provider?: true
+  providerAccountId?: true
+  refresh_token?: true
+  access_token?: true
+  expires_at?: true
+  token_type?: true
+  scope?: true
+  id_token?: true
+  session_state?: true
+}
+
+export type AccountCountAggregateInputType = {
+  id?: true
+  userId?: true
+  type?: true
+  provider?: true
+  providerAccountId?: true
+  refresh_token?: true
+  access_token?: true
+  expires_at?: true
+  token_type?: true
+  scope?: true
+  id_token?: true
+  session_state?: true
+  _all?: true
+}
+
+export type AccountAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Account to aggregate.
+   */
+  where?: Prisma.AccountWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Accounts to fetch.
+   */
+  orderBy?: Prisma.AccountOrderByWithRelationInput | Prisma.AccountOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.AccountWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Accounts from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Accounts.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned Accounts
+  **/
+  _count?: true | AccountCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to average
+  **/
+  _avg?: AccountAvgAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to sum
+  **/
+  _sum?: AccountSumAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: AccountMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: AccountMaxAggregateInputType
+}
+
+export type GetAccountAggregateType<T extends AccountAggregateArgs> = {
+      [P in keyof T & keyof AggregateAccount]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateAccount[P]>
+    : Prisma.GetScalarType<T[P], AggregateAccount[P]>
+}
+
+
+
+
+export type AccountGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.AccountWhereInput
+  orderBy?: Prisma.AccountOrderByWithAggregationInput | Prisma.AccountOrderByWithAggregationInput[]
+  by: Prisma.AccountScalarFieldEnum[] | Prisma.AccountScalarFieldEnum
+  having?: Prisma.AccountScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: AccountCountAggregateInputType | true
+  _avg?: AccountAvgAggregateInputType
+  _sum?: AccountSumAggregateInputType
+  _min?: AccountMinAggregateInputType
+  _max?: AccountMaxAggregateInputType
+}
+
+export type AccountGroupByOutputType = {
+  id: string
+  userId: string
+  type: string
+  provider: string
+  providerAccountId: string
+  refresh_token: string | null
+  access_token: string | null
+  expires_at: number | null
+  token_type: string | null
+  scope: string | null
+  id_token: string | null
+  session_state: string | null
+  _count: AccountCountAggregateOutputType | null
+  _avg: AccountAvgAggregateOutputType | null
+  _sum: AccountSumAggregateOutputType | null
+  _min: AccountMinAggregateOutputType | null
+  _max: AccountMaxAggregateOutputType | null
+}
+
+export type GetAccountGroupByPayload<T extends AccountGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<AccountGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof AccountGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], AccountGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], AccountGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type AccountWhereInput = {
+  AND?: Prisma.AccountWhereInput | Prisma.AccountWhereInput[]
+  OR?: Prisma.AccountWhereInput[]
+  NOT?: Prisma.AccountWhereInput | Prisma.AccountWhereInput[]
+  id?: Prisma.StringFilter<"Account"> | string
+  userId?: Prisma.StringFilter<"Account"> | string
+  type?: Prisma.StringFilter<"Account"> | string
+  provider?: Prisma.StringFilter<"Account"> | string
+  providerAccountId?: Prisma.StringFilter<"Account"> | string
+  refresh_token?: Prisma.StringNullableFilter<"Account"> | string | null
+  access_token?: Prisma.StringNullableFilter<"Account"> | string | null
+  expires_at?: Prisma.IntNullableFilter<"Account"> | number | null
+  token_type?: Prisma.StringNullableFilter<"Account"> | string | null
+  scope?: Prisma.StringNullableFilter<"Account"> | string | null
+  id_token?: Prisma.StringNullableFilter<"Account"> | string | null
+  session_state?: Prisma.StringNullableFilter<"Account"> | string | null
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+}
+
+export type AccountOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  type?: Prisma.SortOrder
+  provider?: Prisma.SortOrder
+  providerAccountId?: Prisma.SortOrder
+  refresh_token?: Prisma.SortOrderInput | Prisma.SortOrder
+  access_token?: Prisma.SortOrderInput | Prisma.SortOrder
+  expires_at?: Prisma.SortOrderInput | Prisma.SortOrder
+  token_type?: Prisma.SortOrderInput | Prisma.SortOrder
+  scope?: Prisma.SortOrderInput | Prisma.SortOrder
+  id_token?: Prisma.SortOrderInput | Prisma.SortOrder
+  session_state?: Prisma.SortOrderInput | Prisma.SortOrder
+  user?: Prisma.UserOrderByWithRelationInput
+}
+
+export type AccountWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  provider_providerAccountId?: Prisma.AccountProviderProviderAccountIdCompoundUniqueInput
+  AND?: Prisma.AccountWhereInput | Prisma.AccountWhereInput[]
+  OR?: Prisma.AccountWhereInput[]
+  NOT?: Prisma.AccountWhereInput | Prisma.AccountWhereInput[]
+  userId?: Prisma.StringFilter<"Account"> | string
+  type?: Prisma.StringFilter<"Account"> | string
+  provider?: Prisma.StringFilter<"Account"> | string
+  providerAccountId?: Prisma.StringFilter<"Account"> | string
+  refresh_token?: Prisma.StringNullableFilter<"Account"> | string | null
+  access_token?: Prisma.StringNullableFilter<"Account"> | string | null
+  expires_at?: Prisma.IntNullableFilter<"Account"> | number | null
+  token_type?: Prisma.StringNullableFilter<"Account"> | string | null
+  scope?: Prisma.StringNullableFilter<"Account"> | string | null
+  id_token?: Prisma.StringNullableFilter<"Account"> | string | null
+  session_state?: Prisma.StringNullableFilter<"Account"> | string | null
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+}, "id" | "provider_providerAccountId">
+
+export type AccountOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  type?: Prisma.SortOrder
+  provider?: Prisma.SortOrder
+  providerAccountId?: Prisma.SortOrder
+  refresh_token?: Prisma.SortOrderInput | Prisma.SortOrder
+  access_token?: Prisma.SortOrderInput | Prisma.SortOrder
+  expires_at?: Prisma.SortOrderInput | Prisma.SortOrder
+  token_type?: Prisma.SortOrderInput | Prisma.SortOrder
+  scope?: Prisma.SortOrderInput | Prisma.SortOrder
+  id_token?: Prisma.SortOrderInput | Prisma.SortOrder
+  session_state?: Prisma.SortOrderInput | Prisma.SortOrder
+  _count?: Prisma.AccountCountOrderByAggregateInput
+  _avg?: Prisma.AccountAvgOrderByAggregateInput
+  _max?: Prisma.AccountMaxOrderByAggregateInput
+  _min?: Prisma.AccountMinOrderByAggregateInput
+  _sum?: Prisma.AccountSumOrderByAggregateInput
+}
+
+export type AccountScalarWhereWithAggregatesInput = {
+  AND?: Prisma.AccountScalarWhereWithAggregatesInput | Prisma.AccountScalarWhereWithAggregatesInput[]
+  OR?: Prisma.AccountScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.AccountScalarWhereWithAggregatesInput | Prisma.AccountScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"Account"> | string
+  userId?: Prisma.StringWithAggregatesFilter<"Account"> | string
+  type?: Prisma.StringWithAggregatesFilter<"Account"> | string
+  provider?: Prisma.StringWithAggregatesFilter<"Account"> | string
+  providerAccountId?: Prisma.StringWithAggregatesFilter<"Account"> | string
+  refresh_token?: Prisma.StringNullableWithAggregatesFilter<"Account"> | string | null
+  access_token?: Prisma.StringNullableWithAggregatesFilter<"Account"> | string | null
+  expires_at?: Prisma.IntNullableWithAggregatesFilter<"Account"> | number | null
+  token_type?: Prisma.StringNullableWithAggregatesFilter<"Account"> | string | null
+  scope?: Prisma.StringNullableWithAggregatesFilter<"Account"> | string | null
+  id_token?: Prisma.StringNullableWithAggregatesFilter<"Account"> | string | null
+  session_state?: Prisma.StringNullableWithAggregatesFilter<"Account"> | string | null
+}
+
+export type AccountCreateInput = {
+  id?: string
+  type: string
+  provider: string
+  providerAccountId: string
+  refresh_token?: string | null
+  access_token?: string | null
+  expires_at?: number | null
+  token_type?: string | null
+  scope?: string | null
+  id_token?: string | null
+  session_state?: string | null
+  user: Prisma.UserCreateNestedOneWithoutAccountsInput
+}
+
+export type AccountUncheckedCreateInput = {
+  id?: string
+  userId: string
+  type: string
+  provider: string
+  providerAccountId: string
+  refresh_token?: string | null
+  access_token?: string | null
+  expires_at?: number | null
+  token_type?: string | null
+  scope?: string | null
+  id_token?: string | null
+  session_state?: string | null
+}
+
+export type AccountUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  type?: Prisma.StringFieldUpdateOperationsInput | string
+  provider?: Prisma.StringFieldUpdateOperationsInput | string
+  providerAccountId?: Prisma.StringFieldUpdateOperationsInput | string
+  refresh_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  access_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expires_at?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  token_type?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  scope?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  id_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  session_state?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  user?: Prisma.UserUpdateOneRequiredWithoutAccountsNestedInput
+}
+
+export type AccountUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  type?: Prisma.StringFieldUpdateOperationsInput | string
+  provider?: Prisma.StringFieldUpdateOperationsInput | string
+  providerAccountId?: Prisma.StringFieldUpdateOperationsInput | string
+  refresh_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  access_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expires_at?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  token_type?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  scope?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  id_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  session_state?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type AccountCreateManyInput = {
+  id?: string
+  userId: string
+  type: string
+  provider: string
+  providerAccountId: string
+  refresh_token?: string | null
+  access_token?: string | null
+  expires_at?: number | null
+  token_type?: string | null
+  scope?: string | null
+  id_token?: string | null
+  session_state?: string | null
+}
+
+export type AccountUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  type?: Prisma.StringFieldUpdateOperationsInput | string
+  provider?: Prisma.StringFieldUpdateOperationsInput | string
+  providerAccountId?: Prisma.StringFieldUpdateOperationsInput | string
+  refresh_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  access_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expires_at?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  token_type?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  scope?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  id_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  session_state?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type AccountUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  type?: Prisma.StringFieldUpdateOperationsInput | string
+  provider?: Prisma.StringFieldUpdateOperationsInput | string
+  providerAccountId?: Prisma.StringFieldUpdateOperationsInput | string
+  refresh_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  access_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expires_at?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  token_type?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  scope?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  id_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  session_state?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type AccountListRelationFilter = {
+  every?: Prisma.AccountWhereInput
+  some?: Prisma.AccountWhereInput
+  none?: Prisma.AccountWhereInput
+}
+
+export type AccountOrderByRelationAggregateInput = {
+  _count?: Prisma.SortOrder
+}
+
+export type AccountProviderProviderAccountIdCompoundUniqueInput = {
+  provider: string
+  providerAccountId: string
+}
+
+export type AccountCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  type?: Prisma.SortOrder
+  provider?: Prisma.SortOrder
+  providerAccountId?: Prisma.SortOrder
+  refresh_token?: Prisma.SortOrder
+  access_token?: Prisma.SortOrder
+  expires_at?: Prisma.SortOrder
+  token_type?: Prisma.SortOrder
+  scope?: Prisma.SortOrder
+  id_token?: Prisma.SortOrder
+  session_state?: Prisma.SortOrder
+}
+
+export type AccountAvgOrderByAggregateInput = {
+  expires_at?: Prisma.SortOrder
+}
+
+export type AccountMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  type?: Prisma.SortOrder
+  provider?: Prisma.SortOrder
+  providerAccountId?: Prisma.SortOrder
+  refresh_token?: Prisma.SortOrder
+  access_token?: Prisma.SortOrder
+  expires_at?: Prisma.SortOrder
+  token_type?: Prisma.SortOrder
+  scope?: Prisma.SortOrder
+  id_token?: Prisma.SortOrder
+  session_state?: Prisma.SortOrder
+}
+
+export type AccountMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  type?: Prisma.SortOrder
+  provider?: Prisma.SortOrder
+  providerAccountId?: Prisma.SortOrder
+  refresh_token?: Prisma.SortOrder
+  access_token?: Prisma.SortOrder
+  expires_at?: Prisma.SortOrder
+  token_type?: Prisma.SortOrder
+  scope?: Prisma.SortOrder
+  id_token?: Prisma.SortOrder
+  session_state?: Prisma.SortOrder
+}
+
+export type AccountSumOrderByAggregateInput = {
+  expires_at?: Prisma.SortOrder
+}
+
+export type AccountCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.AccountCreateWithoutUserInput, Prisma.AccountUncheckedCreateWithoutUserInput> | Prisma.AccountCreateWithoutUserInput[] | Prisma.AccountUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.AccountCreateOrConnectWithoutUserInput | Prisma.AccountCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.AccountCreateManyUserInputEnvelope
+  connect?: Prisma.AccountWhereUniqueInput | Prisma.AccountWhereUniqueInput[]
+}
+
+export type AccountUncheckedCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.AccountCreateWithoutUserInput, Prisma.AccountUncheckedCreateWithoutUserInput> | Prisma.AccountCreateWithoutUserInput[] | Prisma.AccountUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.AccountCreateOrConnectWithoutUserInput | Prisma.AccountCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.AccountCreateManyUserInputEnvelope
+  connect?: Prisma.AccountWhereUniqueInput | Prisma.AccountWhereUniqueInput[]
+}
+
+export type AccountUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.AccountCreateWithoutUserInput, Prisma.AccountUncheckedCreateWithoutUserInput> | Prisma.AccountCreateWithoutUserInput[] | Prisma.AccountUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.AccountCreateOrConnectWithoutUserInput | Prisma.AccountCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.AccountUpsertWithWhereUniqueWithoutUserInput | Prisma.AccountUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.AccountCreateManyUserInputEnvelope
+  set?: Prisma.AccountWhereUniqueInput | Prisma.AccountWhereUniqueInput[]
+  disconnect?: Prisma.AccountWhereUniqueInput | Prisma.AccountWhereUniqueInput[]
+  delete?: Prisma.AccountWhereUniqueInput | Prisma.AccountWhereUniqueInput[]
+  connect?: Prisma.AccountWhereUniqueInput | Prisma.AccountWhereUniqueInput[]
+  update?: Prisma.AccountUpdateWithWhereUniqueWithoutUserInput | Prisma.AccountUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.AccountUpdateManyWithWhereWithoutUserInput | Prisma.AccountUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.AccountScalarWhereInput | Prisma.AccountScalarWhereInput[]
+}
+
+export type AccountUncheckedUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.AccountCreateWithoutUserInput, Prisma.AccountUncheckedCreateWithoutUserInput> | Prisma.AccountCreateWithoutUserInput[] | Prisma.AccountUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.AccountCreateOrConnectWithoutUserInput | Prisma.AccountCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.AccountUpsertWithWhereUniqueWithoutUserInput | Prisma.AccountUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.AccountCreateManyUserInputEnvelope
+  set?: Prisma.AccountWhereUniqueInput | Prisma.AccountWhereUniqueInput[]
+  disconnect?: Prisma.AccountWhereUniqueInput | Prisma.AccountWhereUniqueInput[]
+  delete?: Prisma.AccountWhereUniqueInput | Prisma.AccountWhereUniqueInput[]
+  connect?: Prisma.AccountWhereUniqueInput | Prisma.AccountWhereUniqueInput[]
+  update?: Prisma.AccountUpdateWithWhereUniqueWithoutUserInput | Prisma.AccountUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.AccountUpdateManyWithWhereWithoutUserInput | Prisma.AccountUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.AccountScalarWhereInput | Prisma.AccountScalarWhereInput[]
+}
+
+export type NullableIntFieldUpdateOperationsInput = {
+  set?: number | null
+  increment?: number
+  decrement?: number
+  multiply?: number
+  divide?: number
+}
+
+export type AccountCreateWithoutUserInput = {
+  id?: string
+  type: string
+  provider: string
+  providerAccountId: string
+  refresh_token?: string | null
+  access_token?: string | null
+  expires_at?: number | null
+  token_type?: string | null
+  scope?: string | null
+  id_token?: string | null
+  session_state?: string | null
+}
+
+export type AccountUncheckedCreateWithoutUserInput = {
+  id?: string
+  type: string
+  provider: string
+  providerAccountId: string
+  refresh_token?: string | null
+  access_token?: string | null
+  expires_at?: number | null
+  token_type?: string | null
+  scope?: string | null
+  id_token?: string | null
+  session_state?: string | null
+}
+
+export type AccountCreateOrConnectWithoutUserInput = {
+  where: Prisma.AccountWhereUniqueInput
+  create: Prisma.XOR<Prisma.AccountCreateWithoutUserInput, Prisma.AccountUncheckedCreateWithoutUserInput>
+}
+
+export type AccountCreateManyUserInputEnvelope = {
+  data: Prisma.AccountCreateManyUserInput | Prisma.AccountCreateManyUserInput[]
+  skipDuplicates?: boolean
+}
+
+export type AccountUpsertWithWhereUniqueWithoutUserInput = {
+  where: Prisma.AccountWhereUniqueInput
+  update: Prisma.XOR<Prisma.AccountUpdateWithoutUserInput, Prisma.AccountUncheckedUpdateWithoutUserInput>
+  create: Prisma.XOR<Prisma.AccountCreateWithoutUserInput, Prisma.AccountUncheckedCreateWithoutUserInput>
+}
+
+export type AccountUpdateWithWhereUniqueWithoutUserInput = {
+  where: Prisma.AccountWhereUniqueInput
+  data: Prisma.XOR<Prisma.AccountUpdateWithoutUserInput, Prisma.AccountUncheckedUpdateWithoutUserInput>
+}
+
+export type AccountUpdateManyWithWhereWithoutUserInput = {
+  where: Prisma.AccountScalarWhereInput
+  data: Prisma.XOR<Prisma.AccountUpdateManyMutationInput, Prisma.AccountUncheckedUpdateManyWithoutUserInput>
+}
+
+export type AccountScalarWhereInput = {
+  AND?: Prisma.AccountScalarWhereInput | Prisma.AccountScalarWhereInput[]
+  OR?: Prisma.AccountScalarWhereInput[]
+  NOT?: Prisma.AccountScalarWhereInput | Prisma.AccountScalarWhereInput[]
+  id?: Prisma.StringFilter<"Account"> | string
+  userId?: Prisma.StringFilter<"Account"> | string
+  type?: Prisma.StringFilter<"Account"> | string
+  provider?: Prisma.StringFilter<"Account"> | string
+  providerAccountId?: Prisma.StringFilter<"Account"> | string
+  refresh_token?: Prisma.StringNullableFilter<"Account"> | string | null
+  access_token?: Prisma.StringNullableFilter<"Account"> | string | null
+  expires_at?: Prisma.IntNullableFilter<"Account"> | number | null
+  token_type?: Prisma.StringNullableFilter<"Account"> | string | null
+  scope?: Prisma.StringNullableFilter<"Account"> | string | null
+  id_token?: Prisma.StringNullableFilter<"Account"> | string | null
+  session_state?: Prisma.StringNullableFilter<"Account"> | string | null
+}
+
+export type AccountCreateManyUserInput = {
+  id?: string
+  type: string
+  provider: string
+  providerAccountId: string
+  refresh_token?: string | null
+  access_token?: string | null
+  expires_at?: number | null
+  token_type?: string | null
+  scope?: string | null
+  id_token?: string | null
+  session_state?: string | null
+}
+
+export type AccountUpdateWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  type?: Prisma.StringFieldUpdateOperationsInput | string
+  provider?: Prisma.StringFieldUpdateOperationsInput | string
+  providerAccountId?: Prisma.StringFieldUpdateOperationsInput | string
+  refresh_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  access_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expires_at?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  token_type?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  scope?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  id_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  session_state?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type AccountUncheckedUpdateWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  type?: Prisma.StringFieldUpdateOperationsInput | string
+  provider?: Prisma.StringFieldUpdateOperationsInput | string
+  providerAccountId?: Prisma.StringFieldUpdateOperationsInput | string
+  refresh_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  access_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expires_at?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  token_type?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  scope?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  id_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  session_state?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type AccountUncheckedUpdateManyWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  type?: Prisma.StringFieldUpdateOperationsInput | string
+  provider?: Prisma.StringFieldUpdateOperationsInput | string
+  providerAccountId?: Prisma.StringFieldUpdateOperationsInput | string
+  refresh_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  access_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  expires_at?: Prisma.NullableIntFieldUpdateOperationsInput | number | null
+  token_type?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  scope?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  id_token?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  session_state?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+
+
+export type AccountSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  userId?: boolean
+  type?: boolean
+  provider?: boolean
+  providerAccountId?: boolean
+  refresh_token?: boolean
+  access_token?: boolean
+  expires_at?: boolean
+  token_type?: boolean
+  scope?: boolean
+  id_token?: boolean
+  session_state?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["account"]>
+
+export type AccountSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  userId?: boolean
+  type?: boolean
+  provider?: boolean
+  providerAccountId?: boolean
+  refresh_token?: boolean
+  access_token?: boolean
+  expires_at?: boolean
+  token_type?: boolean
+  scope?: boolean
+  id_token?: boolean
+  session_state?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["account"]>
+
+export type AccountSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  userId?: boolean
+  type?: boolean
+  provider?: boolean
+  providerAccountId?: boolean
+  refresh_token?: boolean
+  access_token?: boolean
+  expires_at?: boolean
+  token_type?: boolean
+  scope?: boolean
+  id_token?: boolean
+  session_state?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["account"]>
+
+export type AccountSelectScalar = {
+  id?: boolean
+  userId?: boolean
+  type?: boolean
+  provider?: boolean
+  providerAccountId?: boolean
+  refresh_token?: boolean
+  access_token?: boolean
+  expires_at?: boolean
+  token_type?: boolean
+  scope?: boolean
+  id_token?: boolean
+  session_state?: boolean
+}
+
+export type AccountOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "userId" | "type" | "provider" | "providerAccountId" | "refresh_token" | "access_token" | "expires_at" | "token_type" | "scope" | "id_token" | "session_state", ExtArgs["result"]["account"]>
+export type AccountInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+export type AccountIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+export type AccountIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+
+export type $AccountPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "Account"
+  objects: {
+    user: Prisma.$UserPayload<ExtArgs>
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    userId: string
+    type: string
+    provider: string
+    providerAccountId: string
+    refresh_token: string | null
+    access_token: string | null
+    expires_at: number | null
+    token_type: string | null
+    scope: string | null
+    id_token: string | null
+    session_state: string | null
+  }, ExtArgs["result"]["account"]>
+  composites: {}
+}
+
+export type AccountGetPayload<S extends boolean | null | undefined | AccountDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$AccountPayload, S>
+
+export type AccountCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<AccountFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: AccountCountAggregateInputType | true
+  }
+
+export interface AccountDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Account'], meta: { name: 'Account' } }
+  /**
+   * Find zero or one Account that matches the filter.
+   * @param {AccountFindUniqueArgs} args - Arguments to find a Account
+   * @example
+   * // Get one Account
+   * const account = await prisma.account.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends AccountFindUniqueArgs>(args: Prisma.SelectSubset<T, AccountFindUniqueArgs<ExtArgs>>): Prisma.Prisma__AccountClient<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one Account that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {AccountFindUniqueOrThrowArgs} args - Arguments to find a Account
+   * @example
+   * // Get one Account
+   * const account = await prisma.account.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends AccountFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, AccountFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__AccountClient<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Account that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {AccountFindFirstArgs} args - Arguments to find a Account
+   * @example
+   * // Get one Account
+   * const account = await prisma.account.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends AccountFindFirstArgs>(args?: Prisma.SelectSubset<T, AccountFindFirstArgs<ExtArgs>>): Prisma.Prisma__AccountClient<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Account that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {AccountFindFirstOrThrowArgs} args - Arguments to find a Account
+   * @example
+   * // Get one Account
+   * const account = await prisma.account.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends AccountFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, AccountFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__AccountClient<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more Accounts that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {AccountFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all Accounts
+   * const accounts = await prisma.account.findMany()
+   * 
+   * // Get first 10 Accounts
+   * const accounts = await prisma.account.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const accountWithIdOnly = await prisma.account.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends AccountFindManyArgs>(args?: Prisma.SelectSubset<T, AccountFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a Account.
+   * @param {AccountCreateArgs} args - Arguments to create a Account.
+   * @example
+   * // Create one Account
+   * const Account = await prisma.account.create({
+   *   data: {
+   *     // ... data to create a Account
+   *   }
+   * })
+   * 
+   */
+  create<T extends AccountCreateArgs>(args: Prisma.SelectSubset<T, AccountCreateArgs<ExtArgs>>): Prisma.Prisma__AccountClient<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many Accounts.
+   * @param {AccountCreateManyArgs} args - Arguments to create many Accounts.
+   * @example
+   * // Create many Accounts
+   * const account = await prisma.account.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends AccountCreateManyArgs>(args?: Prisma.SelectSubset<T, AccountCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many Accounts and returns the data saved in the database.
+   * @param {AccountCreateManyAndReturnArgs} args - Arguments to create many Accounts.
+   * @example
+   * // Create many Accounts
+   * const account = await prisma.account.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many Accounts and only return the `id`
+   * const accountWithIdOnly = await prisma.account.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends AccountCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, AccountCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a Account.
+   * @param {AccountDeleteArgs} args - Arguments to delete one Account.
+   * @example
+   * // Delete one Account
+   * const Account = await prisma.account.delete({
+   *   where: {
+   *     // ... filter to delete one Account
+   *   }
+   * })
+   * 
+   */
+  delete<T extends AccountDeleteArgs>(args: Prisma.SelectSubset<T, AccountDeleteArgs<ExtArgs>>): Prisma.Prisma__AccountClient<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one Account.
+   * @param {AccountUpdateArgs} args - Arguments to update one Account.
+   * @example
+   * // Update one Account
+   * const account = await prisma.account.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends AccountUpdateArgs>(args: Prisma.SelectSubset<T, AccountUpdateArgs<ExtArgs>>): Prisma.Prisma__AccountClient<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more Accounts.
+   * @param {AccountDeleteManyArgs} args - Arguments to filter Accounts to delete.
+   * @example
+   * // Delete a few Accounts
+   * const { count } = await prisma.account.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends AccountDeleteManyArgs>(args?: Prisma.SelectSubset<T, AccountDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Accounts.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {AccountUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many Accounts
+   * const account = await prisma.account.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends AccountUpdateManyArgs>(args: Prisma.SelectSubset<T, AccountUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Accounts and returns the data updated in the database.
+   * @param {AccountUpdateManyAndReturnArgs} args - Arguments to update many Accounts.
+   * @example
+   * // Update many Accounts
+   * const account = await prisma.account.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more Accounts and only return the `id`
+   * const accountWithIdOnly = await prisma.account.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends AccountUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, AccountUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one Account.
+   * @param {AccountUpsertArgs} args - Arguments to update or create a Account.
+   * @example
+   * // Update or create a Account
+   * const account = await prisma.account.upsert({
+   *   create: {
+   *     // ... data to create a Account
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the Account we want to update
+   *   }
+   * })
+   */
+  upsert<T extends AccountUpsertArgs>(args: Prisma.SelectSubset<T, AccountUpsertArgs<ExtArgs>>): Prisma.Prisma__AccountClient<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of Accounts.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {AccountCountArgs} args - Arguments to filter Accounts to count.
+   * @example
+   * // Count the number of Accounts
+   * const count = await prisma.account.count({
+   *   where: {
+   *     // ... the filter for the Accounts we want to count
+   *   }
+   * })
+  **/
+  count<T extends AccountCountArgs>(
+    args?: Prisma.Subset<T, AccountCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], AccountCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a Account.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {AccountAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends AccountAggregateArgs>(args: Prisma.Subset<T, AccountAggregateArgs>): Prisma.PrismaPromise<GetAccountAggregateType<T>>
+
+  /**
+   * Group by Account.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {AccountGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends AccountGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: AccountGroupByArgs['orderBy'] }
+      : { orderBy?: AccountGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, AccountGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAccountGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the Account model
+ */
+readonly fields: AccountFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for Account.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__AccountClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  user<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the Account model
+ */
+export interface AccountFieldRefs {
+  readonly id: Prisma.FieldRef<"Account", 'String'>
+  readonly userId: Prisma.FieldRef<"Account", 'String'>
+  readonly type: Prisma.FieldRef<"Account", 'String'>
+  readonly provider: Prisma.FieldRef<"Account", 'String'>
+  readonly providerAccountId: Prisma.FieldRef<"Account", 'String'>
+  readonly refresh_token: Prisma.FieldRef<"Account", 'String'>
+  readonly access_token: Prisma.FieldRef<"Account", 'String'>
+  readonly expires_at: Prisma.FieldRef<"Account", 'Int'>
+  readonly token_type: Prisma.FieldRef<"Account", 'String'>
+  readonly scope: Prisma.FieldRef<"Account", 'String'>
+  readonly id_token: Prisma.FieldRef<"Account", 'String'>
+  readonly session_state: Prisma.FieldRef<"Account", 'String'>
+}
+    
+
+// Custom InputTypes
+/**
+ * Account findUnique
+ */
+export type AccountFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+  /**
+   * Filter, which Account to fetch.
+   */
+  where: Prisma.AccountWhereUniqueInput
+}
+
+/**
+ * Account findUniqueOrThrow
+ */
+export type AccountFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+  /**
+   * Filter, which Account to fetch.
+   */
+  where: Prisma.AccountWhereUniqueInput
+}
+
+/**
+ * Account findFirst
+ */
+export type AccountFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+  /**
+   * Filter, which Account to fetch.
+   */
+  where?: Prisma.AccountWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Accounts to fetch.
+   */
+  orderBy?: Prisma.AccountOrderByWithRelationInput | Prisma.AccountOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Accounts.
+   */
+  cursor?: Prisma.AccountWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Accounts from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Accounts.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Accounts.
+   */
+  distinct?: Prisma.AccountScalarFieldEnum | Prisma.AccountScalarFieldEnum[]
+}
+
+/**
+ * Account findFirstOrThrow
+ */
+export type AccountFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+  /**
+   * Filter, which Account to fetch.
+   */
+  where?: Prisma.AccountWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Accounts to fetch.
+   */
+  orderBy?: Prisma.AccountOrderByWithRelationInput | Prisma.AccountOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Accounts.
+   */
+  cursor?: Prisma.AccountWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Accounts from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Accounts.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Accounts.
+   */
+  distinct?: Prisma.AccountScalarFieldEnum | Prisma.AccountScalarFieldEnum[]
+}
+
+/**
+ * Account findMany
+ */
+export type AccountFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+  /**
+   * Filter, which Accounts to fetch.
+   */
+  where?: Prisma.AccountWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Accounts to fetch.
+   */
+  orderBy?: Prisma.AccountOrderByWithRelationInput | Prisma.AccountOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing Accounts.
+   */
+  cursor?: Prisma.AccountWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Accounts from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Accounts.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Accounts.
+   */
+  distinct?: Prisma.AccountScalarFieldEnum | Prisma.AccountScalarFieldEnum[]
+}
+
+/**
+ * Account create
+ */
+export type AccountCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+  /**
+   * The data needed to create a Account.
+   */
+  data: Prisma.XOR<Prisma.AccountCreateInput, Prisma.AccountUncheckedCreateInput>
+}
+
+/**
+ * Account createMany
+ */
+export type AccountCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many Accounts.
+   */
+  data: Prisma.AccountCreateManyInput | Prisma.AccountCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * Account createManyAndReturn
+ */
+export type AccountCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * The data used to create many Accounts.
+   */
+  data: Prisma.AccountCreateManyInput | Prisma.AccountCreateManyInput[]
+  skipDuplicates?: boolean
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountIncludeCreateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * Account update
+ */
+export type AccountUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+  /**
+   * The data needed to update a Account.
+   */
+  data: Prisma.XOR<Prisma.AccountUpdateInput, Prisma.AccountUncheckedUpdateInput>
+  /**
+   * Choose, which Account to update.
+   */
+  where: Prisma.AccountWhereUniqueInput
+}
+
+/**
+ * Account updateMany
+ */
+export type AccountUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update Accounts.
+   */
+  data: Prisma.XOR<Prisma.AccountUpdateManyMutationInput, Prisma.AccountUncheckedUpdateManyInput>
+  /**
+   * Filter which Accounts to update
+   */
+  where?: Prisma.AccountWhereInput
+  /**
+   * Limit how many Accounts to update.
+   */
+  limit?: number
+}
+
+/**
+ * Account updateManyAndReturn
+ */
+export type AccountUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * The data used to update Accounts.
+   */
+  data: Prisma.XOR<Prisma.AccountUpdateManyMutationInput, Prisma.AccountUncheckedUpdateManyInput>
+  /**
+   * Filter which Accounts to update
+   */
+  where?: Prisma.AccountWhereInput
+  /**
+   * Limit how many Accounts to update.
+   */
+  limit?: number
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountIncludeUpdateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * Account upsert
+ */
+export type AccountUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+  /**
+   * The filter to search for the Account to update in case it exists.
+   */
+  where: Prisma.AccountWhereUniqueInput
+  /**
+   * In case the Account found by the `where` argument doesn't exist, create a new Account with this data.
+   */
+  create: Prisma.XOR<Prisma.AccountCreateInput, Prisma.AccountUncheckedCreateInput>
+  /**
+   * In case the Account was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.AccountUpdateInput, Prisma.AccountUncheckedUpdateInput>
+}
+
+/**
+ * Account delete
+ */
+export type AccountDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+  /**
+   * Filter which Account to delete.
+   */
+  where: Prisma.AccountWhereUniqueInput
+}
+
+/**
+ * Account deleteMany
+ */
+export type AccountDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Accounts to delete
+   */
+  where?: Prisma.AccountWhereInput
+  /**
+   * Limit how many Accounts to delete.
+   */
+  limit?: number
+}
+
+/**
+ * Account without action
+ */
+export type AccountDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+}
diff --git a/src/generated/client/models/MagicLinkToken.ts b/src/generated/client/models/MagicLinkToken.ts
new file mode 100644
index 00000000..9e3a2234
--- /dev/null
+++ b/src/generated/client/models/MagicLinkToken.ts
@@ -0,0 +1,1254 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `MagicLinkToken` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model MagicLinkToken
+ * 
+ */
+export type MagicLinkTokenModel = runtime.Types.Result.DefaultSelection<Prisma.$MagicLinkTokenPayload>
+
+export type AggregateMagicLinkToken = {
+  _count: MagicLinkTokenCountAggregateOutputType | null
+  _avg: MagicLinkTokenAvgAggregateOutputType | null
+  _sum: MagicLinkTokenSumAggregateOutputType | null
+  _min: MagicLinkTokenMinAggregateOutputType | null
+  _max: MagicLinkTokenMaxAggregateOutputType | null
+}
+
+export type MagicLinkTokenAvgAggregateOutputType = {
+  id: number | null
+}
+
+export type MagicLinkTokenSumAggregateOutputType = {
+  id: number | null
+}
+
+export type MagicLinkTokenMinAggregateOutputType = {
+  id: number | null
+  email: string | null
+  tokenHash: string | null
+  expiresAt: Date | null
+  createdAt: Date | null
+  desktopNonce: string | null
+  inviteToken: string | null
+}
+
+export type MagicLinkTokenMaxAggregateOutputType = {
+  id: number | null
+  email: string | null
+  tokenHash: string | null
+  expiresAt: Date | null
+  createdAt: Date | null
+  desktopNonce: string | null
+  inviteToken: string | null
+}
+
+export type MagicLinkTokenCountAggregateOutputType = {
+  id: number
+  email: number
+  tokenHash: number
+  expiresAt: number
+  createdAt: number
+  desktopNonce: number
+  inviteToken: number
+  _all: number
+}
+
+
+export type MagicLinkTokenAvgAggregateInputType = {
+  id?: true
+}
+
+export type MagicLinkTokenSumAggregateInputType = {
+  id?: true
+}
+
+export type MagicLinkTokenMinAggregateInputType = {
+  id?: true
+  email?: true
+  tokenHash?: true
+  expiresAt?: true
+  createdAt?: true
+  desktopNonce?: true
+  inviteToken?: true
+}
+
+export type MagicLinkTokenMaxAggregateInputType = {
+  id?: true
+  email?: true
+  tokenHash?: true
+  expiresAt?: true
+  createdAt?: true
+  desktopNonce?: true
+  inviteToken?: true
+}
+
+export type MagicLinkTokenCountAggregateInputType = {
+  id?: true
+  email?: true
+  tokenHash?: true
+  expiresAt?: true
+  createdAt?: true
+  desktopNonce?: true
+  inviteToken?: true
+  _all?: true
+}
+
+export type MagicLinkTokenAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which MagicLinkToken to aggregate.
+   */
+  where?: Prisma.MagicLinkTokenWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MagicLinkTokens to fetch.
+   */
+  orderBy?: Prisma.MagicLinkTokenOrderByWithRelationInput | Prisma.MagicLinkTokenOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.MagicLinkTokenWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MagicLinkTokens from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MagicLinkTokens.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned MagicLinkTokens
+  **/
+  _count?: true | MagicLinkTokenCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to average
+  **/
+  _avg?: MagicLinkTokenAvgAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to sum
+  **/
+  _sum?: MagicLinkTokenSumAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: MagicLinkTokenMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: MagicLinkTokenMaxAggregateInputType
+}
+
+export type GetMagicLinkTokenAggregateType<T extends MagicLinkTokenAggregateArgs> = {
+      [P in keyof T & keyof AggregateMagicLinkToken]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateMagicLinkToken[P]>
+    : Prisma.GetScalarType<T[P], AggregateMagicLinkToken[P]>
+}
+
+
+
+
+export type MagicLinkTokenGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.MagicLinkTokenWhereInput
+  orderBy?: Prisma.MagicLinkTokenOrderByWithAggregationInput | Prisma.MagicLinkTokenOrderByWithAggregationInput[]
+  by: Prisma.MagicLinkTokenScalarFieldEnum[] | Prisma.MagicLinkTokenScalarFieldEnum
+  having?: Prisma.MagicLinkTokenScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: MagicLinkTokenCountAggregateInputType | true
+  _avg?: MagicLinkTokenAvgAggregateInputType
+  _sum?: MagicLinkTokenSumAggregateInputType
+  _min?: MagicLinkTokenMinAggregateInputType
+  _max?: MagicLinkTokenMaxAggregateInputType
+}
+
+export type MagicLinkTokenGroupByOutputType = {
+  id: number
+  email: string
+  tokenHash: string
+  expiresAt: Date
+  createdAt: Date
+  desktopNonce: string | null
+  inviteToken: string | null
+  _count: MagicLinkTokenCountAggregateOutputType | null
+  _avg: MagicLinkTokenAvgAggregateOutputType | null
+  _sum: MagicLinkTokenSumAggregateOutputType | null
+  _min: MagicLinkTokenMinAggregateOutputType | null
+  _max: MagicLinkTokenMaxAggregateOutputType | null
+}
+
+export type GetMagicLinkTokenGroupByPayload<T extends MagicLinkTokenGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<MagicLinkTokenGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof MagicLinkTokenGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], MagicLinkTokenGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], MagicLinkTokenGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type MagicLinkTokenWhereInput = {
+  AND?: Prisma.MagicLinkTokenWhereInput | Prisma.MagicLinkTokenWhereInput[]
+  OR?: Prisma.MagicLinkTokenWhereInput[]
+  NOT?: Prisma.MagicLinkTokenWhereInput | Prisma.MagicLinkTokenWhereInput[]
+  id?: Prisma.IntFilter<"MagicLinkToken"> | number
+  email?: Prisma.StringFilter<"MagicLinkToken"> | string
+  tokenHash?: Prisma.StringFilter<"MagicLinkToken"> | string
+  expiresAt?: Prisma.DateTimeFilter<"MagicLinkToken"> | Date | string
+  createdAt?: Prisma.DateTimeFilter<"MagicLinkToken"> | Date | string
+  desktopNonce?: Prisma.StringNullableFilter<"MagicLinkToken"> | string | null
+  inviteToken?: Prisma.StringNullableFilter<"MagicLinkToken"> | string | null
+}
+
+export type MagicLinkTokenOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  tokenHash?: Prisma.SortOrder
+  expiresAt?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  desktopNonce?: Prisma.SortOrderInput | Prisma.SortOrder
+  inviteToken?: Prisma.SortOrderInput | Prisma.SortOrder
+}
+
+export type MagicLinkTokenWhereUniqueInput = Prisma.AtLeast<{
+  id?: number
+  tokenHash?: string
+  AND?: Prisma.MagicLinkTokenWhereInput | Prisma.MagicLinkTokenWhereInput[]
+  OR?: Prisma.MagicLinkTokenWhereInput[]
+  NOT?: Prisma.MagicLinkTokenWhereInput | Prisma.MagicLinkTokenWhereInput[]
+  email?: Prisma.StringFilter<"MagicLinkToken"> | string
+  expiresAt?: Prisma.DateTimeFilter<"MagicLinkToken"> | Date | string
+  createdAt?: Prisma.DateTimeFilter<"MagicLinkToken"> | Date | string
+  desktopNonce?: Prisma.StringNullableFilter<"MagicLinkToken"> | string | null
+  inviteToken?: Prisma.StringNullableFilter<"MagicLinkToken"> | string | null
+}, "id" | "tokenHash">
+
+export type MagicLinkTokenOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  tokenHash?: Prisma.SortOrder
+  expiresAt?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  desktopNonce?: Prisma.SortOrderInput | Prisma.SortOrder
+  inviteToken?: Prisma.SortOrderInput | Prisma.SortOrder
+  _count?: Prisma.MagicLinkTokenCountOrderByAggregateInput
+  _avg?: Prisma.MagicLinkTokenAvgOrderByAggregateInput
+  _max?: Prisma.MagicLinkTokenMaxOrderByAggregateInput
+  _min?: Prisma.MagicLinkTokenMinOrderByAggregateInput
+  _sum?: Prisma.MagicLinkTokenSumOrderByAggregateInput
+}
+
+export type MagicLinkTokenScalarWhereWithAggregatesInput = {
+  AND?: Prisma.MagicLinkTokenScalarWhereWithAggregatesInput | Prisma.MagicLinkTokenScalarWhereWithAggregatesInput[]
+  OR?: Prisma.MagicLinkTokenScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.MagicLinkTokenScalarWhereWithAggregatesInput | Prisma.MagicLinkTokenScalarWhereWithAggregatesInput[]
+  id?: Prisma.IntWithAggregatesFilter<"MagicLinkToken"> | number
+  email?: Prisma.StringWithAggregatesFilter<"MagicLinkToken"> | string
+  tokenHash?: Prisma.StringWithAggregatesFilter<"MagicLinkToken"> | string
+  expiresAt?: Prisma.DateTimeWithAggregatesFilter<"MagicLinkToken"> | Date | string
+  createdAt?: Prisma.DateTimeWithAggregatesFilter<"MagicLinkToken"> | Date | string
+  desktopNonce?: Prisma.StringNullableWithAggregatesFilter<"MagicLinkToken"> | string | null
+  inviteToken?: Prisma.StringNullableWithAggregatesFilter<"MagicLinkToken"> | string | null
+}
+
+export type MagicLinkTokenCreateInput = {
+  email: string
+  tokenHash: string
+  expiresAt: Date | string
+  createdAt?: Date | string
+  desktopNonce?: string | null
+  inviteToken?: string | null
+}
+
+export type MagicLinkTokenUncheckedCreateInput = {
+  id?: number
+  email: string
+  tokenHash: string
+  expiresAt: Date | string
+  createdAt?: Date | string
+  desktopNonce?: string | null
+  inviteToken?: string | null
+}
+
+export type MagicLinkTokenUpdateInput = {
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  tokenHash?: Prisma.StringFieldUpdateOperationsInput | string
+  expiresAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  desktopNonce?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  inviteToken?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type MagicLinkTokenUncheckedUpdateInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  tokenHash?: Prisma.StringFieldUpdateOperationsInput | string
+  expiresAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  desktopNonce?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  inviteToken?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type MagicLinkTokenCreateManyInput = {
+  id?: number
+  email: string
+  tokenHash: string
+  expiresAt: Date | string
+  createdAt?: Date | string
+  desktopNonce?: string | null
+  inviteToken?: string | null
+}
+
+export type MagicLinkTokenUpdateManyMutationInput = {
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  tokenHash?: Prisma.StringFieldUpdateOperationsInput | string
+  expiresAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  desktopNonce?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  inviteToken?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type MagicLinkTokenUncheckedUpdateManyInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  tokenHash?: Prisma.StringFieldUpdateOperationsInput | string
+  expiresAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  desktopNonce?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  inviteToken?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+}
+
+export type MagicLinkTokenCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  tokenHash?: Prisma.SortOrder
+  expiresAt?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  desktopNonce?: Prisma.SortOrder
+  inviteToken?: Prisma.SortOrder
+}
+
+export type MagicLinkTokenAvgOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+}
+
+export type MagicLinkTokenMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  tokenHash?: Prisma.SortOrder
+  expiresAt?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  desktopNonce?: Prisma.SortOrder
+  inviteToken?: Prisma.SortOrder
+}
+
+export type MagicLinkTokenMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  tokenHash?: Prisma.SortOrder
+  expiresAt?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  desktopNonce?: Prisma.SortOrder
+  inviteToken?: Prisma.SortOrder
+}
+
+export type MagicLinkTokenSumOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+}
+
+export type IntFieldUpdateOperationsInput = {
+  set?: number
+  increment?: number
+  decrement?: number
+  multiply?: number
+  divide?: number
+}
+
+
+
+export type MagicLinkTokenSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  email?: boolean
+  tokenHash?: boolean
+  expiresAt?: boolean
+  createdAt?: boolean
+  desktopNonce?: boolean
+  inviteToken?: boolean
+}, ExtArgs["result"]["magicLinkToken"]>
+
+export type MagicLinkTokenSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  email?: boolean
+  tokenHash?: boolean
+  expiresAt?: boolean
+  createdAt?: boolean
+  desktopNonce?: boolean
+  inviteToken?: boolean
+}, ExtArgs["result"]["magicLinkToken"]>
+
+export type MagicLinkTokenSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  email?: boolean
+  tokenHash?: boolean
+  expiresAt?: boolean
+  createdAt?: boolean
+  desktopNonce?: boolean
+  inviteToken?: boolean
+}, ExtArgs["result"]["magicLinkToken"]>
+
+export type MagicLinkTokenSelectScalar = {
+  id?: boolean
+  email?: boolean
+  tokenHash?: boolean
+  expiresAt?: boolean
+  createdAt?: boolean
+  desktopNonce?: boolean
+  inviteToken?: boolean
+}
+
+export type MagicLinkTokenOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "email" | "tokenHash" | "expiresAt" | "createdAt" | "desktopNonce" | "inviteToken", ExtArgs["result"]["magicLinkToken"]>
+
+export type $MagicLinkTokenPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "MagicLinkToken"
+  objects: {}
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: number
+    email: string
+    tokenHash: string
+    expiresAt: Date
+    createdAt: Date
+    desktopNonce: string | null
+    inviteToken: string | null
+  }, ExtArgs["result"]["magicLinkToken"]>
+  composites: {}
+}
+
+export type MagicLinkTokenGetPayload<S extends boolean | null | undefined | MagicLinkTokenDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload, S>
+
+export type MagicLinkTokenCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<MagicLinkTokenFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: MagicLinkTokenCountAggregateInputType | true
+  }
+
+export interface MagicLinkTokenDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['MagicLinkToken'], meta: { name: 'MagicLinkToken' } }
+  /**
+   * Find zero or one MagicLinkToken that matches the filter.
+   * @param {MagicLinkTokenFindUniqueArgs} args - Arguments to find a MagicLinkToken
+   * @example
+   * // Get one MagicLinkToken
+   * const magicLinkToken = await prisma.magicLinkToken.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends MagicLinkTokenFindUniqueArgs>(args: Prisma.SelectSubset<T, MagicLinkTokenFindUniqueArgs<ExtArgs>>): Prisma.Prisma__MagicLinkTokenClient<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one MagicLinkToken that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {MagicLinkTokenFindUniqueOrThrowArgs} args - Arguments to find a MagicLinkToken
+   * @example
+   * // Get one MagicLinkToken
+   * const magicLinkToken = await prisma.magicLinkToken.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends MagicLinkTokenFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, MagicLinkTokenFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__MagicLinkTokenClient<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first MagicLinkToken that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MagicLinkTokenFindFirstArgs} args - Arguments to find a MagicLinkToken
+   * @example
+   * // Get one MagicLinkToken
+   * const magicLinkToken = await prisma.magicLinkToken.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends MagicLinkTokenFindFirstArgs>(args?: Prisma.SelectSubset<T, MagicLinkTokenFindFirstArgs<ExtArgs>>): Prisma.Prisma__MagicLinkTokenClient<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first MagicLinkToken that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MagicLinkTokenFindFirstOrThrowArgs} args - Arguments to find a MagicLinkToken
+   * @example
+   * // Get one MagicLinkToken
+   * const magicLinkToken = await prisma.magicLinkToken.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends MagicLinkTokenFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, MagicLinkTokenFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__MagicLinkTokenClient<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more MagicLinkTokens that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MagicLinkTokenFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all MagicLinkTokens
+   * const magicLinkTokens = await prisma.magicLinkToken.findMany()
+   * 
+   * // Get first 10 MagicLinkTokens
+   * const magicLinkTokens = await prisma.magicLinkToken.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const magicLinkTokenWithIdOnly = await prisma.magicLinkToken.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends MagicLinkTokenFindManyArgs>(args?: Prisma.SelectSubset<T, MagicLinkTokenFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a MagicLinkToken.
+   * @param {MagicLinkTokenCreateArgs} args - Arguments to create a MagicLinkToken.
+   * @example
+   * // Create one MagicLinkToken
+   * const MagicLinkToken = await prisma.magicLinkToken.create({
+   *   data: {
+   *     // ... data to create a MagicLinkToken
+   *   }
+   * })
+   * 
+   */
+  create<T extends MagicLinkTokenCreateArgs>(args: Prisma.SelectSubset<T, MagicLinkTokenCreateArgs<ExtArgs>>): Prisma.Prisma__MagicLinkTokenClient<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many MagicLinkTokens.
+   * @param {MagicLinkTokenCreateManyArgs} args - Arguments to create many MagicLinkTokens.
+   * @example
+   * // Create many MagicLinkTokens
+   * const magicLinkToken = await prisma.magicLinkToken.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends MagicLinkTokenCreateManyArgs>(args?: Prisma.SelectSubset<T, MagicLinkTokenCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many MagicLinkTokens and returns the data saved in the database.
+   * @param {MagicLinkTokenCreateManyAndReturnArgs} args - Arguments to create many MagicLinkTokens.
+   * @example
+   * // Create many MagicLinkTokens
+   * const magicLinkToken = await prisma.magicLinkToken.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many MagicLinkTokens and only return the `id`
+   * const magicLinkTokenWithIdOnly = await prisma.magicLinkToken.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends MagicLinkTokenCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, MagicLinkTokenCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a MagicLinkToken.
+   * @param {MagicLinkTokenDeleteArgs} args - Arguments to delete one MagicLinkToken.
+   * @example
+   * // Delete one MagicLinkToken
+   * const MagicLinkToken = await prisma.magicLinkToken.delete({
+   *   where: {
+   *     // ... filter to delete one MagicLinkToken
+   *   }
+   * })
+   * 
+   */
+  delete<T extends MagicLinkTokenDeleteArgs>(args: Prisma.SelectSubset<T, MagicLinkTokenDeleteArgs<ExtArgs>>): Prisma.Prisma__MagicLinkTokenClient<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one MagicLinkToken.
+   * @param {MagicLinkTokenUpdateArgs} args - Arguments to update one MagicLinkToken.
+   * @example
+   * // Update one MagicLinkToken
+   * const magicLinkToken = await prisma.magicLinkToken.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends MagicLinkTokenUpdateArgs>(args: Prisma.SelectSubset<T, MagicLinkTokenUpdateArgs<ExtArgs>>): Prisma.Prisma__MagicLinkTokenClient<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more MagicLinkTokens.
+   * @param {MagicLinkTokenDeleteManyArgs} args - Arguments to filter MagicLinkTokens to delete.
+   * @example
+   * // Delete a few MagicLinkTokens
+   * const { count } = await prisma.magicLinkToken.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends MagicLinkTokenDeleteManyArgs>(args?: Prisma.SelectSubset<T, MagicLinkTokenDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more MagicLinkTokens.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MagicLinkTokenUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many MagicLinkTokens
+   * const magicLinkToken = await prisma.magicLinkToken.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends MagicLinkTokenUpdateManyArgs>(args: Prisma.SelectSubset<T, MagicLinkTokenUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more MagicLinkTokens and returns the data updated in the database.
+   * @param {MagicLinkTokenUpdateManyAndReturnArgs} args - Arguments to update many MagicLinkTokens.
+   * @example
+   * // Update many MagicLinkTokens
+   * const magicLinkToken = await prisma.magicLinkToken.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more MagicLinkTokens and only return the `id`
+   * const magicLinkTokenWithIdOnly = await prisma.magicLinkToken.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends MagicLinkTokenUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, MagicLinkTokenUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one MagicLinkToken.
+   * @param {MagicLinkTokenUpsertArgs} args - Arguments to update or create a MagicLinkToken.
+   * @example
+   * // Update or create a MagicLinkToken
+   * const magicLinkToken = await prisma.magicLinkToken.upsert({
+   *   create: {
+   *     // ... data to create a MagicLinkToken
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the MagicLinkToken we want to update
+   *   }
+   * })
+   */
+  upsert<T extends MagicLinkTokenUpsertArgs>(args: Prisma.SelectSubset<T, MagicLinkTokenUpsertArgs<ExtArgs>>): Prisma.Prisma__MagicLinkTokenClient<runtime.Types.Result.GetResult<Prisma.$MagicLinkTokenPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of MagicLinkTokens.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MagicLinkTokenCountArgs} args - Arguments to filter MagicLinkTokens to count.
+   * @example
+   * // Count the number of MagicLinkTokens
+   * const count = await prisma.magicLinkToken.count({
+   *   where: {
+   *     // ... the filter for the MagicLinkTokens we want to count
+   *   }
+   * })
+  **/
+  count<T extends MagicLinkTokenCountArgs>(
+    args?: Prisma.Subset<T, MagicLinkTokenCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], MagicLinkTokenCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a MagicLinkToken.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MagicLinkTokenAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends MagicLinkTokenAggregateArgs>(args: Prisma.Subset<T, MagicLinkTokenAggregateArgs>): Prisma.PrismaPromise<GetMagicLinkTokenAggregateType<T>>
+
+  /**
+   * Group by MagicLinkToken.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {MagicLinkTokenGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends MagicLinkTokenGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: MagicLinkTokenGroupByArgs['orderBy'] }
+      : { orderBy?: MagicLinkTokenGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, MagicLinkTokenGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMagicLinkTokenGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the MagicLinkToken model
+ */
+readonly fields: MagicLinkTokenFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for MagicLinkToken.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__MagicLinkTokenClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the MagicLinkToken model
+ */
+export interface MagicLinkTokenFieldRefs {
+  readonly id: Prisma.FieldRef<"MagicLinkToken", 'Int'>
+  readonly email: Prisma.FieldRef<"MagicLinkToken", 'String'>
+  readonly tokenHash: Prisma.FieldRef<"MagicLinkToken", 'String'>
+  readonly expiresAt: Prisma.FieldRef<"MagicLinkToken", 'DateTime'>
+  readonly createdAt: Prisma.FieldRef<"MagicLinkToken", 'DateTime'>
+  readonly desktopNonce: Prisma.FieldRef<"MagicLinkToken", 'String'>
+  readonly inviteToken: Prisma.FieldRef<"MagicLinkToken", 'String'>
+}
+    
+
+// Custom InputTypes
+/**
+ * MagicLinkToken findUnique
+ */
+export type MagicLinkTokenFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * Filter, which MagicLinkToken to fetch.
+   */
+  where: Prisma.MagicLinkTokenWhereUniqueInput
+}
+
+/**
+ * MagicLinkToken findUniqueOrThrow
+ */
+export type MagicLinkTokenFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * Filter, which MagicLinkToken to fetch.
+   */
+  where: Prisma.MagicLinkTokenWhereUniqueInput
+}
+
+/**
+ * MagicLinkToken findFirst
+ */
+export type MagicLinkTokenFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * Filter, which MagicLinkToken to fetch.
+   */
+  where?: Prisma.MagicLinkTokenWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MagicLinkTokens to fetch.
+   */
+  orderBy?: Prisma.MagicLinkTokenOrderByWithRelationInput | Prisma.MagicLinkTokenOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for MagicLinkTokens.
+   */
+  cursor?: Prisma.MagicLinkTokenWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MagicLinkTokens from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MagicLinkTokens.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of MagicLinkTokens.
+   */
+  distinct?: Prisma.MagicLinkTokenScalarFieldEnum | Prisma.MagicLinkTokenScalarFieldEnum[]
+}
+
+/**
+ * MagicLinkToken findFirstOrThrow
+ */
+export type MagicLinkTokenFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * Filter, which MagicLinkToken to fetch.
+   */
+  where?: Prisma.MagicLinkTokenWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MagicLinkTokens to fetch.
+   */
+  orderBy?: Prisma.MagicLinkTokenOrderByWithRelationInput | Prisma.MagicLinkTokenOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for MagicLinkTokens.
+   */
+  cursor?: Prisma.MagicLinkTokenWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MagicLinkTokens from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MagicLinkTokens.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of MagicLinkTokens.
+   */
+  distinct?: Prisma.MagicLinkTokenScalarFieldEnum | Prisma.MagicLinkTokenScalarFieldEnum[]
+}
+
+/**
+ * MagicLinkToken findMany
+ */
+export type MagicLinkTokenFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * Filter, which MagicLinkTokens to fetch.
+   */
+  where?: Prisma.MagicLinkTokenWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of MagicLinkTokens to fetch.
+   */
+  orderBy?: Prisma.MagicLinkTokenOrderByWithRelationInput | Prisma.MagicLinkTokenOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing MagicLinkTokens.
+   */
+  cursor?: Prisma.MagicLinkTokenWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` MagicLinkTokens from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` MagicLinkTokens.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of MagicLinkTokens.
+   */
+  distinct?: Prisma.MagicLinkTokenScalarFieldEnum | Prisma.MagicLinkTokenScalarFieldEnum[]
+}
+
+/**
+ * MagicLinkToken create
+ */
+export type MagicLinkTokenCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * The data needed to create a MagicLinkToken.
+   */
+  data: Prisma.XOR<Prisma.MagicLinkTokenCreateInput, Prisma.MagicLinkTokenUncheckedCreateInput>
+}
+
+/**
+ * MagicLinkToken createMany
+ */
+export type MagicLinkTokenCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many MagicLinkTokens.
+   */
+  data: Prisma.MagicLinkTokenCreateManyInput | Prisma.MagicLinkTokenCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * MagicLinkToken createManyAndReturn
+ */
+export type MagicLinkTokenCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * The data used to create many MagicLinkTokens.
+   */
+  data: Prisma.MagicLinkTokenCreateManyInput | Prisma.MagicLinkTokenCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * MagicLinkToken update
+ */
+export type MagicLinkTokenUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * The data needed to update a MagicLinkToken.
+   */
+  data: Prisma.XOR<Prisma.MagicLinkTokenUpdateInput, Prisma.MagicLinkTokenUncheckedUpdateInput>
+  /**
+   * Choose, which MagicLinkToken to update.
+   */
+  where: Prisma.MagicLinkTokenWhereUniqueInput
+}
+
+/**
+ * MagicLinkToken updateMany
+ */
+export type MagicLinkTokenUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update MagicLinkTokens.
+   */
+  data: Prisma.XOR<Prisma.MagicLinkTokenUpdateManyMutationInput, Prisma.MagicLinkTokenUncheckedUpdateManyInput>
+  /**
+   * Filter which MagicLinkTokens to update
+   */
+  where?: Prisma.MagicLinkTokenWhereInput
+  /**
+   * Limit how many MagicLinkTokens to update.
+   */
+  limit?: number
+}
+
+/**
+ * MagicLinkToken updateManyAndReturn
+ */
+export type MagicLinkTokenUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * The data used to update MagicLinkTokens.
+   */
+  data: Prisma.XOR<Prisma.MagicLinkTokenUpdateManyMutationInput, Prisma.MagicLinkTokenUncheckedUpdateManyInput>
+  /**
+   * Filter which MagicLinkTokens to update
+   */
+  where?: Prisma.MagicLinkTokenWhereInput
+  /**
+   * Limit how many MagicLinkTokens to update.
+   */
+  limit?: number
+}
+
+/**
+ * MagicLinkToken upsert
+ */
+export type MagicLinkTokenUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * The filter to search for the MagicLinkToken to update in case it exists.
+   */
+  where: Prisma.MagicLinkTokenWhereUniqueInput
+  /**
+   * In case the MagicLinkToken found by the `where` argument doesn't exist, create a new MagicLinkToken with this data.
+   */
+  create: Prisma.XOR<Prisma.MagicLinkTokenCreateInput, Prisma.MagicLinkTokenUncheckedCreateInput>
+  /**
+   * In case the MagicLinkToken was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.MagicLinkTokenUpdateInput, Prisma.MagicLinkTokenUncheckedUpdateInput>
+}
+
+/**
+ * MagicLinkToken delete
+ */
+export type MagicLinkTokenDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+  /**
+   * Filter which MagicLinkToken to delete.
+   */
+  where: Prisma.MagicLinkTokenWhereUniqueInput
+}
+
+/**
+ * MagicLinkToken deleteMany
+ */
+export type MagicLinkTokenDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which MagicLinkTokens to delete
+   */
+  where?: Prisma.MagicLinkTokenWhereInput
+  /**
+   * Limit how many MagicLinkTokens to delete.
+   */
+  limit?: number
+}
+
+/**
+ * MagicLinkToken without action
+ */
+export type MagicLinkTokenDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the MagicLinkToken
+   */
+  select?: Prisma.MagicLinkTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the MagicLinkToken
+   */
+  omit?: Prisma.MagicLinkTokenOmit<ExtArgs> | null
+}
diff --git a/src/generated/client/models/Project.ts b/src/generated/client/models/Project.ts
new file mode 100644
index 00000000..5b8fe942
--- /dev/null
+++ b/src/generated/client/models/Project.ts
@@ -0,0 +1,1513 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `Project` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model Project
+ * 
+ */
+export type ProjectModel = runtime.Types.Result.DefaultSelection<Prisma.$ProjectPayload>
+
+export type AggregateProject = {
+  _count: ProjectCountAggregateOutputType | null
+  _min: ProjectMinAggregateOutputType | null
+  _max: ProjectMaxAggregateOutputType | null
+}
+
+export type ProjectMinAggregateOutputType = {
+  id: string | null
+  createdAt: Date | null
+  updatedAt: Date | null
+  title: string | null
+  description: string | null
+  author: string | null
+  hasPoster: boolean | null
+}
+
+export type ProjectMaxAggregateOutputType = {
+  id: string | null
+  createdAt: Date | null
+  updatedAt: Date | null
+  title: string | null
+  description: string | null
+  author: string | null
+  hasPoster: boolean | null
+}
+
+export type ProjectCountAggregateOutputType = {
+  id: number
+  createdAt: number
+  updatedAt: number
+  title: number
+  description: number
+  author: number
+  hasPoster: number
+  _all: number
+}
+
+
+export type ProjectMinAggregateInputType = {
+  id?: true
+  createdAt?: true
+  updatedAt?: true
+  title?: true
+  description?: true
+  author?: true
+  hasPoster?: true
+}
+
+export type ProjectMaxAggregateInputType = {
+  id?: true
+  createdAt?: true
+  updatedAt?: true
+  title?: true
+  description?: true
+  author?: true
+  hasPoster?: true
+}
+
+export type ProjectCountAggregateInputType = {
+  id?: true
+  createdAt?: true
+  updatedAt?: true
+  title?: true
+  description?: true
+  author?: true
+  hasPoster?: true
+  _all?: true
+}
+
+export type ProjectAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Project to aggregate.
+   */
+  where?: Prisma.ProjectWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Projects to fetch.
+   */
+  orderBy?: Prisma.ProjectOrderByWithRelationInput | Prisma.ProjectOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.ProjectWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Projects from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Projects.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned Projects
+  **/
+  _count?: true | ProjectCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: ProjectMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: ProjectMaxAggregateInputType
+}
+
+export type GetProjectAggregateType<T extends ProjectAggregateArgs> = {
+      [P in keyof T & keyof AggregateProject]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateProject[P]>
+    : Prisma.GetScalarType<T[P], AggregateProject[P]>
+}
+
+
+
+
+export type ProjectGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.ProjectWhereInput
+  orderBy?: Prisma.ProjectOrderByWithAggregationInput | Prisma.ProjectOrderByWithAggregationInput[]
+  by: Prisma.ProjectScalarFieldEnum[] | Prisma.ProjectScalarFieldEnum
+  having?: Prisma.ProjectScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: ProjectCountAggregateInputType | true
+  _min?: ProjectMinAggregateInputType
+  _max?: ProjectMaxAggregateInputType
+}
+
+export type ProjectGroupByOutputType = {
+  id: string
+  createdAt: Date
+  updatedAt: Date
+  title: string
+  description: string | null
+  author: string | null
+  hasPoster: boolean
+  _count: ProjectCountAggregateOutputType | null
+  _min: ProjectMinAggregateOutputType | null
+  _max: ProjectMaxAggregateOutputType | null
+}
+
+export type GetProjectGroupByPayload<T extends ProjectGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<ProjectGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof ProjectGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], ProjectGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], ProjectGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type ProjectWhereInput = {
+  AND?: Prisma.ProjectWhereInput | Prisma.ProjectWhereInput[]
+  OR?: Prisma.ProjectWhereInput[]
+  NOT?: Prisma.ProjectWhereInput | Prisma.ProjectWhereInput[]
+  id?: Prisma.StringFilter<"Project"> | string
+  createdAt?: Prisma.DateTimeFilter<"Project"> | Date | string
+  updatedAt?: Prisma.DateTimeFilter<"Project"> | Date | string
+  title?: Prisma.StringFilter<"Project"> | string
+  description?: Prisma.StringNullableFilter<"Project"> | string | null
+  author?: Prisma.StringNullableFilter<"Project"> | string | null
+  hasPoster?: Prisma.BoolFilter<"Project"> | boolean
+  members?: Prisma.ProjectMemberListRelationFilter
+  invitations?: Prisma.ProjectInvitationListRelationFilter
+}
+
+export type ProjectOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+  title?: Prisma.SortOrder
+  description?: Prisma.SortOrderInput | Prisma.SortOrder
+  author?: Prisma.SortOrderInput | Prisma.SortOrder
+  hasPoster?: Prisma.SortOrder
+  members?: Prisma.ProjectMemberOrderByRelationAggregateInput
+  invitations?: Prisma.ProjectInvitationOrderByRelationAggregateInput
+}
+
+export type ProjectWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  AND?: Prisma.ProjectWhereInput | Prisma.ProjectWhereInput[]
+  OR?: Prisma.ProjectWhereInput[]
+  NOT?: Prisma.ProjectWhereInput | Prisma.ProjectWhereInput[]
+  createdAt?: Prisma.DateTimeFilter<"Project"> | Date | string
+  updatedAt?: Prisma.DateTimeFilter<"Project"> | Date | string
+  title?: Prisma.StringFilter<"Project"> | string
+  description?: Prisma.StringNullableFilter<"Project"> | string | null
+  author?: Prisma.StringNullableFilter<"Project"> | string | null
+  hasPoster?: Prisma.BoolFilter<"Project"> | boolean
+  members?: Prisma.ProjectMemberListRelationFilter
+  invitations?: Prisma.ProjectInvitationListRelationFilter
+}, "id">
+
+export type ProjectOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+  title?: Prisma.SortOrder
+  description?: Prisma.SortOrderInput | Prisma.SortOrder
+  author?: Prisma.SortOrderInput | Prisma.SortOrder
+  hasPoster?: Prisma.SortOrder
+  _count?: Prisma.ProjectCountOrderByAggregateInput
+  _max?: Prisma.ProjectMaxOrderByAggregateInput
+  _min?: Prisma.ProjectMinOrderByAggregateInput
+}
+
+export type ProjectScalarWhereWithAggregatesInput = {
+  AND?: Prisma.ProjectScalarWhereWithAggregatesInput | Prisma.ProjectScalarWhereWithAggregatesInput[]
+  OR?: Prisma.ProjectScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.ProjectScalarWhereWithAggregatesInput | Prisma.ProjectScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"Project"> | string
+  createdAt?: Prisma.DateTimeWithAggregatesFilter<"Project"> | Date | string
+  updatedAt?: Prisma.DateTimeWithAggregatesFilter<"Project"> | Date | string
+  title?: Prisma.StringWithAggregatesFilter<"Project"> | string
+  description?: Prisma.StringNullableWithAggregatesFilter<"Project"> | string | null
+  author?: Prisma.StringNullableWithAggregatesFilter<"Project"> | string | null
+  hasPoster?: Prisma.BoolWithAggregatesFilter<"Project"> | boolean
+}
+
+export type ProjectCreateInput = {
+  id?: string
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  title: string
+  description?: string | null
+  author?: string | null
+  hasPoster?: boolean
+  members?: Prisma.ProjectMemberCreateNestedManyWithoutProjectInput
+  invitations?: Prisma.ProjectInvitationCreateNestedManyWithoutProjectInput
+}
+
+export type ProjectUncheckedCreateInput = {
+  id?: string
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  title: string
+  description?: string | null
+  author?: string | null
+  hasPoster?: boolean
+  members?: Prisma.ProjectMemberUncheckedCreateNestedManyWithoutProjectInput
+  invitations?: Prisma.ProjectInvitationUncheckedCreateNestedManyWithoutProjectInput
+}
+
+export type ProjectUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  author?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  hasPoster?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  members?: Prisma.ProjectMemberUpdateManyWithoutProjectNestedInput
+  invitations?: Prisma.ProjectInvitationUpdateManyWithoutProjectNestedInput
+}
+
+export type ProjectUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  author?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  hasPoster?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  members?: Prisma.ProjectMemberUncheckedUpdateManyWithoutProjectNestedInput
+  invitations?: Prisma.ProjectInvitationUncheckedUpdateManyWithoutProjectNestedInput
+}
+
+export type ProjectCreateManyInput = {
+  id?: string
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  title: string
+  description?: string | null
+  author?: string | null
+  hasPoster?: boolean
+}
+
+export type ProjectUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  author?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  hasPoster?: Prisma.BoolFieldUpdateOperationsInput | boolean
+}
+
+export type ProjectUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  author?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  hasPoster?: Prisma.BoolFieldUpdateOperationsInput | boolean
+}
+
+export type ProjectCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+  title?: Prisma.SortOrder
+  description?: Prisma.SortOrder
+  author?: Prisma.SortOrder
+  hasPoster?: Prisma.SortOrder
+}
+
+export type ProjectMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+  title?: Prisma.SortOrder
+  description?: Prisma.SortOrder
+  author?: Prisma.SortOrder
+  hasPoster?: Prisma.SortOrder
+}
+
+export type ProjectMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  updatedAt?: Prisma.SortOrder
+  title?: Prisma.SortOrder
+  description?: Prisma.SortOrder
+  author?: Prisma.SortOrder
+  hasPoster?: Prisma.SortOrder
+}
+
+export type ProjectScalarRelationFilter = {
+  is?: Prisma.ProjectWhereInput
+  isNot?: Prisma.ProjectWhereInput
+}
+
+export type ProjectCreateNestedOneWithoutMembersInput = {
+  create?: Prisma.XOR<Prisma.ProjectCreateWithoutMembersInput, Prisma.ProjectUncheckedCreateWithoutMembersInput>
+  connectOrCreate?: Prisma.ProjectCreateOrConnectWithoutMembersInput
+  connect?: Prisma.ProjectWhereUniqueInput
+}
+
+export type ProjectUpdateOneRequiredWithoutMembersNestedInput = {
+  create?: Prisma.XOR<Prisma.ProjectCreateWithoutMembersInput, Prisma.ProjectUncheckedCreateWithoutMembersInput>
+  connectOrCreate?: Prisma.ProjectCreateOrConnectWithoutMembersInput
+  upsert?: Prisma.ProjectUpsertWithoutMembersInput
+  connect?: Prisma.ProjectWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.ProjectUpdateToOneWithWhereWithoutMembersInput, Prisma.ProjectUpdateWithoutMembersInput>, Prisma.ProjectUncheckedUpdateWithoutMembersInput>
+}
+
+export type ProjectCreateNestedOneWithoutInvitationsInput = {
+  create?: Prisma.XOR<Prisma.ProjectCreateWithoutInvitationsInput, Prisma.ProjectUncheckedCreateWithoutInvitationsInput>
+  connectOrCreate?: Prisma.ProjectCreateOrConnectWithoutInvitationsInput
+  connect?: Prisma.ProjectWhereUniqueInput
+}
+
+export type ProjectUpdateOneRequiredWithoutInvitationsNestedInput = {
+  create?: Prisma.XOR<Prisma.ProjectCreateWithoutInvitationsInput, Prisma.ProjectUncheckedCreateWithoutInvitationsInput>
+  connectOrCreate?: Prisma.ProjectCreateOrConnectWithoutInvitationsInput
+  upsert?: Prisma.ProjectUpsertWithoutInvitationsInput
+  connect?: Prisma.ProjectWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.ProjectUpdateToOneWithWhereWithoutInvitationsInput, Prisma.ProjectUpdateWithoutInvitationsInput>, Prisma.ProjectUncheckedUpdateWithoutInvitationsInput>
+}
+
+export type ProjectCreateWithoutMembersInput = {
+  id?: string
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  title: string
+  description?: string | null
+  author?: string | null
+  hasPoster?: boolean
+  invitations?: Prisma.ProjectInvitationCreateNestedManyWithoutProjectInput
+}
+
+export type ProjectUncheckedCreateWithoutMembersInput = {
+  id?: string
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  title: string
+  description?: string | null
+  author?: string | null
+  hasPoster?: boolean
+  invitations?: Prisma.ProjectInvitationUncheckedCreateNestedManyWithoutProjectInput
+}
+
+export type ProjectCreateOrConnectWithoutMembersInput = {
+  where: Prisma.ProjectWhereUniqueInput
+  create: Prisma.XOR<Prisma.ProjectCreateWithoutMembersInput, Prisma.ProjectUncheckedCreateWithoutMembersInput>
+}
+
+export type ProjectUpsertWithoutMembersInput = {
+  update: Prisma.XOR<Prisma.ProjectUpdateWithoutMembersInput, Prisma.ProjectUncheckedUpdateWithoutMembersInput>
+  create: Prisma.XOR<Prisma.ProjectCreateWithoutMembersInput, Prisma.ProjectUncheckedCreateWithoutMembersInput>
+  where?: Prisma.ProjectWhereInput
+}
+
+export type ProjectUpdateToOneWithWhereWithoutMembersInput = {
+  where?: Prisma.ProjectWhereInput
+  data: Prisma.XOR<Prisma.ProjectUpdateWithoutMembersInput, Prisma.ProjectUncheckedUpdateWithoutMembersInput>
+}
+
+export type ProjectUpdateWithoutMembersInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  author?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  hasPoster?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  invitations?: Prisma.ProjectInvitationUpdateManyWithoutProjectNestedInput
+}
+
+export type ProjectUncheckedUpdateWithoutMembersInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  author?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  hasPoster?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  invitations?: Prisma.ProjectInvitationUncheckedUpdateManyWithoutProjectNestedInput
+}
+
+export type ProjectCreateWithoutInvitationsInput = {
+  id?: string
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  title: string
+  description?: string | null
+  author?: string | null
+  hasPoster?: boolean
+  members?: Prisma.ProjectMemberCreateNestedManyWithoutProjectInput
+}
+
+export type ProjectUncheckedCreateWithoutInvitationsInput = {
+  id?: string
+  createdAt?: Date | string
+  updatedAt?: Date | string
+  title: string
+  description?: string | null
+  author?: string | null
+  hasPoster?: boolean
+  members?: Prisma.ProjectMemberUncheckedCreateNestedManyWithoutProjectInput
+}
+
+export type ProjectCreateOrConnectWithoutInvitationsInput = {
+  where: Prisma.ProjectWhereUniqueInput
+  create: Prisma.XOR<Prisma.ProjectCreateWithoutInvitationsInput, Prisma.ProjectUncheckedCreateWithoutInvitationsInput>
+}
+
+export type ProjectUpsertWithoutInvitationsInput = {
+  update: Prisma.XOR<Prisma.ProjectUpdateWithoutInvitationsInput, Prisma.ProjectUncheckedUpdateWithoutInvitationsInput>
+  create: Prisma.XOR<Prisma.ProjectCreateWithoutInvitationsInput, Prisma.ProjectUncheckedCreateWithoutInvitationsInput>
+  where?: Prisma.ProjectWhereInput
+}
+
+export type ProjectUpdateToOneWithWhereWithoutInvitationsInput = {
+  where?: Prisma.ProjectWhereInput
+  data: Prisma.XOR<Prisma.ProjectUpdateWithoutInvitationsInput, Prisma.ProjectUncheckedUpdateWithoutInvitationsInput>
+}
+
+export type ProjectUpdateWithoutInvitationsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  author?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  hasPoster?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  members?: Prisma.ProjectMemberUpdateManyWithoutProjectNestedInput
+}
+
+export type ProjectUncheckedUpdateWithoutInvitationsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  title?: Prisma.StringFieldUpdateOperationsInput | string
+  description?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  author?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  hasPoster?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  members?: Prisma.ProjectMemberUncheckedUpdateManyWithoutProjectNestedInput
+}
+
+
+/**
+ * Count Type ProjectCountOutputType
+ */
+
+export type ProjectCountOutputType = {
+  members: number
+  invitations: number
+}
+
+export type ProjectCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  members?: boolean | ProjectCountOutputTypeCountMembersArgs
+  invitations?: boolean | ProjectCountOutputTypeCountInvitationsArgs
+}
+
+/**
+ * ProjectCountOutputType without action
+ */
+export type ProjectCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectCountOutputType
+   */
+  select?: Prisma.ProjectCountOutputTypeSelect<ExtArgs> | null
+}
+
+/**
+ * ProjectCountOutputType without action
+ */
+export type ProjectCountOutputTypeCountMembersArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.ProjectMemberWhereInput
+}
+
+/**
+ * ProjectCountOutputType without action
+ */
+export type ProjectCountOutputTypeCountInvitationsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.ProjectInvitationWhereInput
+}
+
+
+export type ProjectSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+  title?: boolean
+  description?: boolean
+  author?: boolean
+  hasPoster?: boolean
+  members?: boolean | Prisma.Project$membersArgs<ExtArgs>
+  invitations?: boolean | Prisma.Project$invitationsArgs<ExtArgs>
+  _count?: boolean | Prisma.ProjectCountOutputTypeDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["project"]>
+
+export type ProjectSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+  title?: boolean
+  description?: boolean
+  author?: boolean
+  hasPoster?: boolean
+}, ExtArgs["result"]["project"]>
+
+export type ProjectSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+  title?: boolean
+  description?: boolean
+  author?: boolean
+  hasPoster?: boolean
+}, ExtArgs["result"]["project"]>
+
+export type ProjectSelectScalar = {
+  id?: boolean
+  createdAt?: boolean
+  updatedAt?: boolean
+  title?: boolean
+  description?: boolean
+  author?: boolean
+  hasPoster?: boolean
+}
+
+export type ProjectOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "createdAt" | "updatedAt" | "title" | "description" | "author" | "hasPoster", ExtArgs["result"]["project"]>
+export type ProjectInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  members?: boolean | Prisma.Project$membersArgs<ExtArgs>
+  invitations?: boolean | Prisma.Project$invitationsArgs<ExtArgs>
+  _count?: boolean | Prisma.ProjectCountOutputTypeDefaultArgs<ExtArgs>
+}
+export type ProjectIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
+export type ProjectIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
+
+export type $ProjectPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "Project"
+  objects: {
+    members: Prisma.$ProjectMemberPayload<ExtArgs>[]
+    invitations: Prisma.$ProjectInvitationPayload<ExtArgs>[]
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    createdAt: Date
+    updatedAt: Date
+    title: string
+    description: string | null
+    author: string | null
+    hasPoster: boolean
+  }, ExtArgs["result"]["project"]>
+  composites: {}
+}
+
+export type ProjectGetPayload<S extends boolean | null | undefined | ProjectDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$ProjectPayload, S>
+
+export type ProjectCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<ProjectFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: ProjectCountAggregateInputType | true
+  }
+
+export interface ProjectDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Project'], meta: { name: 'Project' } }
+  /**
+   * Find zero or one Project that matches the filter.
+   * @param {ProjectFindUniqueArgs} args - Arguments to find a Project
+   * @example
+   * // Get one Project
+   * const project = await prisma.project.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends ProjectFindUniqueArgs>(args: Prisma.SelectSubset<T, ProjectFindUniqueArgs<ExtArgs>>): Prisma.Prisma__ProjectClient<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one Project that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {ProjectFindUniqueOrThrowArgs} args - Arguments to find a Project
+   * @example
+   * // Get one Project
+   * const project = await prisma.project.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends ProjectFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, ProjectFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__ProjectClient<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Project that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectFindFirstArgs} args - Arguments to find a Project
+   * @example
+   * // Get one Project
+   * const project = await prisma.project.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends ProjectFindFirstArgs>(args?: Prisma.SelectSubset<T, ProjectFindFirstArgs<ExtArgs>>): Prisma.Prisma__ProjectClient<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Project that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectFindFirstOrThrowArgs} args - Arguments to find a Project
+   * @example
+   * // Get one Project
+   * const project = await prisma.project.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends ProjectFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, ProjectFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__ProjectClient<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more Projects that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all Projects
+   * const projects = await prisma.project.findMany()
+   * 
+   * // Get first 10 Projects
+   * const projects = await prisma.project.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const projectWithIdOnly = await prisma.project.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends ProjectFindManyArgs>(args?: Prisma.SelectSubset<T, ProjectFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a Project.
+   * @param {ProjectCreateArgs} args - Arguments to create a Project.
+   * @example
+   * // Create one Project
+   * const Project = await prisma.project.create({
+   *   data: {
+   *     // ... data to create a Project
+   *   }
+   * })
+   * 
+   */
+  create<T extends ProjectCreateArgs>(args: Prisma.SelectSubset<T, ProjectCreateArgs<ExtArgs>>): Prisma.Prisma__ProjectClient<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many Projects.
+   * @param {ProjectCreateManyArgs} args - Arguments to create many Projects.
+   * @example
+   * // Create many Projects
+   * const project = await prisma.project.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends ProjectCreateManyArgs>(args?: Prisma.SelectSubset<T, ProjectCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many Projects and returns the data saved in the database.
+   * @param {ProjectCreateManyAndReturnArgs} args - Arguments to create many Projects.
+   * @example
+   * // Create many Projects
+   * const project = await prisma.project.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many Projects and only return the `id`
+   * const projectWithIdOnly = await prisma.project.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends ProjectCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, ProjectCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a Project.
+   * @param {ProjectDeleteArgs} args - Arguments to delete one Project.
+   * @example
+   * // Delete one Project
+   * const Project = await prisma.project.delete({
+   *   where: {
+   *     // ... filter to delete one Project
+   *   }
+   * })
+   * 
+   */
+  delete<T extends ProjectDeleteArgs>(args: Prisma.SelectSubset<T, ProjectDeleteArgs<ExtArgs>>): Prisma.Prisma__ProjectClient<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one Project.
+   * @param {ProjectUpdateArgs} args - Arguments to update one Project.
+   * @example
+   * // Update one Project
+   * const project = await prisma.project.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends ProjectUpdateArgs>(args: Prisma.SelectSubset<T, ProjectUpdateArgs<ExtArgs>>): Prisma.Prisma__ProjectClient<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more Projects.
+   * @param {ProjectDeleteManyArgs} args - Arguments to filter Projects to delete.
+   * @example
+   * // Delete a few Projects
+   * const { count } = await prisma.project.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends ProjectDeleteManyArgs>(args?: Prisma.SelectSubset<T, ProjectDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Projects.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many Projects
+   * const project = await prisma.project.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends ProjectUpdateManyArgs>(args: Prisma.SelectSubset<T, ProjectUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Projects and returns the data updated in the database.
+   * @param {ProjectUpdateManyAndReturnArgs} args - Arguments to update many Projects.
+   * @example
+   * // Update many Projects
+   * const project = await prisma.project.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more Projects and only return the `id`
+   * const projectWithIdOnly = await prisma.project.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends ProjectUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, ProjectUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one Project.
+   * @param {ProjectUpsertArgs} args - Arguments to update or create a Project.
+   * @example
+   * // Update or create a Project
+   * const project = await prisma.project.upsert({
+   *   create: {
+   *     // ... data to create a Project
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the Project we want to update
+   *   }
+   * })
+   */
+  upsert<T extends ProjectUpsertArgs>(args: Prisma.SelectSubset<T, ProjectUpsertArgs<ExtArgs>>): Prisma.Prisma__ProjectClient<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of Projects.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectCountArgs} args - Arguments to filter Projects to count.
+   * @example
+   * // Count the number of Projects
+   * const count = await prisma.project.count({
+   *   where: {
+   *     // ... the filter for the Projects we want to count
+   *   }
+   * })
+  **/
+  count<T extends ProjectCountArgs>(
+    args?: Prisma.Subset<T, ProjectCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], ProjectCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a Project.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends ProjectAggregateArgs>(args: Prisma.Subset<T, ProjectAggregateArgs>): Prisma.PrismaPromise<GetProjectAggregateType<T>>
+
+  /**
+   * Group by Project.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends ProjectGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: ProjectGroupByArgs['orderBy'] }
+      : { orderBy?: ProjectGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, ProjectGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetProjectGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the Project model
+ */
+readonly fields: ProjectFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for Project.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__ProjectClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  members<T extends Prisma.Project$membersArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Project$membersArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  invitations<T extends Prisma.Project$invitationsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.Project$invitationsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the Project model
+ */
+export interface ProjectFieldRefs {
+  readonly id: Prisma.FieldRef<"Project", 'String'>
+  readonly createdAt: Prisma.FieldRef<"Project", 'DateTime'>
+  readonly updatedAt: Prisma.FieldRef<"Project", 'DateTime'>
+  readonly title: Prisma.FieldRef<"Project", 'String'>
+  readonly description: Prisma.FieldRef<"Project", 'String'>
+  readonly author: Prisma.FieldRef<"Project", 'String'>
+  readonly hasPoster: Prisma.FieldRef<"Project", 'Boolean'>
+}
+    
+
+// Custom InputTypes
+/**
+ * Project findUnique
+ */
+export type ProjectFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInclude<ExtArgs> | null
+  /**
+   * Filter, which Project to fetch.
+   */
+  where: Prisma.ProjectWhereUniqueInput
+}
+
+/**
+ * Project findUniqueOrThrow
+ */
+export type ProjectFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInclude<ExtArgs> | null
+  /**
+   * Filter, which Project to fetch.
+   */
+  where: Prisma.ProjectWhereUniqueInput
+}
+
+/**
+ * Project findFirst
+ */
+export type ProjectFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInclude<ExtArgs> | null
+  /**
+   * Filter, which Project to fetch.
+   */
+  where?: Prisma.ProjectWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Projects to fetch.
+   */
+  orderBy?: Prisma.ProjectOrderByWithRelationInput | Prisma.ProjectOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Projects.
+   */
+  cursor?: Prisma.ProjectWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Projects from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Projects.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Projects.
+   */
+  distinct?: Prisma.ProjectScalarFieldEnum | Prisma.ProjectScalarFieldEnum[]
+}
+
+/**
+ * Project findFirstOrThrow
+ */
+export type ProjectFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInclude<ExtArgs> | null
+  /**
+   * Filter, which Project to fetch.
+   */
+  where?: Prisma.ProjectWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Projects to fetch.
+   */
+  orderBy?: Prisma.ProjectOrderByWithRelationInput | Prisma.ProjectOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Projects.
+   */
+  cursor?: Prisma.ProjectWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Projects from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Projects.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Projects.
+   */
+  distinct?: Prisma.ProjectScalarFieldEnum | Prisma.ProjectScalarFieldEnum[]
+}
+
+/**
+ * Project findMany
+ */
+export type ProjectFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInclude<ExtArgs> | null
+  /**
+   * Filter, which Projects to fetch.
+   */
+  where?: Prisma.ProjectWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Projects to fetch.
+   */
+  orderBy?: Prisma.ProjectOrderByWithRelationInput | Prisma.ProjectOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing Projects.
+   */
+  cursor?: Prisma.ProjectWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Projects from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Projects.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Projects.
+   */
+  distinct?: Prisma.ProjectScalarFieldEnum | Prisma.ProjectScalarFieldEnum[]
+}
+
+/**
+ * Project create
+ */
+export type ProjectCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInclude<ExtArgs> | null
+  /**
+   * The data needed to create a Project.
+   */
+  data: Prisma.XOR<Prisma.ProjectCreateInput, Prisma.ProjectUncheckedCreateInput>
+}
+
+/**
+ * Project createMany
+ */
+export type ProjectCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many Projects.
+   */
+  data: Prisma.ProjectCreateManyInput | Prisma.ProjectCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * Project createManyAndReturn
+ */
+export type ProjectCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * The data used to create many Projects.
+   */
+  data: Prisma.ProjectCreateManyInput | Prisma.ProjectCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * Project update
+ */
+export type ProjectUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInclude<ExtArgs> | null
+  /**
+   * The data needed to update a Project.
+   */
+  data: Prisma.XOR<Prisma.ProjectUpdateInput, Prisma.ProjectUncheckedUpdateInput>
+  /**
+   * Choose, which Project to update.
+   */
+  where: Prisma.ProjectWhereUniqueInput
+}
+
+/**
+ * Project updateMany
+ */
+export type ProjectUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update Projects.
+   */
+  data: Prisma.XOR<Prisma.ProjectUpdateManyMutationInput, Prisma.ProjectUncheckedUpdateManyInput>
+  /**
+   * Filter which Projects to update
+   */
+  where?: Prisma.ProjectWhereInput
+  /**
+   * Limit how many Projects to update.
+   */
+  limit?: number
+}
+
+/**
+ * Project updateManyAndReturn
+ */
+export type ProjectUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * The data used to update Projects.
+   */
+  data: Prisma.XOR<Prisma.ProjectUpdateManyMutationInput, Prisma.ProjectUncheckedUpdateManyInput>
+  /**
+   * Filter which Projects to update
+   */
+  where?: Prisma.ProjectWhereInput
+  /**
+   * Limit how many Projects to update.
+   */
+  limit?: number
+}
+
+/**
+ * Project upsert
+ */
+export type ProjectUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInclude<ExtArgs> | null
+  /**
+   * The filter to search for the Project to update in case it exists.
+   */
+  where: Prisma.ProjectWhereUniqueInput
+  /**
+   * In case the Project found by the `where` argument doesn't exist, create a new Project with this data.
+   */
+  create: Prisma.XOR<Prisma.ProjectCreateInput, Prisma.ProjectUncheckedCreateInput>
+  /**
+   * In case the Project was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.ProjectUpdateInput, Prisma.ProjectUncheckedUpdateInput>
+}
+
+/**
+ * Project delete
+ */
+export type ProjectDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInclude<ExtArgs> | null
+  /**
+   * Filter which Project to delete.
+   */
+  where: Prisma.ProjectWhereUniqueInput
+}
+
+/**
+ * Project deleteMany
+ */
+export type ProjectDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Projects to delete
+   */
+  where?: Prisma.ProjectWhereInput
+  /**
+   * Limit how many Projects to delete.
+   */
+  limit?: number
+}
+
+/**
+ * Project.members
+ */
+export type Project$membersArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  where?: Prisma.ProjectMemberWhereInput
+  orderBy?: Prisma.ProjectMemberOrderByWithRelationInput | Prisma.ProjectMemberOrderByWithRelationInput[]
+  cursor?: Prisma.ProjectMemberWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.ProjectMemberScalarFieldEnum | Prisma.ProjectMemberScalarFieldEnum[]
+}
+
+/**
+ * Project.invitations
+ */
+export type Project$invitationsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+  where?: Prisma.ProjectInvitationWhereInput
+  orderBy?: Prisma.ProjectInvitationOrderByWithRelationInput | Prisma.ProjectInvitationOrderByWithRelationInput[]
+  cursor?: Prisma.ProjectInvitationWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.ProjectInvitationScalarFieldEnum | Prisma.ProjectInvitationScalarFieldEnum[]
+}
+
+/**
+ * Project without action
+ */
+export type ProjectDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Project
+   */
+  select?: Prisma.ProjectSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Project
+   */
+  omit?: Prisma.ProjectOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInclude<ExtArgs> | null
+}
diff --git a/src/generated/client/models/ProjectInvitation.ts b/src/generated/client/models/ProjectInvitation.ts
new file mode 100644
index 00000000..3d15a96d
--- /dev/null
+++ b/src/generated/client/models/ProjectInvitation.ts
@@ -0,0 +1,1390 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `ProjectInvitation` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model ProjectInvitation
+ * 
+ */
+export type ProjectInvitationModel = runtime.Types.Result.DefaultSelection<Prisma.$ProjectInvitationPayload>
+
+export type AggregateProjectInvitation = {
+  _count: ProjectInvitationCountAggregateOutputType | null
+  _avg: ProjectInvitationAvgAggregateOutputType | null
+  _sum: ProjectInvitationSumAggregateOutputType | null
+  _min: ProjectInvitationMinAggregateOutputType | null
+  _max: ProjectInvitationMaxAggregateOutputType | null
+}
+
+export type ProjectInvitationAvgAggregateOutputType = {
+  id: number | null
+}
+
+export type ProjectInvitationSumAggregateOutputType = {
+  id: number | null
+}
+
+export type ProjectInvitationMinAggregateOutputType = {
+  id: number | null
+  token: string | null
+  email: string | null
+  createdAt: Date | null
+  projectId: string | null
+}
+
+export type ProjectInvitationMaxAggregateOutputType = {
+  id: number | null
+  token: string | null
+  email: string | null
+  createdAt: Date | null
+  projectId: string | null
+}
+
+export type ProjectInvitationCountAggregateOutputType = {
+  id: number
+  token: number
+  email: number
+  createdAt: number
+  projectId: number
+  _all: number
+}
+
+
+export type ProjectInvitationAvgAggregateInputType = {
+  id?: true
+}
+
+export type ProjectInvitationSumAggregateInputType = {
+  id?: true
+}
+
+export type ProjectInvitationMinAggregateInputType = {
+  id?: true
+  token?: true
+  email?: true
+  createdAt?: true
+  projectId?: true
+}
+
+export type ProjectInvitationMaxAggregateInputType = {
+  id?: true
+  token?: true
+  email?: true
+  createdAt?: true
+  projectId?: true
+}
+
+export type ProjectInvitationCountAggregateInputType = {
+  id?: true
+  token?: true
+  email?: true
+  createdAt?: true
+  projectId?: true
+  _all?: true
+}
+
+export type ProjectInvitationAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which ProjectInvitation to aggregate.
+   */
+  where?: Prisma.ProjectInvitationWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of ProjectInvitations to fetch.
+   */
+  orderBy?: Prisma.ProjectInvitationOrderByWithRelationInput | Prisma.ProjectInvitationOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.ProjectInvitationWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` ProjectInvitations from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` ProjectInvitations.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned ProjectInvitations
+  **/
+  _count?: true | ProjectInvitationCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to average
+  **/
+  _avg?: ProjectInvitationAvgAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to sum
+  **/
+  _sum?: ProjectInvitationSumAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: ProjectInvitationMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: ProjectInvitationMaxAggregateInputType
+}
+
+export type GetProjectInvitationAggregateType<T extends ProjectInvitationAggregateArgs> = {
+      [P in keyof T & keyof AggregateProjectInvitation]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateProjectInvitation[P]>
+    : Prisma.GetScalarType<T[P], AggregateProjectInvitation[P]>
+}
+
+
+
+
+export type ProjectInvitationGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.ProjectInvitationWhereInput
+  orderBy?: Prisma.ProjectInvitationOrderByWithAggregationInput | Prisma.ProjectInvitationOrderByWithAggregationInput[]
+  by: Prisma.ProjectInvitationScalarFieldEnum[] | Prisma.ProjectInvitationScalarFieldEnum
+  having?: Prisma.ProjectInvitationScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: ProjectInvitationCountAggregateInputType | true
+  _avg?: ProjectInvitationAvgAggregateInputType
+  _sum?: ProjectInvitationSumAggregateInputType
+  _min?: ProjectInvitationMinAggregateInputType
+  _max?: ProjectInvitationMaxAggregateInputType
+}
+
+export type ProjectInvitationGroupByOutputType = {
+  id: number
+  token: string
+  email: string
+  createdAt: Date
+  projectId: string
+  _count: ProjectInvitationCountAggregateOutputType | null
+  _avg: ProjectInvitationAvgAggregateOutputType | null
+  _sum: ProjectInvitationSumAggregateOutputType | null
+  _min: ProjectInvitationMinAggregateOutputType | null
+  _max: ProjectInvitationMaxAggregateOutputType | null
+}
+
+export type GetProjectInvitationGroupByPayload<T extends ProjectInvitationGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<ProjectInvitationGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof ProjectInvitationGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], ProjectInvitationGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], ProjectInvitationGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type ProjectInvitationWhereInput = {
+  AND?: Prisma.ProjectInvitationWhereInput | Prisma.ProjectInvitationWhereInput[]
+  OR?: Prisma.ProjectInvitationWhereInput[]
+  NOT?: Prisma.ProjectInvitationWhereInput | Prisma.ProjectInvitationWhereInput[]
+  id?: Prisma.IntFilter<"ProjectInvitation"> | number
+  token?: Prisma.StringFilter<"ProjectInvitation"> | string
+  email?: Prisma.StringFilter<"ProjectInvitation"> | string
+  createdAt?: Prisma.DateTimeFilter<"ProjectInvitation"> | Date | string
+  projectId?: Prisma.StringFilter<"ProjectInvitation"> | string
+  project?: Prisma.XOR<Prisma.ProjectScalarRelationFilter, Prisma.ProjectWhereInput>
+}
+
+export type ProjectInvitationOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  token?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  projectId?: Prisma.SortOrder
+  project?: Prisma.ProjectOrderByWithRelationInput
+}
+
+export type ProjectInvitationWhereUniqueInput = Prisma.AtLeast<{
+  id?: number
+  token?: string
+  email_projectId?: Prisma.ProjectInvitationEmailProjectIdCompoundUniqueInput
+  AND?: Prisma.ProjectInvitationWhereInput | Prisma.ProjectInvitationWhereInput[]
+  OR?: Prisma.ProjectInvitationWhereInput[]
+  NOT?: Prisma.ProjectInvitationWhereInput | Prisma.ProjectInvitationWhereInput[]
+  email?: Prisma.StringFilter<"ProjectInvitation"> | string
+  createdAt?: Prisma.DateTimeFilter<"ProjectInvitation"> | Date | string
+  projectId?: Prisma.StringFilter<"ProjectInvitation"> | string
+  project?: Prisma.XOR<Prisma.ProjectScalarRelationFilter, Prisma.ProjectWhereInput>
+}, "id" | "token" | "email_projectId">
+
+export type ProjectInvitationOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  token?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  projectId?: Prisma.SortOrder
+  _count?: Prisma.ProjectInvitationCountOrderByAggregateInput
+  _avg?: Prisma.ProjectInvitationAvgOrderByAggregateInput
+  _max?: Prisma.ProjectInvitationMaxOrderByAggregateInput
+  _min?: Prisma.ProjectInvitationMinOrderByAggregateInput
+  _sum?: Prisma.ProjectInvitationSumOrderByAggregateInput
+}
+
+export type ProjectInvitationScalarWhereWithAggregatesInput = {
+  AND?: Prisma.ProjectInvitationScalarWhereWithAggregatesInput | Prisma.ProjectInvitationScalarWhereWithAggregatesInput[]
+  OR?: Prisma.ProjectInvitationScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.ProjectInvitationScalarWhereWithAggregatesInput | Prisma.ProjectInvitationScalarWhereWithAggregatesInput[]
+  id?: Prisma.IntWithAggregatesFilter<"ProjectInvitation"> | number
+  token?: Prisma.StringWithAggregatesFilter<"ProjectInvitation"> | string
+  email?: Prisma.StringWithAggregatesFilter<"ProjectInvitation"> | string
+  createdAt?: Prisma.DateTimeWithAggregatesFilter<"ProjectInvitation"> | Date | string
+  projectId?: Prisma.StringWithAggregatesFilter<"ProjectInvitation"> | string
+}
+
+export type ProjectInvitationCreateInput = {
+  token: string
+  email: string
+  createdAt?: Date | string
+  project: Prisma.ProjectCreateNestedOneWithoutInvitationsInput
+}
+
+export type ProjectInvitationUncheckedCreateInput = {
+  id?: number
+  token: string
+  email: string
+  createdAt?: Date | string
+  projectId: string
+}
+
+export type ProjectInvitationUpdateInput = {
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  project?: Prisma.ProjectUpdateOneRequiredWithoutInvitationsNestedInput
+}
+
+export type ProjectInvitationUncheckedUpdateInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  projectId?: Prisma.StringFieldUpdateOperationsInput | string
+}
+
+export type ProjectInvitationCreateManyInput = {
+  id?: number
+  token: string
+  email: string
+  createdAt?: Date | string
+  projectId: string
+}
+
+export type ProjectInvitationUpdateManyMutationInput = {
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type ProjectInvitationUncheckedUpdateManyInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  projectId?: Prisma.StringFieldUpdateOperationsInput | string
+}
+
+export type ProjectInvitationListRelationFilter = {
+  every?: Prisma.ProjectInvitationWhereInput
+  some?: Prisma.ProjectInvitationWhereInput
+  none?: Prisma.ProjectInvitationWhereInput
+}
+
+export type ProjectInvitationOrderByRelationAggregateInput = {
+  _count?: Prisma.SortOrder
+}
+
+export type ProjectInvitationEmailProjectIdCompoundUniqueInput = {
+  email: string
+  projectId: string
+}
+
+export type ProjectInvitationCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  token?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  projectId?: Prisma.SortOrder
+}
+
+export type ProjectInvitationAvgOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+}
+
+export type ProjectInvitationMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  token?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  projectId?: Prisma.SortOrder
+}
+
+export type ProjectInvitationMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  token?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  projectId?: Prisma.SortOrder
+}
+
+export type ProjectInvitationSumOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+}
+
+export type ProjectInvitationCreateNestedManyWithoutProjectInput = {
+  create?: Prisma.XOR<Prisma.ProjectInvitationCreateWithoutProjectInput, Prisma.ProjectInvitationUncheckedCreateWithoutProjectInput> | Prisma.ProjectInvitationCreateWithoutProjectInput[] | Prisma.ProjectInvitationUncheckedCreateWithoutProjectInput[]
+  connectOrCreate?: Prisma.ProjectInvitationCreateOrConnectWithoutProjectInput | Prisma.ProjectInvitationCreateOrConnectWithoutProjectInput[]
+  createMany?: Prisma.ProjectInvitationCreateManyProjectInputEnvelope
+  connect?: Prisma.ProjectInvitationWhereUniqueInput | Prisma.ProjectInvitationWhereUniqueInput[]
+}
+
+export type ProjectInvitationUncheckedCreateNestedManyWithoutProjectInput = {
+  create?: Prisma.XOR<Prisma.ProjectInvitationCreateWithoutProjectInput, Prisma.ProjectInvitationUncheckedCreateWithoutProjectInput> | Prisma.ProjectInvitationCreateWithoutProjectInput[] | Prisma.ProjectInvitationUncheckedCreateWithoutProjectInput[]
+  connectOrCreate?: Prisma.ProjectInvitationCreateOrConnectWithoutProjectInput | Prisma.ProjectInvitationCreateOrConnectWithoutProjectInput[]
+  createMany?: Prisma.ProjectInvitationCreateManyProjectInputEnvelope
+  connect?: Prisma.ProjectInvitationWhereUniqueInput | Prisma.ProjectInvitationWhereUniqueInput[]
+}
+
+export type ProjectInvitationUpdateManyWithoutProjectNestedInput = {
+  create?: Prisma.XOR<Prisma.ProjectInvitationCreateWithoutProjectInput, Prisma.ProjectInvitationUncheckedCreateWithoutProjectInput> | Prisma.ProjectInvitationCreateWithoutProjectInput[] | Prisma.ProjectInvitationUncheckedCreateWithoutProjectInput[]
+  connectOrCreate?: Prisma.ProjectInvitationCreateOrConnectWithoutProjectInput | Prisma.ProjectInvitationCreateOrConnectWithoutProjectInput[]
+  upsert?: Prisma.ProjectInvitationUpsertWithWhereUniqueWithoutProjectInput | Prisma.ProjectInvitationUpsertWithWhereUniqueWithoutProjectInput[]
+  createMany?: Prisma.ProjectInvitationCreateManyProjectInputEnvelope
+  set?: Prisma.ProjectInvitationWhereUniqueInput | Prisma.ProjectInvitationWhereUniqueInput[]
+  disconnect?: Prisma.ProjectInvitationWhereUniqueInput | Prisma.ProjectInvitationWhereUniqueInput[]
+  delete?: Prisma.ProjectInvitationWhereUniqueInput | Prisma.ProjectInvitationWhereUniqueInput[]
+  connect?: Prisma.ProjectInvitationWhereUniqueInput | Prisma.ProjectInvitationWhereUniqueInput[]
+  update?: Prisma.ProjectInvitationUpdateWithWhereUniqueWithoutProjectInput | Prisma.ProjectInvitationUpdateWithWhereUniqueWithoutProjectInput[]
+  updateMany?: Prisma.ProjectInvitationUpdateManyWithWhereWithoutProjectInput | Prisma.ProjectInvitationUpdateManyWithWhereWithoutProjectInput[]
+  deleteMany?: Prisma.ProjectInvitationScalarWhereInput | Prisma.ProjectInvitationScalarWhereInput[]
+}
+
+export type ProjectInvitationUncheckedUpdateManyWithoutProjectNestedInput = {
+  create?: Prisma.XOR<Prisma.ProjectInvitationCreateWithoutProjectInput, Prisma.ProjectInvitationUncheckedCreateWithoutProjectInput> | Prisma.ProjectInvitationCreateWithoutProjectInput[] | Prisma.ProjectInvitationUncheckedCreateWithoutProjectInput[]
+  connectOrCreate?: Prisma.ProjectInvitationCreateOrConnectWithoutProjectInput | Prisma.ProjectInvitationCreateOrConnectWithoutProjectInput[]
+  upsert?: Prisma.ProjectInvitationUpsertWithWhereUniqueWithoutProjectInput | Prisma.ProjectInvitationUpsertWithWhereUniqueWithoutProjectInput[]
+  createMany?: Prisma.ProjectInvitationCreateManyProjectInputEnvelope
+  set?: Prisma.ProjectInvitationWhereUniqueInput | Prisma.ProjectInvitationWhereUniqueInput[]
+  disconnect?: Prisma.ProjectInvitationWhereUniqueInput | Prisma.ProjectInvitationWhereUniqueInput[]
+  delete?: Prisma.ProjectInvitationWhereUniqueInput | Prisma.ProjectInvitationWhereUniqueInput[]
+  connect?: Prisma.ProjectInvitationWhereUniqueInput | Prisma.ProjectInvitationWhereUniqueInput[]
+  update?: Prisma.ProjectInvitationUpdateWithWhereUniqueWithoutProjectInput | Prisma.ProjectInvitationUpdateWithWhereUniqueWithoutProjectInput[]
+  updateMany?: Prisma.ProjectInvitationUpdateManyWithWhereWithoutProjectInput | Prisma.ProjectInvitationUpdateManyWithWhereWithoutProjectInput[]
+  deleteMany?: Prisma.ProjectInvitationScalarWhereInput | Prisma.ProjectInvitationScalarWhereInput[]
+}
+
+export type ProjectInvitationCreateWithoutProjectInput = {
+  token: string
+  email: string
+  createdAt?: Date | string
+}
+
+export type ProjectInvitationUncheckedCreateWithoutProjectInput = {
+  id?: number
+  token: string
+  email: string
+  createdAt?: Date | string
+}
+
+export type ProjectInvitationCreateOrConnectWithoutProjectInput = {
+  where: Prisma.ProjectInvitationWhereUniqueInput
+  create: Prisma.XOR<Prisma.ProjectInvitationCreateWithoutProjectInput, Prisma.ProjectInvitationUncheckedCreateWithoutProjectInput>
+}
+
+export type ProjectInvitationCreateManyProjectInputEnvelope = {
+  data: Prisma.ProjectInvitationCreateManyProjectInput | Prisma.ProjectInvitationCreateManyProjectInput[]
+  skipDuplicates?: boolean
+}
+
+export type ProjectInvitationUpsertWithWhereUniqueWithoutProjectInput = {
+  where: Prisma.ProjectInvitationWhereUniqueInput
+  update: Prisma.XOR<Prisma.ProjectInvitationUpdateWithoutProjectInput, Prisma.ProjectInvitationUncheckedUpdateWithoutProjectInput>
+  create: Prisma.XOR<Prisma.ProjectInvitationCreateWithoutProjectInput, Prisma.ProjectInvitationUncheckedCreateWithoutProjectInput>
+}
+
+export type ProjectInvitationUpdateWithWhereUniqueWithoutProjectInput = {
+  where: Prisma.ProjectInvitationWhereUniqueInput
+  data: Prisma.XOR<Prisma.ProjectInvitationUpdateWithoutProjectInput, Prisma.ProjectInvitationUncheckedUpdateWithoutProjectInput>
+}
+
+export type ProjectInvitationUpdateManyWithWhereWithoutProjectInput = {
+  where: Prisma.ProjectInvitationScalarWhereInput
+  data: Prisma.XOR<Prisma.ProjectInvitationUpdateManyMutationInput, Prisma.ProjectInvitationUncheckedUpdateManyWithoutProjectInput>
+}
+
+export type ProjectInvitationScalarWhereInput = {
+  AND?: Prisma.ProjectInvitationScalarWhereInput | Prisma.ProjectInvitationScalarWhereInput[]
+  OR?: Prisma.ProjectInvitationScalarWhereInput[]
+  NOT?: Prisma.ProjectInvitationScalarWhereInput | Prisma.ProjectInvitationScalarWhereInput[]
+  id?: Prisma.IntFilter<"ProjectInvitation"> | number
+  token?: Prisma.StringFilter<"ProjectInvitation"> | string
+  email?: Prisma.StringFilter<"ProjectInvitation"> | string
+  createdAt?: Prisma.DateTimeFilter<"ProjectInvitation"> | Date | string
+  projectId?: Prisma.StringFilter<"ProjectInvitation"> | string
+}
+
+export type ProjectInvitationCreateManyProjectInput = {
+  id?: number
+  token: string
+  email: string
+  createdAt?: Date | string
+}
+
+export type ProjectInvitationUpdateWithoutProjectInput = {
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type ProjectInvitationUncheckedUpdateWithoutProjectInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type ProjectInvitationUncheckedUpdateManyWithoutProjectInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+
+
+export type ProjectInvitationSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  token?: boolean
+  email?: boolean
+  createdAt?: boolean
+  projectId?: boolean
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["projectInvitation"]>
+
+export type ProjectInvitationSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  token?: boolean
+  email?: boolean
+  createdAt?: boolean
+  projectId?: boolean
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["projectInvitation"]>
+
+export type ProjectInvitationSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  token?: boolean
+  email?: boolean
+  createdAt?: boolean
+  projectId?: boolean
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["projectInvitation"]>
+
+export type ProjectInvitationSelectScalar = {
+  id?: boolean
+  token?: boolean
+  email?: boolean
+  createdAt?: boolean
+  projectId?: boolean
+}
+
+export type ProjectInvitationOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "token" | "email" | "createdAt" | "projectId", ExtArgs["result"]["projectInvitation"]>
+export type ProjectInvitationInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}
+export type ProjectInvitationIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}
+export type ProjectInvitationIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}
+
+export type $ProjectInvitationPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "ProjectInvitation"
+  objects: {
+    project: Prisma.$ProjectPayload<ExtArgs>
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: number
+    token: string
+    email: string
+    createdAt: Date
+    projectId: string
+  }, ExtArgs["result"]["projectInvitation"]>
+  composites: {}
+}
+
+export type ProjectInvitationGetPayload<S extends boolean | null | undefined | ProjectInvitationDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload, S>
+
+export type ProjectInvitationCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<ProjectInvitationFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: ProjectInvitationCountAggregateInputType | true
+  }
+
+export interface ProjectInvitationDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['ProjectInvitation'], meta: { name: 'ProjectInvitation' } }
+  /**
+   * Find zero or one ProjectInvitation that matches the filter.
+   * @param {ProjectInvitationFindUniqueArgs} args - Arguments to find a ProjectInvitation
+   * @example
+   * // Get one ProjectInvitation
+   * const projectInvitation = await prisma.projectInvitation.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends ProjectInvitationFindUniqueArgs>(args: Prisma.SelectSubset<T, ProjectInvitationFindUniqueArgs<ExtArgs>>): Prisma.Prisma__ProjectInvitationClient<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one ProjectInvitation that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {ProjectInvitationFindUniqueOrThrowArgs} args - Arguments to find a ProjectInvitation
+   * @example
+   * // Get one ProjectInvitation
+   * const projectInvitation = await prisma.projectInvitation.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends ProjectInvitationFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, ProjectInvitationFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__ProjectInvitationClient<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first ProjectInvitation that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectInvitationFindFirstArgs} args - Arguments to find a ProjectInvitation
+   * @example
+   * // Get one ProjectInvitation
+   * const projectInvitation = await prisma.projectInvitation.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends ProjectInvitationFindFirstArgs>(args?: Prisma.SelectSubset<T, ProjectInvitationFindFirstArgs<ExtArgs>>): Prisma.Prisma__ProjectInvitationClient<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first ProjectInvitation that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectInvitationFindFirstOrThrowArgs} args - Arguments to find a ProjectInvitation
+   * @example
+   * // Get one ProjectInvitation
+   * const projectInvitation = await prisma.projectInvitation.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends ProjectInvitationFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, ProjectInvitationFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__ProjectInvitationClient<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more ProjectInvitations that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectInvitationFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all ProjectInvitations
+   * const projectInvitations = await prisma.projectInvitation.findMany()
+   * 
+   * // Get first 10 ProjectInvitations
+   * const projectInvitations = await prisma.projectInvitation.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const projectInvitationWithIdOnly = await prisma.projectInvitation.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends ProjectInvitationFindManyArgs>(args?: Prisma.SelectSubset<T, ProjectInvitationFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a ProjectInvitation.
+   * @param {ProjectInvitationCreateArgs} args - Arguments to create a ProjectInvitation.
+   * @example
+   * // Create one ProjectInvitation
+   * const ProjectInvitation = await prisma.projectInvitation.create({
+   *   data: {
+   *     // ... data to create a ProjectInvitation
+   *   }
+   * })
+   * 
+   */
+  create<T extends ProjectInvitationCreateArgs>(args: Prisma.SelectSubset<T, ProjectInvitationCreateArgs<ExtArgs>>): Prisma.Prisma__ProjectInvitationClient<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many ProjectInvitations.
+   * @param {ProjectInvitationCreateManyArgs} args - Arguments to create many ProjectInvitations.
+   * @example
+   * // Create many ProjectInvitations
+   * const projectInvitation = await prisma.projectInvitation.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends ProjectInvitationCreateManyArgs>(args?: Prisma.SelectSubset<T, ProjectInvitationCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many ProjectInvitations and returns the data saved in the database.
+   * @param {ProjectInvitationCreateManyAndReturnArgs} args - Arguments to create many ProjectInvitations.
+   * @example
+   * // Create many ProjectInvitations
+   * const projectInvitation = await prisma.projectInvitation.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many ProjectInvitations and only return the `id`
+   * const projectInvitationWithIdOnly = await prisma.projectInvitation.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends ProjectInvitationCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, ProjectInvitationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a ProjectInvitation.
+   * @param {ProjectInvitationDeleteArgs} args - Arguments to delete one ProjectInvitation.
+   * @example
+   * // Delete one ProjectInvitation
+   * const ProjectInvitation = await prisma.projectInvitation.delete({
+   *   where: {
+   *     // ... filter to delete one ProjectInvitation
+   *   }
+   * })
+   * 
+   */
+  delete<T extends ProjectInvitationDeleteArgs>(args: Prisma.SelectSubset<T, ProjectInvitationDeleteArgs<ExtArgs>>): Prisma.Prisma__ProjectInvitationClient<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one ProjectInvitation.
+   * @param {ProjectInvitationUpdateArgs} args - Arguments to update one ProjectInvitation.
+   * @example
+   * // Update one ProjectInvitation
+   * const projectInvitation = await prisma.projectInvitation.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends ProjectInvitationUpdateArgs>(args: Prisma.SelectSubset<T, ProjectInvitationUpdateArgs<ExtArgs>>): Prisma.Prisma__ProjectInvitationClient<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more ProjectInvitations.
+   * @param {ProjectInvitationDeleteManyArgs} args - Arguments to filter ProjectInvitations to delete.
+   * @example
+   * // Delete a few ProjectInvitations
+   * const { count } = await prisma.projectInvitation.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends ProjectInvitationDeleteManyArgs>(args?: Prisma.SelectSubset<T, ProjectInvitationDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more ProjectInvitations.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectInvitationUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many ProjectInvitations
+   * const projectInvitation = await prisma.projectInvitation.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends ProjectInvitationUpdateManyArgs>(args: Prisma.SelectSubset<T, ProjectInvitationUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more ProjectInvitations and returns the data updated in the database.
+   * @param {ProjectInvitationUpdateManyAndReturnArgs} args - Arguments to update many ProjectInvitations.
+   * @example
+   * // Update many ProjectInvitations
+   * const projectInvitation = await prisma.projectInvitation.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more ProjectInvitations and only return the `id`
+   * const projectInvitationWithIdOnly = await prisma.projectInvitation.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends ProjectInvitationUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, ProjectInvitationUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one ProjectInvitation.
+   * @param {ProjectInvitationUpsertArgs} args - Arguments to update or create a ProjectInvitation.
+   * @example
+   * // Update or create a ProjectInvitation
+   * const projectInvitation = await prisma.projectInvitation.upsert({
+   *   create: {
+   *     // ... data to create a ProjectInvitation
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the ProjectInvitation we want to update
+   *   }
+   * })
+   */
+  upsert<T extends ProjectInvitationUpsertArgs>(args: Prisma.SelectSubset<T, ProjectInvitationUpsertArgs<ExtArgs>>): Prisma.Prisma__ProjectInvitationClient<runtime.Types.Result.GetResult<Prisma.$ProjectInvitationPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of ProjectInvitations.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectInvitationCountArgs} args - Arguments to filter ProjectInvitations to count.
+   * @example
+   * // Count the number of ProjectInvitations
+   * const count = await prisma.projectInvitation.count({
+   *   where: {
+   *     // ... the filter for the ProjectInvitations we want to count
+   *   }
+   * })
+  **/
+  count<T extends ProjectInvitationCountArgs>(
+    args?: Prisma.Subset<T, ProjectInvitationCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], ProjectInvitationCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a ProjectInvitation.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectInvitationAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends ProjectInvitationAggregateArgs>(args: Prisma.Subset<T, ProjectInvitationAggregateArgs>): Prisma.PrismaPromise<GetProjectInvitationAggregateType<T>>
+
+  /**
+   * Group by ProjectInvitation.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectInvitationGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends ProjectInvitationGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: ProjectInvitationGroupByArgs['orderBy'] }
+      : { orderBy?: ProjectInvitationGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, ProjectInvitationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetProjectInvitationGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the ProjectInvitation model
+ */
+readonly fields: ProjectInvitationFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for ProjectInvitation.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__ProjectInvitationClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  project<T extends Prisma.ProjectDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.ProjectDefaultArgs<ExtArgs>>): Prisma.Prisma__ProjectClient<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the ProjectInvitation model
+ */
+export interface ProjectInvitationFieldRefs {
+  readonly id: Prisma.FieldRef<"ProjectInvitation", 'Int'>
+  readonly token: Prisma.FieldRef<"ProjectInvitation", 'String'>
+  readonly email: Prisma.FieldRef<"ProjectInvitation", 'String'>
+  readonly createdAt: Prisma.FieldRef<"ProjectInvitation", 'DateTime'>
+  readonly projectId: Prisma.FieldRef<"ProjectInvitation", 'String'>
+}
+    
+
+// Custom InputTypes
+/**
+ * ProjectInvitation findUnique
+ */
+export type ProjectInvitationFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+  /**
+   * Filter, which ProjectInvitation to fetch.
+   */
+  where: Prisma.ProjectInvitationWhereUniqueInput
+}
+
+/**
+ * ProjectInvitation findUniqueOrThrow
+ */
+export type ProjectInvitationFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+  /**
+   * Filter, which ProjectInvitation to fetch.
+   */
+  where: Prisma.ProjectInvitationWhereUniqueInput
+}
+
+/**
+ * ProjectInvitation findFirst
+ */
+export type ProjectInvitationFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+  /**
+   * Filter, which ProjectInvitation to fetch.
+   */
+  where?: Prisma.ProjectInvitationWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of ProjectInvitations to fetch.
+   */
+  orderBy?: Prisma.ProjectInvitationOrderByWithRelationInput | Prisma.ProjectInvitationOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for ProjectInvitations.
+   */
+  cursor?: Prisma.ProjectInvitationWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` ProjectInvitations from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` ProjectInvitations.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of ProjectInvitations.
+   */
+  distinct?: Prisma.ProjectInvitationScalarFieldEnum | Prisma.ProjectInvitationScalarFieldEnum[]
+}
+
+/**
+ * ProjectInvitation findFirstOrThrow
+ */
+export type ProjectInvitationFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+  /**
+   * Filter, which ProjectInvitation to fetch.
+   */
+  where?: Prisma.ProjectInvitationWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of ProjectInvitations to fetch.
+   */
+  orderBy?: Prisma.ProjectInvitationOrderByWithRelationInput | Prisma.ProjectInvitationOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for ProjectInvitations.
+   */
+  cursor?: Prisma.ProjectInvitationWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` ProjectInvitations from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` ProjectInvitations.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of ProjectInvitations.
+   */
+  distinct?: Prisma.ProjectInvitationScalarFieldEnum | Prisma.ProjectInvitationScalarFieldEnum[]
+}
+
+/**
+ * ProjectInvitation findMany
+ */
+export type ProjectInvitationFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+  /**
+   * Filter, which ProjectInvitations to fetch.
+   */
+  where?: Prisma.ProjectInvitationWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of ProjectInvitations to fetch.
+   */
+  orderBy?: Prisma.ProjectInvitationOrderByWithRelationInput | Prisma.ProjectInvitationOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing ProjectInvitations.
+   */
+  cursor?: Prisma.ProjectInvitationWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` ProjectInvitations from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` ProjectInvitations.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of ProjectInvitations.
+   */
+  distinct?: Prisma.ProjectInvitationScalarFieldEnum | Prisma.ProjectInvitationScalarFieldEnum[]
+}
+
+/**
+ * ProjectInvitation create
+ */
+export type ProjectInvitationCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+  /**
+   * The data needed to create a ProjectInvitation.
+   */
+  data: Prisma.XOR<Prisma.ProjectInvitationCreateInput, Prisma.ProjectInvitationUncheckedCreateInput>
+}
+
+/**
+ * ProjectInvitation createMany
+ */
+export type ProjectInvitationCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many ProjectInvitations.
+   */
+  data: Prisma.ProjectInvitationCreateManyInput | Prisma.ProjectInvitationCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * ProjectInvitation createManyAndReturn
+ */
+export type ProjectInvitationCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * The data used to create many ProjectInvitations.
+   */
+  data: Prisma.ProjectInvitationCreateManyInput | Prisma.ProjectInvitationCreateManyInput[]
+  skipDuplicates?: boolean
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationIncludeCreateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * ProjectInvitation update
+ */
+export type ProjectInvitationUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+  /**
+   * The data needed to update a ProjectInvitation.
+   */
+  data: Prisma.XOR<Prisma.ProjectInvitationUpdateInput, Prisma.ProjectInvitationUncheckedUpdateInput>
+  /**
+   * Choose, which ProjectInvitation to update.
+   */
+  where: Prisma.ProjectInvitationWhereUniqueInput
+}
+
+/**
+ * ProjectInvitation updateMany
+ */
+export type ProjectInvitationUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update ProjectInvitations.
+   */
+  data: Prisma.XOR<Prisma.ProjectInvitationUpdateManyMutationInput, Prisma.ProjectInvitationUncheckedUpdateManyInput>
+  /**
+   * Filter which ProjectInvitations to update
+   */
+  where?: Prisma.ProjectInvitationWhereInput
+  /**
+   * Limit how many ProjectInvitations to update.
+   */
+  limit?: number
+}
+
+/**
+ * ProjectInvitation updateManyAndReturn
+ */
+export type ProjectInvitationUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * The data used to update ProjectInvitations.
+   */
+  data: Prisma.XOR<Prisma.ProjectInvitationUpdateManyMutationInput, Prisma.ProjectInvitationUncheckedUpdateManyInput>
+  /**
+   * Filter which ProjectInvitations to update
+   */
+  where?: Prisma.ProjectInvitationWhereInput
+  /**
+   * Limit how many ProjectInvitations to update.
+   */
+  limit?: number
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationIncludeUpdateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * ProjectInvitation upsert
+ */
+export type ProjectInvitationUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+  /**
+   * The filter to search for the ProjectInvitation to update in case it exists.
+   */
+  where: Prisma.ProjectInvitationWhereUniqueInput
+  /**
+   * In case the ProjectInvitation found by the `where` argument doesn't exist, create a new ProjectInvitation with this data.
+   */
+  create: Prisma.XOR<Prisma.ProjectInvitationCreateInput, Prisma.ProjectInvitationUncheckedCreateInput>
+  /**
+   * In case the ProjectInvitation was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.ProjectInvitationUpdateInput, Prisma.ProjectInvitationUncheckedUpdateInput>
+}
+
+/**
+ * ProjectInvitation delete
+ */
+export type ProjectInvitationDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+  /**
+   * Filter which ProjectInvitation to delete.
+   */
+  where: Prisma.ProjectInvitationWhereUniqueInput
+}
+
+/**
+ * ProjectInvitation deleteMany
+ */
+export type ProjectInvitationDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which ProjectInvitations to delete
+   */
+  where?: Prisma.ProjectInvitationWhereInput
+  /**
+   * Limit how many ProjectInvitations to delete.
+   */
+  limit?: number
+}
+
+/**
+ * ProjectInvitation without action
+ */
+export type ProjectInvitationDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectInvitation
+   */
+  select?: Prisma.ProjectInvitationSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectInvitation
+   */
+  omit?: Prisma.ProjectInvitationOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectInvitationInclude<ExtArgs> | null
+}
diff --git a/src/generated/client/models/ProjectMember.ts b/src/generated/client/models/ProjectMember.ts
new file mode 100644
index 00000000..bac15c15
--- /dev/null
+++ b/src/generated/client/models/ProjectMember.ts
@@ -0,0 +1,1471 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `ProjectMember` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model ProjectMember
+ * 
+ */
+export type ProjectMemberModel = runtime.Types.Result.DefaultSelection<Prisma.$ProjectMemberPayload>
+
+export type AggregateProjectMember = {
+  _count: ProjectMemberCountAggregateOutputType | null
+  _avg: ProjectMemberAvgAggregateOutputType | null
+  _sum: ProjectMemberSumAggregateOutputType | null
+  _min: ProjectMemberMinAggregateOutputType | null
+  _max: ProjectMemberMaxAggregateOutputType | null
+}
+
+export type ProjectMemberAvgAggregateOutputType = {
+  id: number | null
+}
+
+export type ProjectMemberSumAggregateOutputType = {
+  id: number | null
+}
+
+export type ProjectMemberMinAggregateOutputType = {
+  id: number | null
+  role: $Enums.ProjectRole | null
+  userId: string | null
+  projectId: string | null
+}
+
+export type ProjectMemberMaxAggregateOutputType = {
+  id: number | null
+  role: $Enums.ProjectRole | null
+  userId: string | null
+  projectId: string | null
+}
+
+export type ProjectMemberCountAggregateOutputType = {
+  id: number
+  role: number
+  userId: number
+  projectId: number
+  _all: number
+}
+
+
+export type ProjectMemberAvgAggregateInputType = {
+  id?: true
+}
+
+export type ProjectMemberSumAggregateInputType = {
+  id?: true
+}
+
+export type ProjectMemberMinAggregateInputType = {
+  id?: true
+  role?: true
+  userId?: true
+  projectId?: true
+}
+
+export type ProjectMemberMaxAggregateInputType = {
+  id?: true
+  role?: true
+  userId?: true
+  projectId?: true
+}
+
+export type ProjectMemberCountAggregateInputType = {
+  id?: true
+  role?: true
+  userId?: true
+  projectId?: true
+  _all?: true
+}
+
+export type ProjectMemberAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which ProjectMember to aggregate.
+   */
+  where?: Prisma.ProjectMemberWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of ProjectMembers to fetch.
+   */
+  orderBy?: Prisma.ProjectMemberOrderByWithRelationInput | Prisma.ProjectMemberOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.ProjectMemberWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` ProjectMembers from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` ProjectMembers.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned ProjectMembers
+  **/
+  _count?: true | ProjectMemberCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to average
+  **/
+  _avg?: ProjectMemberAvgAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to sum
+  **/
+  _sum?: ProjectMemberSumAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: ProjectMemberMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: ProjectMemberMaxAggregateInputType
+}
+
+export type GetProjectMemberAggregateType<T extends ProjectMemberAggregateArgs> = {
+      [P in keyof T & keyof AggregateProjectMember]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateProjectMember[P]>
+    : Prisma.GetScalarType<T[P], AggregateProjectMember[P]>
+}
+
+
+
+
+export type ProjectMemberGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.ProjectMemberWhereInput
+  orderBy?: Prisma.ProjectMemberOrderByWithAggregationInput | Prisma.ProjectMemberOrderByWithAggregationInput[]
+  by: Prisma.ProjectMemberScalarFieldEnum[] | Prisma.ProjectMemberScalarFieldEnum
+  having?: Prisma.ProjectMemberScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: ProjectMemberCountAggregateInputType | true
+  _avg?: ProjectMemberAvgAggregateInputType
+  _sum?: ProjectMemberSumAggregateInputType
+  _min?: ProjectMemberMinAggregateInputType
+  _max?: ProjectMemberMaxAggregateInputType
+}
+
+export type ProjectMemberGroupByOutputType = {
+  id: number
+  role: $Enums.ProjectRole
+  userId: string
+  projectId: string
+  _count: ProjectMemberCountAggregateOutputType | null
+  _avg: ProjectMemberAvgAggregateOutputType | null
+  _sum: ProjectMemberSumAggregateOutputType | null
+  _min: ProjectMemberMinAggregateOutputType | null
+  _max: ProjectMemberMaxAggregateOutputType | null
+}
+
+export type GetProjectMemberGroupByPayload<T extends ProjectMemberGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<ProjectMemberGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof ProjectMemberGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], ProjectMemberGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], ProjectMemberGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type ProjectMemberWhereInput = {
+  AND?: Prisma.ProjectMemberWhereInput | Prisma.ProjectMemberWhereInput[]
+  OR?: Prisma.ProjectMemberWhereInput[]
+  NOT?: Prisma.ProjectMemberWhereInput | Prisma.ProjectMemberWhereInput[]
+  id?: Prisma.IntFilter<"ProjectMember"> | number
+  role?: Prisma.EnumProjectRoleFilter<"ProjectMember"> | $Enums.ProjectRole
+  userId?: Prisma.StringFilter<"ProjectMember"> | string
+  projectId?: Prisma.StringFilter<"ProjectMember"> | string
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+  project?: Prisma.XOR<Prisma.ProjectScalarRelationFilter, Prisma.ProjectWhereInput>
+}
+
+export type ProjectMemberOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  role?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  projectId?: Prisma.SortOrder
+  user?: Prisma.UserOrderByWithRelationInput
+  project?: Prisma.ProjectOrderByWithRelationInput
+}
+
+export type ProjectMemberWhereUniqueInput = Prisma.AtLeast<{
+  id?: number
+  userId_projectId?: Prisma.ProjectMemberUserIdProjectIdCompoundUniqueInput
+  AND?: Prisma.ProjectMemberWhereInput | Prisma.ProjectMemberWhereInput[]
+  OR?: Prisma.ProjectMemberWhereInput[]
+  NOT?: Prisma.ProjectMemberWhereInput | Prisma.ProjectMemberWhereInput[]
+  role?: Prisma.EnumProjectRoleFilter<"ProjectMember"> | $Enums.ProjectRole
+  userId?: Prisma.StringFilter<"ProjectMember"> | string
+  projectId?: Prisma.StringFilter<"ProjectMember"> | string
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+  project?: Prisma.XOR<Prisma.ProjectScalarRelationFilter, Prisma.ProjectWhereInput>
+}, "id" | "userId_projectId">
+
+export type ProjectMemberOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  role?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  projectId?: Prisma.SortOrder
+  _count?: Prisma.ProjectMemberCountOrderByAggregateInput
+  _avg?: Prisma.ProjectMemberAvgOrderByAggregateInput
+  _max?: Prisma.ProjectMemberMaxOrderByAggregateInput
+  _min?: Prisma.ProjectMemberMinOrderByAggregateInput
+  _sum?: Prisma.ProjectMemberSumOrderByAggregateInput
+}
+
+export type ProjectMemberScalarWhereWithAggregatesInput = {
+  AND?: Prisma.ProjectMemberScalarWhereWithAggregatesInput | Prisma.ProjectMemberScalarWhereWithAggregatesInput[]
+  OR?: Prisma.ProjectMemberScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.ProjectMemberScalarWhereWithAggregatesInput | Prisma.ProjectMemberScalarWhereWithAggregatesInput[]
+  id?: Prisma.IntWithAggregatesFilter<"ProjectMember"> | number
+  role?: Prisma.EnumProjectRoleWithAggregatesFilter<"ProjectMember"> | $Enums.ProjectRole
+  userId?: Prisma.StringWithAggregatesFilter<"ProjectMember"> | string
+  projectId?: Prisma.StringWithAggregatesFilter<"ProjectMember"> | string
+}
+
+export type ProjectMemberCreateInput = {
+  role?: $Enums.ProjectRole
+  user: Prisma.UserCreateNestedOneWithoutProjectsInput
+  project: Prisma.ProjectCreateNestedOneWithoutMembersInput
+}
+
+export type ProjectMemberUncheckedCreateInput = {
+  id?: number
+  role?: $Enums.ProjectRole
+  userId: string
+  projectId: string
+}
+
+export type ProjectMemberUpdateInput = {
+  role?: Prisma.EnumProjectRoleFieldUpdateOperationsInput | $Enums.ProjectRole
+  user?: Prisma.UserUpdateOneRequiredWithoutProjectsNestedInput
+  project?: Prisma.ProjectUpdateOneRequiredWithoutMembersNestedInput
+}
+
+export type ProjectMemberUncheckedUpdateInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  role?: Prisma.EnumProjectRoleFieldUpdateOperationsInput | $Enums.ProjectRole
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  projectId?: Prisma.StringFieldUpdateOperationsInput | string
+}
+
+export type ProjectMemberCreateManyInput = {
+  id?: number
+  role?: $Enums.ProjectRole
+  userId: string
+  projectId: string
+}
+
+export type ProjectMemberUpdateManyMutationInput = {
+  role?: Prisma.EnumProjectRoleFieldUpdateOperationsInput | $Enums.ProjectRole
+}
+
+export type ProjectMemberUncheckedUpdateManyInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  role?: Prisma.EnumProjectRoleFieldUpdateOperationsInput | $Enums.ProjectRole
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  projectId?: Prisma.StringFieldUpdateOperationsInput | string
+}
+
+export type ProjectMemberListRelationFilter = {
+  every?: Prisma.ProjectMemberWhereInput
+  some?: Prisma.ProjectMemberWhereInput
+  none?: Prisma.ProjectMemberWhereInput
+}
+
+export type ProjectMemberOrderByRelationAggregateInput = {
+  _count?: Prisma.SortOrder
+}
+
+export type ProjectMemberUserIdProjectIdCompoundUniqueInput = {
+  userId: string
+  projectId: string
+}
+
+export type ProjectMemberCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  role?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  projectId?: Prisma.SortOrder
+}
+
+export type ProjectMemberAvgOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+}
+
+export type ProjectMemberMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  role?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  projectId?: Prisma.SortOrder
+}
+
+export type ProjectMemberMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  role?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  projectId?: Prisma.SortOrder
+}
+
+export type ProjectMemberSumOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+}
+
+export type ProjectMemberCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.ProjectMemberCreateWithoutUserInput, Prisma.ProjectMemberUncheckedCreateWithoutUserInput> | Prisma.ProjectMemberCreateWithoutUserInput[] | Prisma.ProjectMemberUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.ProjectMemberCreateOrConnectWithoutUserInput | Prisma.ProjectMemberCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.ProjectMemberCreateManyUserInputEnvelope
+  connect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+}
+
+export type ProjectMemberUncheckedCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.ProjectMemberCreateWithoutUserInput, Prisma.ProjectMemberUncheckedCreateWithoutUserInput> | Prisma.ProjectMemberCreateWithoutUserInput[] | Prisma.ProjectMemberUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.ProjectMemberCreateOrConnectWithoutUserInput | Prisma.ProjectMemberCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.ProjectMemberCreateManyUserInputEnvelope
+  connect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+}
+
+export type ProjectMemberUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.ProjectMemberCreateWithoutUserInput, Prisma.ProjectMemberUncheckedCreateWithoutUserInput> | Prisma.ProjectMemberCreateWithoutUserInput[] | Prisma.ProjectMemberUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.ProjectMemberCreateOrConnectWithoutUserInput | Prisma.ProjectMemberCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.ProjectMemberUpsertWithWhereUniqueWithoutUserInput | Prisma.ProjectMemberUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.ProjectMemberCreateManyUserInputEnvelope
+  set?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  disconnect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  delete?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  connect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  update?: Prisma.ProjectMemberUpdateWithWhereUniqueWithoutUserInput | Prisma.ProjectMemberUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.ProjectMemberUpdateManyWithWhereWithoutUserInput | Prisma.ProjectMemberUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.ProjectMemberScalarWhereInput | Prisma.ProjectMemberScalarWhereInput[]
+}
+
+export type ProjectMemberUncheckedUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.ProjectMemberCreateWithoutUserInput, Prisma.ProjectMemberUncheckedCreateWithoutUserInput> | Prisma.ProjectMemberCreateWithoutUserInput[] | Prisma.ProjectMemberUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.ProjectMemberCreateOrConnectWithoutUserInput | Prisma.ProjectMemberCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.ProjectMemberUpsertWithWhereUniqueWithoutUserInput | Prisma.ProjectMemberUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.ProjectMemberCreateManyUserInputEnvelope
+  set?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  disconnect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  delete?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  connect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  update?: Prisma.ProjectMemberUpdateWithWhereUniqueWithoutUserInput | Prisma.ProjectMemberUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.ProjectMemberUpdateManyWithWhereWithoutUserInput | Prisma.ProjectMemberUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.ProjectMemberScalarWhereInput | Prisma.ProjectMemberScalarWhereInput[]
+}
+
+export type ProjectMemberCreateNestedManyWithoutProjectInput = {
+  create?: Prisma.XOR<Prisma.ProjectMemberCreateWithoutProjectInput, Prisma.ProjectMemberUncheckedCreateWithoutProjectInput> | Prisma.ProjectMemberCreateWithoutProjectInput[] | Prisma.ProjectMemberUncheckedCreateWithoutProjectInput[]
+  connectOrCreate?: Prisma.ProjectMemberCreateOrConnectWithoutProjectInput | Prisma.ProjectMemberCreateOrConnectWithoutProjectInput[]
+  createMany?: Prisma.ProjectMemberCreateManyProjectInputEnvelope
+  connect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+}
+
+export type ProjectMemberUncheckedCreateNestedManyWithoutProjectInput = {
+  create?: Prisma.XOR<Prisma.ProjectMemberCreateWithoutProjectInput, Prisma.ProjectMemberUncheckedCreateWithoutProjectInput> | Prisma.ProjectMemberCreateWithoutProjectInput[] | Prisma.ProjectMemberUncheckedCreateWithoutProjectInput[]
+  connectOrCreate?: Prisma.ProjectMemberCreateOrConnectWithoutProjectInput | Prisma.ProjectMemberCreateOrConnectWithoutProjectInput[]
+  createMany?: Prisma.ProjectMemberCreateManyProjectInputEnvelope
+  connect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+}
+
+export type ProjectMemberUpdateManyWithoutProjectNestedInput = {
+  create?: Prisma.XOR<Prisma.ProjectMemberCreateWithoutProjectInput, Prisma.ProjectMemberUncheckedCreateWithoutProjectInput> | Prisma.ProjectMemberCreateWithoutProjectInput[] | Prisma.ProjectMemberUncheckedCreateWithoutProjectInput[]
+  connectOrCreate?: Prisma.ProjectMemberCreateOrConnectWithoutProjectInput | Prisma.ProjectMemberCreateOrConnectWithoutProjectInput[]
+  upsert?: Prisma.ProjectMemberUpsertWithWhereUniqueWithoutProjectInput | Prisma.ProjectMemberUpsertWithWhereUniqueWithoutProjectInput[]
+  createMany?: Prisma.ProjectMemberCreateManyProjectInputEnvelope
+  set?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  disconnect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  delete?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  connect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  update?: Prisma.ProjectMemberUpdateWithWhereUniqueWithoutProjectInput | Prisma.ProjectMemberUpdateWithWhereUniqueWithoutProjectInput[]
+  updateMany?: Prisma.ProjectMemberUpdateManyWithWhereWithoutProjectInput | Prisma.ProjectMemberUpdateManyWithWhereWithoutProjectInput[]
+  deleteMany?: Prisma.ProjectMemberScalarWhereInput | Prisma.ProjectMemberScalarWhereInput[]
+}
+
+export type ProjectMemberUncheckedUpdateManyWithoutProjectNestedInput = {
+  create?: Prisma.XOR<Prisma.ProjectMemberCreateWithoutProjectInput, Prisma.ProjectMemberUncheckedCreateWithoutProjectInput> | Prisma.ProjectMemberCreateWithoutProjectInput[] | Prisma.ProjectMemberUncheckedCreateWithoutProjectInput[]
+  connectOrCreate?: Prisma.ProjectMemberCreateOrConnectWithoutProjectInput | Prisma.ProjectMemberCreateOrConnectWithoutProjectInput[]
+  upsert?: Prisma.ProjectMemberUpsertWithWhereUniqueWithoutProjectInput | Prisma.ProjectMemberUpsertWithWhereUniqueWithoutProjectInput[]
+  createMany?: Prisma.ProjectMemberCreateManyProjectInputEnvelope
+  set?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  disconnect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  delete?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  connect?: Prisma.ProjectMemberWhereUniqueInput | Prisma.ProjectMemberWhereUniqueInput[]
+  update?: Prisma.ProjectMemberUpdateWithWhereUniqueWithoutProjectInput | Prisma.ProjectMemberUpdateWithWhereUniqueWithoutProjectInput[]
+  updateMany?: Prisma.ProjectMemberUpdateManyWithWhereWithoutProjectInput | Prisma.ProjectMemberUpdateManyWithWhereWithoutProjectInput[]
+  deleteMany?: Prisma.ProjectMemberScalarWhereInput | Prisma.ProjectMemberScalarWhereInput[]
+}
+
+export type EnumProjectRoleFieldUpdateOperationsInput = {
+  set?: $Enums.ProjectRole
+}
+
+export type ProjectMemberCreateWithoutUserInput = {
+  role?: $Enums.ProjectRole
+  project: Prisma.ProjectCreateNestedOneWithoutMembersInput
+}
+
+export type ProjectMemberUncheckedCreateWithoutUserInput = {
+  id?: number
+  role?: $Enums.ProjectRole
+  projectId: string
+}
+
+export type ProjectMemberCreateOrConnectWithoutUserInput = {
+  where: Prisma.ProjectMemberWhereUniqueInput
+  create: Prisma.XOR<Prisma.ProjectMemberCreateWithoutUserInput, Prisma.ProjectMemberUncheckedCreateWithoutUserInput>
+}
+
+export type ProjectMemberCreateManyUserInputEnvelope = {
+  data: Prisma.ProjectMemberCreateManyUserInput | Prisma.ProjectMemberCreateManyUserInput[]
+  skipDuplicates?: boolean
+}
+
+export type ProjectMemberUpsertWithWhereUniqueWithoutUserInput = {
+  where: Prisma.ProjectMemberWhereUniqueInput
+  update: Prisma.XOR<Prisma.ProjectMemberUpdateWithoutUserInput, Prisma.ProjectMemberUncheckedUpdateWithoutUserInput>
+  create: Prisma.XOR<Prisma.ProjectMemberCreateWithoutUserInput, Prisma.ProjectMemberUncheckedCreateWithoutUserInput>
+}
+
+export type ProjectMemberUpdateWithWhereUniqueWithoutUserInput = {
+  where: Prisma.ProjectMemberWhereUniqueInput
+  data: Prisma.XOR<Prisma.ProjectMemberUpdateWithoutUserInput, Prisma.ProjectMemberUncheckedUpdateWithoutUserInput>
+}
+
+export type ProjectMemberUpdateManyWithWhereWithoutUserInput = {
+  where: Prisma.ProjectMemberScalarWhereInput
+  data: Prisma.XOR<Prisma.ProjectMemberUpdateManyMutationInput, Prisma.ProjectMemberUncheckedUpdateManyWithoutUserInput>
+}
+
+export type ProjectMemberScalarWhereInput = {
+  AND?: Prisma.ProjectMemberScalarWhereInput | Prisma.ProjectMemberScalarWhereInput[]
+  OR?: Prisma.ProjectMemberScalarWhereInput[]
+  NOT?: Prisma.ProjectMemberScalarWhereInput | Prisma.ProjectMemberScalarWhereInput[]
+  id?: Prisma.IntFilter<"ProjectMember"> | number
+  role?: Prisma.EnumProjectRoleFilter<"ProjectMember"> | $Enums.ProjectRole
+  userId?: Prisma.StringFilter<"ProjectMember"> | string
+  projectId?: Prisma.StringFilter<"ProjectMember"> | string
+}
+
+export type ProjectMemberCreateWithoutProjectInput = {
+  role?: $Enums.ProjectRole
+  user: Prisma.UserCreateNestedOneWithoutProjectsInput
+}
+
+export type ProjectMemberUncheckedCreateWithoutProjectInput = {
+  id?: number
+  role?: $Enums.ProjectRole
+  userId: string
+}
+
+export type ProjectMemberCreateOrConnectWithoutProjectInput = {
+  where: Prisma.ProjectMemberWhereUniqueInput
+  create: Prisma.XOR<Prisma.ProjectMemberCreateWithoutProjectInput, Prisma.ProjectMemberUncheckedCreateWithoutProjectInput>
+}
+
+export type ProjectMemberCreateManyProjectInputEnvelope = {
+  data: Prisma.ProjectMemberCreateManyProjectInput | Prisma.ProjectMemberCreateManyProjectInput[]
+  skipDuplicates?: boolean
+}
+
+export type ProjectMemberUpsertWithWhereUniqueWithoutProjectInput = {
+  where: Prisma.ProjectMemberWhereUniqueInput
+  update: Prisma.XOR<Prisma.ProjectMemberUpdateWithoutProjectInput, Prisma.ProjectMemberUncheckedUpdateWithoutProjectInput>
+  create: Prisma.XOR<Prisma.ProjectMemberCreateWithoutProjectInput, Prisma.ProjectMemberUncheckedCreateWithoutProjectInput>
+}
+
+export type ProjectMemberUpdateWithWhereUniqueWithoutProjectInput = {
+  where: Prisma.ProjectMemberWhereUniqueInput
+  data: Prisma.XOR<Prisma.ProjectMemberUpdateWithoutProjectInput, Prisma.ProjectMemberUncheckedUpdateWithoutProjectInput>
+}
+
+export type ProjectMemberUpdateManyWithWhereWithoutProjectInput = {
+  where: Prisma.ProjectMemberScalarWhereInput
+  data: Prisma.XOR<Prisma.ProjectMemberUpdateManyMutationInput, Prisma.ProjectMemberUncheckedUpdateManyWithoutProjectInput>
+}
+
+export type ProjectMemberCreateManyUserInput = {
+  id?: number
+  role?: $Enums.ProjectRole
+  projectId: string
+}
+
+export type ProjectMemberUpdateWithoutUserInput = {
+  role?: Prisma.EnumProjectRoleFieldUpdateOperationsInput | $Enums.ProjectRole
+  project?: Prisma.ProjectUpdateOneRequiredWithoutMembersNestedInput
+}
+
+export type ProjectMemberUncheckedUpdateWithoutUserInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  role?: Prisma.EnumProjectRoleFieldUpdateOperationsInput | $Enums.ProjectRole
+  projectId?: Prisma.StringFieldUpdateOperationsInput | string
+}
+
+export type ProjectMemberUncheckedUpdateManyWithoutUserInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  role?: Prisma.EnumProjectRoleFieldUpdateOperationsInput | $Enums.ProjectRole
+  projectId?: Prisma.StringFieldUpdateOperationsInput | string
+}
+
+export type ProjectMemberCreateManyProjectInput = {
+  id?: number
+  role?: $Enums.ProjectRole
+  userId: string
+}
+
+export type ProjectMemberUpdateWithoutProjectInput = {
+  role?: Prisma.EnumProjectRoleFieldUpdateOperationsInput | $Enums.ProjectRole
+  user?: Prisma.UserUpdateOneRequiredWithoutProjectsNestedInput
+}
+
+export type ProjectMemberUncheckedUpdateWithoutProjectInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  role?: Prisma.EnumProjectRoleFieldUpdateOperationsInput | $Enums.ProjectRole
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+}
+
+export type ProjectMemberUncheckedUpdateManyWithoutProjectInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  role?: Prisma.EnumProjectRoleFieldUpdateOperationsInput | $Enums.ProjectRole
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+}
+
+
+
+export type ProjectMemberSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  role?: boolean
+  userId?: boolean
+  projectId?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["projectMember"]>
+
+export type ProjectMemberSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  role?: boolean
+  userId?: boolean
+  projectId?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["projectMember"]>
+
+export type ProjectMemberSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  role?: boolean
+  userId?: boolean
+  projectId?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["projectMember"]>
+
+export type ProjectMemberSelectScalar = {
+  id?: boolean
+  role?: boolean
+  userId?: boolean
+  projectId?: boolean
+}
+
+export type ProjectMemberOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "role" | "userId" | "projectId", ExtArgs["result"]["projectMember"]>
+export type ProjectMemberInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}
+export type ProjectMemberIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}
+export type ProjectMemberIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+  project?: boolean | Prisma.ProjectDefaultArgs<ExtArgs>
+}
+
+export type $ProjectMemberPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "ProjectMember"
+  objects: {
+    user: Prisma.$UserPayload<ExtArgs>
+    project: Prisma.$ProjectPayload<ExtArgs>
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: number
+    role: $Enums.ProjectRole
+    userId: string
+    projectId: string
+  }, ExtArgs["result"]["projectMember"]>
+  composites: {}
+}
+
+export type ProjectMemberGetPayload<S extends boolean | null | undefined | ProjectMemberDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload, S>
+
+export type ProjectMemberCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<ProjectMemberFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: ProjectMemberCountAggregateInputType | true
+  }
+
+export interface ProjectMemberDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['ProjectMember'], meta: { name: 'ProjectMember' } }
+  /**
+   * Find zero or one ProjectMember that matches the filter.
+   * @param {ProjectMemberFindUniqueArgs} args - Arguments to find a ProjectMember
+   * @example
+   * // Get one ProjectMember
+   * const projectMember = await prisma.projectMember.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends ProjectMemberFindUniqueArgs>(args: Prisma.SelectSubset<T, ProjectMemberFindUniqueArgs<ExtArgs>>): Prisma.Prisma__ProjectMemberClient<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one ProjectMember that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {ProjectMemberFindUniqueOrThrowArgs} args - Arguments to find a ProjectMember
+   * @example
+   * // Get one ProjectMember
+   * const projectMember = await prisma.projectMember.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends ProjectMemberFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, ProjectMemberFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__ProjectMemberClient<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first ProjectMember that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectMemberFindFirstArgs} args - Arguments to find a ProjectMember
+   * @example
+   * // Get one ProjectMember
+   * const projectMember = await prisma.projectMember.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends ProjectMemberFindFirstArgs>(args?: Prisma.SelectSubset<T, ProjectMemberFindFirstArgs<ExtArgs>>): Prisma.Prisma__ProjectMemberClient<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first ProjectMember that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectMemberFindFirstOrThrowArgs} args - Arguments to find a ProjectMember
+   * @example
+   * // Get one ProjectMember
+   * const projectMember = await prisma.projectMember.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends ProjectMemberFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, ProjectMemberFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__ProjectMemberClient<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more ProjectMembers that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectMemberFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all ProjectMembers
+   * const projectMembers = await prisma.projectMember.findMany()
+   * 
+   * // Get first 10 ProjectMembers
+   * const projectMembers = await prisma.projectMember.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const projectMemberWithIdOnly = await prisma.projectMember.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends ProjectMemberFindManyArgs>(args?: Prisma.SelectSubset<T, ProjectMemberFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a ProjectMember.
+   * @param {ProjectMemberCreateArgs} args - Arguments to create a ProjectMember.
+   * @example
+   * // Create one ProjectMember
+   * const ProjectMember = await prisma.projectMember.create({
+   *   data: {
+   *     // ... data to create a ProjectMember
+   *   }
+   * })
+   * 
+   */
+  create<T extends ProjectMemberCreateArgs>(args: Prisma.SelectSubset<T, ProjectMemberCreateArgs<ExtArgs>>): Prisma.Prisma__ProjectMemberClient<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many ProjectMembers.
+   * @param {ProjectMemberCreateManyArgs} args - Arguments to create many ProjectMembers.
+   * @example
+   * // Create many ProjectMembers
+   * const projectMember = await prisma.projectMember.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends ProjectMemberCreateManyArgs>(args?: Prisma.SelectSubset<T, ProjectMemberCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many ProjectMembers and returns the data saved in the database.
+   * @param {ProjectMemberCreateManyAndReturnArgs} args - Arguments to create many ProjectMembers.
+   * @example
+   * // Create many ProjectMembers
+   * const projectMember = await prisma.projectMember.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many ProjectMembers and only return the `id`
+   * const projectMemberWithIdOnly = await prisma.projectMember.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends ProjectMemberCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, ProjectMemberCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a ProjectMember.
+   * @param {ProjectMemberDeleteArgs} args - Arguments to delete one ProjectMember.
+   * @example
+   * // Delete one ProjectMember
+   * const ProjectMember = await prisma.projectMember.delete({
+   *   where: {
+   *     // ... filter to delete one ProjectMember
+   *   }
+   * })
+   * 
+   */
+  delete<T extends ProjectMemberDeleteArgs>(args: Prisma.SelectSubset<T, ProjectMemberDeleteArgs<ExtArgs>>): Prisma.Prisma__ProjectMemberClient<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one ProjectMember.
+   * @param {ProjectMemberUpdateArgs} args - Arguments to update one ProjectMember.
+   * @example
+   * // Update one ProjectMember
+   * const projectMember = await prisma.projectMember.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends ProjectMemberUpdateArgs>(args: Prisma.SelectSubset<T, ProjectMemberUpdateArgs<ExtArgs>>): Prisma.Prisma__ProjectMemberClient<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more ProjectMembers.
+   * @param {ProjectMemberDeleteManyArgs} args - Arguments to filter ProjectMembers to delete.
+   * @example
+   * // Delete a few ProjectMembers
+   * const { count } = await prisma.projectMember.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends ProjectMemberDeleteManyArgs>(args?: Prisma.SelectSubset<T, ProjectMemberDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more ProjectMembers.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectMemberUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many ProjectMembers
+   * const projectMember = await prisma.projectMember.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends ProjectMemberUpdateManyArgs>(args: Prisma.SelectSubset<T, ProjectMemberUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more ProjectMembers and returns the data updated in the database.
+   * @param {ProjectMemberUpdateManyAndReturnArgs} args - Arguments to update many ProjectMembers.
+   * @example
+   * // Update many ProjectMembers
+   * const projectMember = await prisma.projectMember.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more ProjectMembers and only return the `id`
+   * const projectMemberWithIdOnly = await prisma.projectMember.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends ProjectMemberUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, ProjectMemberUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one ProjectMember.
+   * @param {ProjectMemberUpsertArgs} args - Arguments to update or create a ProjectMember.
+   * @example
+   * // Update or create a ProjectMember
+   * const projectMember = await prisma.projectMember.upsert({
+   *   create: {
+   *     // ... data to create a ProjectMember
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the ProjectMember we want to update
+   *   }
+   * })
+   */
+  upsert<T extends ProjectMemberUpsertArgs>(args: Prisma.SelectSubset<T, ProjectMemberUpsertArgs<ExtArgs>>): Prisma.Prisma__ProjectMemberClient<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of ProjectMembers.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectMemberCountArgs} args - Arguments to filter ProjectMembers to count.
+   * @example
+   * // Count the number of ProjectMembers
+   * const count = await prisma.projectMember.count({
+   *   where: {
+   *     // ... the filter for the ProjectMembers we want to count
+   *   }
+   * })
+  **/
+  count<T extends ProjectMemberCountArgs>(
+    args?: Prisma.Subset<T, ProjectMemberCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], ProjectMemberCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a ProjectMember.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectMemberAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends ProjectMemberAggregateArgs>(args: Prisma.Subset<T, ProjectMemberAggregateArgs>): Prisma.PrismaPromise<GetProjectMemberAggregateType<T>>
+
+  /**
+   * Group by ProjectMember.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {ProjectMemberGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends ProjectMemberGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: ProjectMemberGroupByArgs['orderBy'] }
+      : { orderBy?: ProjectMemberGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, ProjectMemberGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetProjectMemberGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the ProjectMember model
+ */
+readonly fields: ProjectMemberFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for ProjectMember.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__ProjectMemberClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  user<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  project<T extends Prisma.ProjectDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.ProjectDefaultArgs<ExtArgs>>): Prisma.Prisma__ProjectClient<runtime.Types.Result.GetResult<Prisma.$ProjectPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the ProjectMember model
+ */
+export interface ProjectMemberFieldRefs {
+  readonly id: Prisma.FieldRef<"ProjectMember", 'Int'>
+  readonly role: Prisma.FieldRef<"ProjectMember", 'ProjectRole'>
+  readonly userId: Prisma.FieldRef<"ProjectMember", 'String'>
+  readonly projectId: Prisma.FieldRef<"ProjectMember", 'String'>
+}
+    
+
+// Custom InputTypes
+/**
+ * ProjectMember findUnique
+ */
+export type ProjectMemberFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  /**
+   * Filter, which ProjectMember to fetch.
+   */
+  where: Prisma.ProjectMemberWhereUniqueInput
+}
+
+/**
+ * ProjectMember findUniqueOrThrow
+ */
+export type ProjectMemberFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  /**
+   * Filter, which ProjectMember to fetch.
+   */
+  where: Prisma.ProjectMemberWhereUniqueInput
+}
+
+/**
+ * ProjectMember findFirst
+ */
+export type ProjectMemberFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  /**
+   * Filter, which ProjectMember to fetch.
+   */
+  where?: Prisma.ProjectMemberWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of ProjectMembers to fetch.
+   */
+  orderBy?: Prisma.ProjectMemberOrderByWithRelationInput | Prisma.ProjectMemberOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for ProjectMembers.
+   */
+  cursor?: Prisma.ProjectMemberWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` ProjectMembers from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` ProjectMembers.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of ProjectMembers.
+   */
+  distinct?: Prisma.ProjectMemberScalarFieldEnum | Prisma.ProjectMemberScalarFieldEnum[]
+}
+
+/**
+ * ProjectMember findFirstOrThrow
+ */
+export type ProjectMemberFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  /**
+   * Filter, which ProjectMember to fetch.
+   */
+  where?: Prisma.ProjectMemberWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of ProjectMembers to fetch.
+   */
+  orderBy?: Prisma.ProjectMemberOrderByWithRelationInput | Prisma.ProjectMemberOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for ProjectMembers.
+   */
+  cursor?: Prisma.ProjectMemberWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` ProjectMembers from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` ProjectMembers.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of ProjectMembers.
+   */
+  distinct?: Prisma.ProjectMemberScalarFieldEnum | Prisma.ProjectMemberScalarFieldEnum[]
+}
+
+/**
+ * ProjectMember findMany
+ */
+export type ProjectMemberFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  /**
+   * Filter, which ProjectMembers to fetch.
+   */
+  where?: Prisma.ProjectMemberWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of ProjectMembers to fetch.
+   */
+  orderBy?: Prisma.ProjectMemberOrderByWithRelationInput | Prisma.ProjectMemberOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing ProjectMembers.
+   */
+  cursor?: Prisma.ProjectMemberWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` ProjectMembers from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` ProjectMembers.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of ProjectMembers.
+   */
+  distinct?: Prisma.ProjectMemberScalarFieldEnum | Prisma.ProjectMemberScalarFieldEnum[]
+}
+
+/**
+ * ProjectMember create
+ */
+export type ProjectMemberCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  /**
+   * The data needed to create a ProjectMember.
+   */
+  data: Prisma.XOR<Prisma.ProjectMemberCreateInput, Prisma.ProjectMemberUncheckedCreateInput>
+}
+
+/**
+ * ProjectMember createMany
+ */
+export type ProjectMemberCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many ProjectMembers.
+   */
+  data: Prisma.ProjectMemberCreateManyInput | Prisma.ProjectMemberCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * ProjectMember createManyAndReturn
+ */
+export type ProjectMemberCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * The data used to create many ProjectMembers.
+   */
+  data: Prisma.ProjectMemberCreateManyInput | Prisma.ProjectMemberCreateManyInput[]
+  skipDuplicates?: boolean
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberIncludeCreateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * ProjectMember update
+ */
+export type ProjectMemberUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  /**
+   * The data needed to update a ProjectMember.
+   */
+  data: Prisma.XOR<Prisma.ProjectMemberUpdateInput, Prisma.ProjectMemberUncheckedUpdateInput>
+  /**
+   * Choose, which ProjectMember to update.
+   */
+  where: Prisma.ProjectMemberWhereUniqueInput
+}
+
+/**
+ * ProjectMember updateMany
+ */
+export type ProjectMemberUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update ProjectMembers.
+   */
+  data: Prisma.XOR<Prisma.ProjectMemberUpdateManyMutationInput, Prisma.ProjectMemberUncheckedUpdateManyInput>
+  /**
+   * Filter which ProjectMembers to update
+   */
+  where?: Prisma.ProjectMemberWhereInput
+  /**
+   * Limit how many ProjectMembers to update.
+   */
+  limit?: number
+}
+
+/**
+ * ProjectMember updateManyAndReturn
+ */
+export type ProjectMemberUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * The data used to update ProjectMembers.
+   */
+  data: Prisma.XOR<Prisma.ProjectMemberUpdateManyMutationInput, Prisma.ProjectMemberUncheckedUpdateManyInput>
+  /**
+   * Filter which ProjectMembers to update
+   */
+  where?: Prisma.ProjectMemberWhereInput
+  /**
+   * Limit how many ProjectMembers to update.
+   */
+  limit?: number
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberIncludeUpdateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * ProjectMember upsert
+ */
+export type ProjectMemberUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  /**
+   * The filter to search for the ProjectMember to update in case it exists.
+   */
+  where: Prisma.ProjectMemberWhereUniqueInput
+  /**
+   * In case the ProjectMember found by the `where` argument doesn't exist, create a new ProjectMember with this data.
+   */
+  create: Prisma.XOR<Prisma.ProjectMemberCreateInput, Prisma.ProjectMemberUncheckedCreateInput>
+  /**
+   * In case the ProjectMember was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.ProjectMemberUpdateInput, Prisma.ProjectMemberUncheckedUpdateInput>
+}
+
+/**
+ * ProjectMember delete
+ */
+export type ProjectMemberDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  /**
+   * Filter which ProjectMember to delete.
+   */
+  where: Prisma.ProjectMemberWhereUniqueInput
+}
+
+/**
+ * ProjectMember deleteMany
+ */
+export type ProjectMemberDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which ProjectMembers to delete
+   */
+  where?: Prisma.ProjectMemberWhereInput
+  /**
+   * Limit how many ProjectMembers to delete.
+   */
+  limit?: number
+}
+
+/**
+ * ProjectMember without action
+ */
+export type ProjectMemberDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+}
diff --git a/src/generated/client/models/Session.ts b/src/generated/client/models/Session.ts
new file mode 100644
index 00000000..ebea2b47
--- /dev/null
+++ b/src/generated/client/models/Session.ts
@@ -0,0 +1,1310 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `Session` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model Session
+ * 
+ */
+export type SessionModel = runtime.Types.Result.DefaultSelection<Prisma.$SessionPayload>
+
+export type AggregateSession = {
+  _count: SessionCountAggregateOutputType | null
+  _min: SessionMinAggregateOutputType | null
+  _max: SessionMaxAggregateOutputType | null
+}
+
+export type SessionMinAggregateOutputType = {
+  id: string | null
+  sessionToken: string | null
+  userId: string | null
+  expires: Date | null
+}
+
+export type SessionMaxAggregateOutputType = {
+  id: string | null
+  sessionToken: string | null
+  userId: string | null
+  expires: Date | null
+}
+
+export type SessionCountAggregateOutputType = {
+  id: number
+  sessionToken: number
+  userId: number
+  expires: number
+  _all: number
+}
+
+
+export type SessionMinAggregateInputType = {
+  id?: true
+  sessionToken?: true
+  userId?: true
+  expires?: true
+}
+
+export type SessionMaxAggregateInputType = {
+  id?: true
+  sessionToken?: true
+  userId?: true
+  expires?: true
+}
+
+export type SessionCountAggregateInputType = {
+  id?: true
+  sessionToken?: true
+  userId?: true
+  expires?: true
+  _all?: true
+}
+
+export type SessionAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Session to aggregate.
+   */
+  where?: Prisma.SessionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Sessions to fetch.
+   */
+  orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.SessionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Sessions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Sessions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned Sessions
+  **/
+  _count?: true | SessionCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: SessionMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: SessionMaxAggregateInputType
+}
+
+export type GetSessionAggregateType<T extends SessionAggregateArgs> = {
+      [P in keyof T & keyof AggregateSession]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateSession[P]>
+    : Prisma.GetScalarType<T[P], AggregateSession[P]>
+}
+
+
+
+
+export type SessionGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.SessionWhereInput
+  orderBy?: Prisma.SessionOrderByWithAggregationInput | Prisma.SessionOrderByWithAggregationInput[]
+  by: Prisma.SessionScalarFieldEnum[] | Prisma.SessionScalarFieldEnum
+  having?: Prisma.SessionScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: SessionCountAggregateInputType | true
+  _min?: SessionMinAggregateInputType
+  _max?: SessionMaxAggregateInputType
+}
+
+export type SessionGroupByOutputType = {
+  id: string
+  sessionToken: string
+  userId: string
+  expires: Date
+  _count: SessionCountAggregateOutputType | null
+  _min: SessionMinAggregateOutputType | null
+  _max: SessionMaxAggregateOutputType | null
+}
+
+export type GetSessionGroupByPayload<T extends SessionGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<SessionGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof SessionGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], SessionGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], SessionGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type SessionWhereInput = {
+  AND?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[]
+  OR?: Prisma.SessionWhereInput[]
+  NOT?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[]
+  id?: Prisma.StringFilter<"Session"> | string
+  sessionToken?: Prisma.StringFilter<"Session"> | string
+  userId?: Prisma.StringFilter<"Session"> | string
+  expires?: Prisma.DateTimeFilter<"Session"> | Date | string
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+}
+
+export type SessionOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  sessionToken?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  expires?: Prisma.SortOrder
+  user?: Prisma.UserOrderByWithRelationInput
+}
+
+export type SessionWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  sessionToken?: string
+  AND?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[]
+  OR?: Prisma.SessionWhereInput[]
+  NOT?: Prisma.SessionWhereInput | Prisma.SessionWhereInput[]
+  userId?: Prisma.StringFilter<"Session"> | string
+  expires?: Prisma.DateTimeFilter<"Session"> | Date | string
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+}, "id" | "sessionToken">
+
+export type SessionOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  sessionToken?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  expires?: Prisma.SortOrder
+  _count?: Prisma.SessionCountOrderByAggregateInput
+  _max?: Prisma.SessionMaxOrderByAggregateInput
+  _min?: Prisma.SessionMinOrderByAggregateInput
+}
+
+export type SessionScalarWhereWithAggregatesInput = {
+  AND?: Prisma.SessionScalarWhereWithAggregatesInput | Prisma.SessionScalarWhereWithAggregatesInput[]
+  OR?: Prisma.SessionScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.SessionScalarWhereWithAggregatesInput | Prisma.SessionScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"Session"> | string
+  sessionToken?: Prisma.StringWithAggregatesFilter<"Session"> | string
+  userId?: Prisma.StringWithAggregatesFilter<"Session"> | string
+  expires?: Prisma.DateTimeWithAggregatesFilter<"Session"> | Date | string
+}
+
+export type SessionCreateInput = {
+  id?: string
+  sessionToken: string
+  expires: Date | string
+  user: Prisma.UserCreateNestedOneWithoutSessionsInput
+}
+
+export type SessionUncheckedCreateInput = {
+  id?: string
+  sessionToken: string
+  userId: string
+  expires: Date | string
+}
+
+export type SessionUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  sessionToken?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  user?: Prisma.UserUpdateOneRequiredWithoutSessionsNestedInput
+}
+
+export type SessionUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  sessionToken?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SessionCreateManyInput = {
+  id?: string
+  sessionToken: string
+  userId: string
+  expires: Date | string
+}
+
+export type SessionUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  sessionToken?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SessionUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  sessionToken?: Prisma.StringFieldUpdateOperationsInput | string
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SessionListRelationFilter = {
+  every?: Prisma.SessionWhereInput
+  some?: Prisma.SessionWhereInput
+  none?: Prisma.SessionWhereInput
+}
+
+export type SessionOrderByRelationAggregateInput = {
+  _count?: Prisma.SortOrder
+}
+
+export type SessionCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  sessionToken?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  expires?: Prisma.SortOrder
+}
+
+export type SessionMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  sessionToken?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  expires?: Prisma.SortOrder
+}
+
+export type SessionMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  sessionToken?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  expires?: Prisma.SortOrder
+}
+
+export type SessionCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.SessionCreateManyUserInputEnvelope
+  connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[]
+}
+
+export type SessionUncheckedCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.SessionCreateManyUserInputEnvelope
+  connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[]
+}
+
+export type SessionUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.SessionUpsertWithWhereUniqueWithoutUserInput | Prisma.SessionUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.SessionCreateManyUserInputEnvelope
+  set?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[]
+  disconnect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[]
+  delete?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[]
+  connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[]
+  update?: Prisma.SessionUpdateWithWhereUniqueWithoutUserInput | Prisma.SessionUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.SessionUpdateManyWithWhereWithoutUserInput | Prisma.SessionUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[]
+}
+
+export type SessionUncheckedUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput> | Prisma.SessionCreateWithoutUserInput[] | Prisma.SessionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.SessionCreateOrConnectWithoutUserInput | Prisma.SessionCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.SessionUpsertWithWhereUniqueWithoutUserInput | Prisma.SessionUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.SessionCreateManyUserInputEnvelope
+  set?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[]
+  disconnect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[]
+  delete?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[]
+  connect?: Prisma.SessionWhereUniqueInput | Prisma.SessionWhereUniqueInput[]
+  update?: Prisma.SessionUpdateWithWhereUniqueWithoutUserInput | Prisma.SessionUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.SessionUpdateManyWithWhereWithoutUserInput | Prisma.SessionUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[]
+}
+
+export type SessionCreateWithoutUserInput = {
+  id?: string
+  sessionToken: string
+  expires: Date | string
+}
+
+export type SessionUncheckedCreateWithoutUserInput = {
+  id?: string
+  sessionToken: string
+  expires: Date | string
+}
+
+export type SessionCreateOrConnectWithoutUserInput = {
+  where: Prisma.SessionWhereUniqueInput
+  create: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput>
+}
+
+export type SessionCreateManyUserInputEnvelope = {
+  data: Prisma.SessionCreateManyUserInput | Prisma.SessionCreateManyUserInput[]
+  skipDuplicates?: boolean
+}
+
+export type SessionUpsertWithWhereUniqueWithoutUserInput = {
+  where: Prisma.SessionWhereUniqueInput
+  update: Prisma.XOR<Prisma.SessionUpdateWithoutUserInput, Prisma.SessionUncheckedUpdateWithoutUserInput>
+  create: Prisma.XOR<Prisma.SessionCreateWithoutUserInput, Prisma.SessionUncheckedCreateWithoutUserInput>
+}
+
+export type SessionUpdateWithWhereUniqueWithoutUserInput = {
+  where: Prisma.SessionWhereUniqueInput
+  data: Prisma.XOR<Prisma.SessionUpdateWithoutUserInput, Prisma.SessionUncheckedUpdateWithoutUserInput>
+}
+
+export type SessionUpdateManyWithWhereWithoutUserInput = {
+  where: Prisma.SessionScalarWhereInput
+  data: Prisma.XOR<Prisma.SessionUpdateManyMutationInput, Prisma.SessionUncheckedUpdateManyWithoutUserInput>
+}
+
+export type SessionScalarWhereInput = {
+  AND?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[]
+  OR?: Prisma.SessionScalarWhereInput[]
+  NOT?: Prisma.SessionScalarWhereInput | Prisma.SessionScalarWhereInput[]
+  id?: Prisma.StringFilter<"Session"> | string
+  sessionToken?: Prisma.StringFilter<"Session"> | string
+  userId?: Prisma.StringFilter<"Session"> | string
+  expires?: Prisma.DateTimeFilter<"Session"> | Date | string
+}
+
+export type SessionCreateManyUserInput = {
+  id?: string
+  sessionToken: string
+  expires: Date | string
+}
+
+export type SessionUpdateWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  sessionToken?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SessionUncheckedUpdateWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  sessionToken?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type SessionUncheckedUpdateManyWithoutUserInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  sessionToken?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+
+
+export type SessionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  sessionToken?: boolean
+  userId?: boolean
+  expires?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["session"]>
+
+export type SessionSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  sessionToken?: boolean
+  userId?: boolean
+  expires?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["session"]>
+
+export type SessionSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  sessionToken?: boolean
+  userId?: boolean
+  expires?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["session"]>
+
+export type SessionSelectScalar = {
+  id?: boolean
+  sessionToken?: boolean
+  userId?: boolean
+  expires?: boolean
+}
+
+export type SessionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "sessionToken" | "userId" | "expires", ExtArgs["result"]["session"]>
+export type SessionInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+export type SessionIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+export type SessionIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+
+export type $SessionPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "Session"
+  objects: {
+    user: Prisma.$UserPayload<ExtArgs>
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    sessionToken: string
+    userId: string
+    expires: Date
+  }, ExtArgs["result"]["session"]>
+  composites: {}
+}
+
+export type SessionGetPayload<S extends boolean | null | undefined | SessionDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$SessionPayload, S>
+
+export type SessionCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<SessionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: SessionCountAggregateInputType | true
+  }
+
+export interface SessionDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Session'], meta: { name: 'Session' } }
+  /**
+   * Find zero or one Session that matches the filter.
+   * @param {SessionFindUniqueArgs} args - Arguments to find a Session
+   * @example
+   * // Get one Session
+   * const session = await prisma.session.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends SessionFindUniqueArgs>(args: Prisma.SelectSubset<T, SessionFindUniqueArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one Session that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {SessionFindUniqueOrThrowArgs} args - Arguments to find a Session
+   * @example
+   * // Get one Session
+   * const session = await prisma.session.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends SessionFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, SessionFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Session that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SessionFindFirstArgs} args - Arguments to find a Session
+   * @example
+   * // Get one Session
+   * const session = await prisma.session.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends SessionFindFirstArgs>(args?: Prisma.SelectSubset<T, SessionFindFirstArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Session that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SessionFindFirstOrThrowArgs} args - Arguments to find a Session
+   * @example
+   * // Get one Session
+   * const session = await prisma.session.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends SessionFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, SessionFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more Sessions that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SessionFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all Sessions
+   * const sessions = await prisma.session.findMany()
+   * 
+   * // Get first 10 Sessions
+   * const sessions = await prisma.session.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const sessionWithIdOnly = await prisma.session.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends SessionFindManyArgs>(args?: Prisma.SelectSubset<T, SessionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a Session.
+   * @param {SessionCreateArgs} args - Arguments to create a Session.
+   * @example
+   * // Create one Session
+   * const Session = await prisma.session.create({
+   *   data: {
+   *     // ... data to create a Session
+   *   }
+   * })
+   * 
+   */
+  create<T extends SessionCreateArgs>(args: Prisma.SelectSubset<T, SessionCreateArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many Sessions.
+   * @param {SessionCreateManyArgs} args - Arguments to create many Sessions.
+   * @example
+   * // Create many Sessions
+   * const session = await prisma.session.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends SessionCreateManyArgs>(args?: Prisma.SelectSubset<T, SessionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many Sessions and returns the data saved in the database.
+   * @param {SessionCreateManyAndReturnArgs} args - Arguments to create many Sessions.
+   * @example
+   * // Create many Sessions
+   * const session = await prisma.session.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many Sessions and only return the `id`
+   * const sessionWithIdOnly = await prisma.session.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends SessionCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, SessionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a Session.
+   * @param {SessionDeleteArgs} args - Arguments to delete one Session.
+   * @example
+   * // Delete one Session
+   * const Session = await prisma.session.delete({
+   *   where: {
+   *     // ... filter to delete one Session
+   *   }
+   * })
+   * 
+   */
+  delete<T extends SessionDeleteArgs>(args: Prisma.SelectSubset<T, SessionDeleteArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one Session.
+   * @param {SessionUpdateArgs} args - Arguments to update one Session.
+   * @example
+   * // Update one Session
+   * const session = await prisma.session.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends SessionUpdateArgs>(args: Prisma.SelectSubset<T, SessionUpdateArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more Sessions.
+   * @param {SessionDeleteManyArgs} args - Arguments to filter Sessions to delete.
+   * @example
+   * // Delete a few Sessions
+   * const { count } = await prisma.session.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends SessionDeleteManyArgs>(args?: Prisma.SelectSubset<T, SessionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Sessions.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SessionUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many Sessions
+   * const session = await prisma.session.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends SessionUpdateManyArgs>(args: Prisma.SelectSubset<T, SessionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Sessions and returns the data updated in the database.
+   * @param {SessionUpdateManyAndReturnArgs} args - Arguments to update many Sessions.
+   * @example
+   * // Update many Sessions
+   * const session = await prisma.session.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more Sessions and only return the `id`
+   * const sessionWithIdOnly = await prisma.session.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends SessionUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, SessionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one Session.
+   * @param {SessionUpsertArgs} args - Arguments to update or create a Session.
+   * @example
+   * // Update or create a Session
+   * const session = await prisma.session.upsert({
+   *   create: {
+   *     // ... data to create a Session
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the Session we want to update
+   *   }
+   * })
+   */
+  upsert<T extends SessionUpsertArgs>(args: Prisma.SelectSubset<T, SessionUpsertArgs<ExtArgs>>): Prisma.Prisma__SessionClient<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of Sessions.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SessionCountArgs} args - Arguments to filter Sessions to count.
+   * @example
+   * // Count the number of Sessions
+   * const count = await prisma.session.count({
+   *   where: {
+   *     // ... the filter for the Sessions we want to count
+   *   }
+   * })
+  **/
+  count<T extends SessionCountArgs>(
+    args?: Prisma.Subset<T, SessionCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], SessionCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a Session.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SessionAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends SessionAggregateArgs>(args: Prisma.Subset<T, SessionAggregateArgs>): Prisma.PrismaPromise<GetSessionAggregateType<T>>
+
+  /**
+   * Group by Session.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {SessionGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends SessionGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: SessionGroupByArgs['orderBy'] }
+      : { orderBy?: SessionGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, SessionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSessionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the Session model
+ */
+readonly fields: SessionFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for Session.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__SessionClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  user<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the Session model
+ */
+export interface SessionFieldRefs {
+  readonly id: Prisma.FieldRef<"Session", 'String'>
+  readonly sessionToken: Prisma.FieldRef<"Session", 'String'>
+  readonly userId: Prisma.FieldRef<"Session", 'String'>
+  readonly expires: Prisma.FieldRef<"Session", 'DateTime'>
+}
+    
+
+// Custom InputTypes
+/**
+ * Session findUnique
+ */
+export type SessionFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+  /**
+   * Filter, which Session to fetch.
+   */
+  where: Prisma.SessionWhereUniqueInput
+}
+
+/**
+ * Session findUniqueOrThrow
+ */
+export type SessionFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+  /**
+   * Filter, which Session to fetch.
+   */
+  where: Prisma.SessionWhereUniqueInput
+}
+
+/**
+ * Session findFirst
+ */
+export type SessionFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+  /**
+   * Filter, which Session to fetch.
+   */
+  where?: Prisma.SessionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Sessions to fetch.
+   */
+  orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Sessions.
+   */
+  cursor?: Prisma.SessionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Sessions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Sessions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Sessions.
+   */
+  distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[]
+}
+
+/**
+ * Session findFirstOrThrow
+ */
+export type SessionFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+  /**
+   * Filter, which Session to fetch.
+   */
+  where?: Prisma.SessionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Sessions to fetch.
+   */
+  orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Sessions.
+   */
+  cursor?: Prisma.SessionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Sessions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Sessions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Sessions.
+   */
+  distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[]
+}
+
+/**
+ * Session findMany
+ */
+export type SessionFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+  /**
+   * Filter, which Sessions to fetch.
+   */
+  where?: Prisma.SessionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Sessions to fetch.
+   */
+  orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing Sessions.
+   */
+  cursor?: Prisma.SessionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Sessions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Sessions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Sessions.
+   */
+  distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[]
+}
+
+/**
+ * Session create
+ */
+export type SessionCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+  /**
+   * The data needed to create a Session.
+   */
+  data: Prisma.XOR<Prisma.SessionCreateInput, Prisma.SessionUncheckedCreateInput>
+}
+
+/**
+ * Session createMany
+ */
+export type SessionCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many Sessions.
+   */
+  data: Prisma.SessionCreateManyInput | Prisma.SessionCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * Session createManyAndReturn
+ */
+export type SessionCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * The data used to create many Sessions.
+   */
+  data: Prisma.SessionCreateManyInput | Prisma.SessionCreateManyInput[]
+  skipDuplicates?: boolean
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionIncludeCreateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * Session update
+ */
+export type SessionUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+  /**
+   * The data needed to update a Session.
+   */
+  data: Prisma.XOR<Prisma.SessionUpdateInput, Prisma.SessionUncheckedUpdateInput>
+  /**
+   * Choose, which Session to update.
+   */
+  where: Prisma.SessionWhereUniqueInput
+}
+
+/**
+ * Session updateMany
+ */
+export type SessionUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update Sessions.
+   */
+  data: Prisma.XOR<Prisma.SessionUpdateManyMutationInput, Prisma.SessionUncheckedUpdateManyInput>
+  /**
+   * Filter which Sessions to update
+   */
+  where?: Prisma.SessionWhereInput
+  /**
+   * Limit how many Sessions to update.
+   */
+  limit?: number
+}
+
+/**
+ * Session updateManyAndReturn
+ */
+export type SessionUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * The data used to update Sessions.
+   */
+  data: Prisma.XOR<Prisma.SessionUpdateManyMutationInput, Prisma.SessionUncheckedUpdateManyInput>
+  /**
+   * Filter which Sessions to update
+   */
+  where?: Prisma.SessionWhereInput
+  /**
+   * Limit how many Sessions to update.
+   */
+  limit?: number
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionIncludeUpdateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * Session upsert
+ */
+export type SessionUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+  /**
+   * The filter to search for the Session to update in case it exists.
+   */
+  where: Prisma.SessionWhereUniqueInput
+  /**
+   * In case the Session found by the `where` argument doesn't exist, create a new Session with this data.
+   */
+  create: Prisma.XOR<Prisma.SessionCreateInput, Prisma.SessionUncheckedCreateInput>
+  /**
+   * In case the Session was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.SessionUpdateInput, Prisma.SessionUncheckedUpdateInput>
+}
+
+/**
+ * Session delete
+ */
+export type SessionDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+  /**
+   * Filter which Session to delete.
+   */
+  where: Prisma.SessionWhereUniqueInput
+}
+
+/**
+ * Session deleteMany
+ */
+export type SessionDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Sessions to delete
+   */
+  where?: Prisma.SessionWhereInput
+  /**
+   * Limit how many Sessions to delete.
+   */
+  limit?: number
+}
+
+/**
+ * Session without action
+ */
+export type SessionDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+}
diff --git a/src/generated/client/models/Transaction.ts b/src/generated/client/models/Transaction.ts
new file mode 100644
index 00000000..1ef403af
--- /dev/null
+++ b/src/generated/client/models/Transaction.ts
@@ -0,0 +1,1388 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `Transaction` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model Transaction
+ * 
+ */
+export type TransactionModel = runtime.Types.Result.DefaultSelection<Prisma.$TransactionPayload>
+
+export type AggregateTransaction = {
+  _count: TransactionCountAggregateOutputType | null
+  _avg: TransactionAvgAggregateOutputType | null
+  _sum: TransactionSumAggregateOutputType | null
+  _min: TransactionMinAggregateOutputType | null
+  _max: TransactionMaxAggregateOutputType | null
+}
+
+export type TransactionAvgAggregateOutputType = {
+  id: number | null
+}
+
+export type TransactionSumAggregateOutputType = {
+  id: number | null
+}
+
+export type TransactionMinAggregateOutputType = {
+  id: number | null
+  userId: string | null
+  provider: $Enums.SubscriptionProvider | null
+  transactionId: string | null
+  createdAt: Date | null
+}
+
+export type TransactionMaxAggregateOutputType = {
+  id: number | null
+  userId: string | null
+  provider: $Enums.SubscriptionProvider | null
+  transactionId: string | null
+  createdAt: Date | null
+}
+
+export type TransactionCountAggregateOutputType = {
+  id: number
+  userId: number
+  provider: number
+  transactionId: number
+  createdAt: number
+  _all: number
+}
+
+
+export type TransactionAvgAggregateInputType = {
+  id?: true
+}
+
+export type TransactionSumAggregateInputType = {
+  id?: true
+}
+
+export type TransactionMinAggregateInputType = {
+  id?: true
+  userId?: true
+  provider?: true
+  transactionId?: true
+  createdAt?: true
+}
+
+export type TransactionMaxAggregateInputType = {
+  id?: true
+  userId?: true
+  provider?: true
+  transactionId?: true
+  createdAt?: true
+}
+
+export type TransactionCountAggregateInputType = {
+  id?: true
+  userId?: true
+  provider?: true
+  transactionId?: true
+  createdAt?: true
+  _all?: true
+}
+
+export type TransactionAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Transaction to aggregate.
+   */
+  where?: Prisma.TransactionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Transactions to fetch.
+   */
+  orderBy?: Prisma.TransactionOrderByWithRelationInput | Prisma.TransactionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.TransactionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Transactions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Transactions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned Transactions
+  **/
+  _count?: true | TransactionCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to average
+  **/
+  _avg?: TransactionAvgAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to sum
+  **/
+  _sum?: TransactionSumAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: TransactionMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: TransactionMaxAggregateInputType
+}
+
+export type GetTransactionAggregateType<T extends TransactionAggregateArgs> = {
+      [P in keyof T & keyof AggregateTransaction]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateTransaction[P]>
+    : Prisma.GetScalarType<T[P], AggregateTransaction[P]>
+}
+
+
+
+
+export type TransactionGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.TransactionWhereInput
+  orderBy?: Prisma.TransactionOrderByWithAggregationInput | Prisma.TransactionOrderByWithAggregationInput[]
+  by: Prisma.TransactionScalarFieldEnum[] | Prisma.TransactionScalarFieldEnum
+  having?: Prisma.TransactionScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: TransactionCountAggregateInputType | true
+  _avg?: TransactionAvgAggregateInputType
+  _sum?: TransactionSumAggregateInputType
+  _min?: TransactionMinAggregateInputType
+  _max?: TransactionMaxAggregateInputType
+}
+
+export type TransactionGroupByOutputType = {
+  id: number
+  userId: string
+  provider: $Enums.SubscriptionProvider
+  transactionId: string
+  createdAt: Date
+  _count: TransactionCountAggregateOutputType | null
+  _avg: TransactionAvgAggregateOutputType | null
+  _sum: TransactionSumAggregateOutputType | null
+  _min: TransactionMinAggregateOutputType | null
+  _max: TransactionMaxAggregateOutputType | null
+}
+
+export type GetTransactionGroupByPayload<T extends TransactionGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<TransactionGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof TransactionGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], TransactionGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], TransactionGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type TransactionWhereInput = {
+  AND?: Prisma.TransactionWhereInput | Prisma.TransactionWhereInput[]
+  OR?: Prisma.TransactionWhereInput[]
+  NOT?: Prisma.TransactionWhereInput | Prisma.TransactionWhereInput[]
+  id?: Prisma.IntFilter<"Transaction"> | number
+  userId?: Prisma.StringFilter<"Transaction"> | string
+  provider?: Prisma.EnumSubscriptionProviderFilter<"Transaction"> | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringFilter<"Transaction"> | string
+  createdAt?: Prisma.DateTimeFilter<"Transaction"> | Date | string
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+}
+
+export type TransactionOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  provider?: Prisma.SortOrder
+  transactionId?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  user?: Prisma.UserOrderByWithRelationInput
+}
+
+export type TransactionWhereUniqueInput = Prisma.AtLeast<{
+  id?: number
+  AND?: Prisma.TransactionWhereInput | Prisma.TransactionWhereInput[]
+  OR?: Prisma.TransactionWhereInput[]
+  NOT?: Prisma.TransactionWhereInput | Prisma.TransactionWhereInput[]
+  userId?: Prisma.StringFilter<"Transaction"> | string
+  provider?: Prisma.EnumSubscriptionProviderFilter<"Transaction"> | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringFilter<"Transaction"> | string
+  createdAt?: Prisma.DateTimeFilter<"Transaction"> | Date | string
+  user?: Prisma.XOR<Prisma.UserScalarRelationFilter, Prisma.UserWhereInput>
+}, "id">
+
+export type TransactionOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  provider?: Prisma.SortOrder
+  transactionId?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  _count?: Prisma.TransactionCountOrderByAggregateInput
+  _avg?: Prisma.TransactionAvgOrderByAggregateInput
+  _max?: Prisma.TransactionMaxOrderByAggregateInput
+  _min?: Prisma.TransactionMinOrderByAggregateInput
+  _sum?: Prisma.TransactionSumOrderByAggregateInput
+}
+
+export type TransactionScalarWhereWithAggregatesInput = {
+  AND?: Prisma.TransactionScalarWhereWithAggregatesInput | Prisma.TransactionScalarWhereWithAggregatesInput[]
+  OR?: Prisma.TransactionScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.TransactionScalarWhereWithAggregatesInput | Prisma.TransactionScalarWhereWithAggregatesInput[]
+  id?: Prisma.IntWithAggregatesFilter<"Transaction"> | number
+  userId?: Prisma.StringWithAggregatesFilter<"Transaction"> | string
+  provider?: Prisma.EnumSubscriptionProviderWithAggregatesFilter<"Transaction"> | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringWithAggregatesFilter<"Transaction"> | string
+  createdAt?: Prisma.DateTimeWithAggregatesFilter<"Transaction"> | Date | string
+}
+
+export type TransactionCreateInput = {
+  provider: $Enums.SubscriptionProvider
+  transactionId: string
+  createdAt?: Date | string
+  user: Prisma.UserCreateNestedOneWithoutTransactionsInput
+}
+
+export type TransactionUncheckedCreateInput = {
+  id?: number
+  userId: string
+  provider: $Enums.SubscriptionProvider
+  transactionId: string
+  createdAt?: Date | string
+}
+
+export type TransactionUpdateInput = {
+  provider?: Prisma.EnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  user?: Prisma.UserUpdateOneRequiredWithoutTransactionsNestedInput
+}
+
+export type TransactionUncheckedUpdateInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  provider?: Prisma.EnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type TransactionCreateManyInput = {
+  id?: number
+  userId: string
+  provider: $Enums.SubscriptionProvider
+  transactionId: string
+  createdAt?: Date | string
+}
+
+export type TransactionUpdateManyMutationInput = {
+  provider?: Prisma.EnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type TransactionUncheckedUpdateManyInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  userId?: Prisma.StringFieldUpdateOperationsInput | string
+  provider?: Prisma.EnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type TransactionListRelationFilter = {
+  every?: Prisma.TransactionWhereInput
+  some?: Prisma.TransactionWhereInput
+  none?: Prisma.TransactionWhereInput
+}
+
+export type TransactionOrderByRelationAggregateInput = {
+  _count?: Prisma.SortOrder
+}
+
+export type TransactionCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  provider?: Prisma.SortOrder
+  transactionId?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+}
+
+export type TransactionAvgOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+}
+
+export type TransactionMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  provider?: Prisma.SortOrder
+  transactionId?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+}
+
+export type TransactionMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  userId?: Prisma.SortOrder
+  provider?: Prisma.SortOrder
+  transactionId?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+}
+
+export type TransactionSumOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+}
+
+export type TransactionCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.TransactionCreateWithoutUserInput, Prisma.TransactionUncheckedCreateWithoutUserInput> | Prisma.TransactionCreateWithoutUserInput[] | Prisma.TransactionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.TransactionCreateOrConnectWithoutUserInput | Prisma.TransactionCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.TransactionCreateManyUserInputEnvelope
+  connect?: Prisma.TransactionWhereUniqueInput | Prisma.TransactionWhereUniqueInput[]
+}
+
+export type TransactionUncheckedCreateNestedManyWithoutUserInput = {
+  create?: Prisma.XOR<Prisma.TransactionCreateWithoutUserInput, Prisma.TransactionUncheckedCreateWithoutUserInput> | Prisma.TransactionCreateWithoutUserInput[] | Prisma.TransactionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.TransactionCreateOrConnectWithoutUserInput | Prisma.TransactionCreateOrConnectWithoutUserInput[]
+  createMany?: Prisma.TransactionCreateManyUserInputEnvelope
+  connect?: Prisma.TransactionWhereUniqueInput | Prisma.TransactionWhereUniqueInput[]
+}
+
+export type TransactionUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.TransactionCreateWithoutUserInput, Prisma.TransactionUncheckedCreateWithoutUserInput> | Prisma.TransactionCreateWithoutUserInput[] | Prisma.TransactionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.TransactionCreateOrConnectWithoutUserInput | Prisma.TransactionCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.TransactionUpsertWithWhereUniqueWithoutUserInput | Prisma.TransactionUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.TransactionCreateManyUserInputEnvelope
+  set?: Prisma.TransactionWhereUniqueInput | Prisma.TransactionWhereUniqueInput[]
+  disconnect?: Prisma.TransactionWhereUniqueInput | Prisma.TransactionWhereUniqueInput[]
+  delete?: Prisma.TransactionWhereUniqueInput | Prisma.TransactionWhereUniqueInput[]
+  connect?: Prisma.TransactionWhereUniqueInput | Prisma.TransactionWhereUniqueInput[]
+  update?: Prisma.TransactionUpdateWithWhereUniqueWithoutUserInput | Prisma.TransactionUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.TransactionUpdateManyWithWhereWithoutUserInput | Prisma.TransactionUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.TransactionScalarWhereInput | Prisma.TransactionScalarWhereInput[]
+}
+
+export type TransactionUncheckedUpdateManyWithoutUserNestedInput = {
+  create?: Prisma.XOR<Prisma.TransactionCreateWithoutUserInput, Prisma.TransactionUncheckedCreateWithoutUserInput> | Prisma.TransactionCreateWithoutUserInput[] | Prisma.TransactionUncheckedCreateWithoutUserInput[]
+  connectOrCreate?: Prisma.TransactionCreateOrConnectWithoutUserInput | Prisma.TransactionCreateOrConnectWithoutUserInput[]
+  upsert?: Prisma.TransactionUpsertWithWhereUniqueWithoutUserInput | Prisma.TransactionUpsertWithWhereUniqueWithoutUserInput[]
+  createMany?: Prisma.TransactionCreateManyUserInputEnvelope
+  set?: Prisma.TransactionWhereUniqueInput | Prisma.TransactionWhereUniqueInput[]
+  disconnect?: Prisma.TransactionWhereUniqueInput | Prisma.TransactionWhereUniqueInput[]
+  delete?: Prisma.TransactionWhereUniqueInput | Prisma.TransactionWhereUniqueInput[]
+  connect?: Prisma.TransactionWhereUniqueInput | Prisma.TransactionWhereUniqueInput[]
+  update?: Prisma.TransactionUpdateWithWhereUniqueWithoutUserInput | Prisma.TransactionUpdateWithWhereUniqueWithoutUserInput[]
+  updateMany?: Prisma.TransactionUpdateManyWithWhereWithoutUserInput | Prisma.TransactionUpdateManyWithWhereWithoutUserInput[]
+  deleteMany?: Prisma.TransactionScalarWhereInput | Prisma.TransactionScalarWhereInput[]
+}
+
+export type EnumSubscriptionProviderFieldUpdateOperationsInput = {
+  set?: $Enums.SubscriptionProvider
+}
+
+export type TransactionCreateWithoutUserInput = {
+  provider: $Enums.SubscriptionProvider
+  transactionId: string
+  createdAt?: Date | string
+}
+
+export type TransactionUncheckedCreateWithoutUserInput = {
+  id?: number
+  provider: $Enums.SubscriptionProvider
+  transactionId: string
+  createdAt?: Date | string
+}
+
+export type TransactionCreateOrConnectWithoutUserInput = {
+  where: Prisma.TransactionWhereUniqueInput
+  create: Prisma.XOR<Prisma.TransactionCreateWithoutUserInput, Prisma.TransactionUncheckedCreateWithoutUserInput>
+}
+
+export type TransactionCreateManyUserInputEnvelope = {
+  data: Prisma.TransactionCreateManyUserInput | Prisma.TransactionCreateManyUserInput[]
+  skipDuplicates?: boolean
+}
+
+export type TransactionUpsertWithWhereUniqueWithoutUserInput = {
+  where: Prisma.TransactionWhereUniqueInput
+  update: Prisma.XOR<Prisma.TransactionUpdateWithoutUserInput, Prisma.TransactionUncheckedUpdateWithoutUserInput>
+  create: Prisma.XOR<Prisma.TransactionCreateWithoutUserInput, Prisma.TransactionUncheckedCreateWithoutUserInput>
+}
+
+export type TransactionUpdateWithWhereUniqueWithoutUserInput = {
+  where: Prisma.TransactionWhereUniqueInput
+  data: Prisma.XOR<Prisma.TransactionUpdateWithoutUserInput, Prisma.TransactionUncheckedUpdateWithoutUserInput>
+}
+
+export type TransactionUpdateManyWithWhereWithoutUserInput = {
+  where: Prisma.TransactionScalarWhereInput
+  data: Prisma.XOR<Prisma.TransactionUpdateManyMutationInput, Prisma.TransactionUncheckedUpdateManyWithoutUserInput>
+}
+
+export type TransactionScalarWhereInput = {
+  AND?: Prisma.TransactionScalarWhereInput | Prisma.TransactionScalarWhereInput[]
+  OR?: Prisma.TransactionScalarWhereInput[]
+  NOT?: Prisma.TransactionScalarWhereInput | Prisma.TransactionScalarWhereInput[]
+  id?: Prisma.IntFilter<"Transaction"> | number
+  userId?: Prisma.StringFilter<"Transaction"> | string
+  provider?: Prisma.EnumSubscriptionProviderFilter<"Transaction"> | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringFilter<"Transaction"> | string
+  createdAt?: Prisma.DateTimeFilter<"Transaction"> | Date | string
+}
+
+export type TransactionCreateManyUserInput = {
+  id?: number
+  provider: $Enums.SubscriptionProvider
+  transactionId: string
+  createdAt?: Date | string
+}
+
+export type TransactionUpdateWithoutUserInput = {
+  provider?: Prisma.EnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type TransactionUncheckedUpdateWithoutUserInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  provider?: Prisma.EnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type TransactionUncheckedUpdateManyWithoutUserInput = {
+  id?: Prisma.IntFieldUpdateOperationsInput | number
+  provider?: Prisma.EnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider
+  transactionId?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+
+
+export type TransactionSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  userId?: boolean
+  provider?: boolean
+  transactionId?: boolean
+  createdAt?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["transaction"]>
+
+export type TransactionSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  userId?: boolean
+  provider?: boolean
+  transactionId?: boolean
+  createdAt?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["transaction"]>
+
+export type TransactionSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  userId?: boolean
+  provider?: boolean
+  transactionId?: boolean
+  createdAt?: boolean
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["transaction"]>
+
+export type TransactionSelectScalar = {
+  id?: boolean
+  userId?: boolean
+  provider?: boolean
+  transactionId?: boolean
+  createdAt?: boolean
+}
+
+export type TransactionOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "userId" | "provider" | "transactionId" | "createdAt", ExtArgs["result"]["transaction"]>
+export type TransactionInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+export type TransactionIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+export type TransactionIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  user?: boolean | Prisma.UserDefaultArgs<ExtArgs>
+}
+
+export type $TransactionPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "Transaction"
+  objects: {
+    user: Prisma.$UserPayload<ExtArgs>
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: number
+    userId: string
+    provider: $Enums.SubscriptionProvider
+    transactionId: string
+    createdAt: Date
+  }, ExtArgs["result"]["transaction"]>
+  composites: {}
+}
+
+export type TransactionGetPayload<S extends boolean | null | undefined | TransactionDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$TransactionPayload, S>
+
+export type TransactionCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<TransactionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: TransactionCountAggregateInputType | true
+  }
+
+export interface TransactionDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Transaction'], meta: { name: 'Transaction' } }
+  /**
+   * Find zero or one Transaction that matches the filter.
+   * @param {TransactionFindUniqueArgs} args - Arguments to find a Transaction
+   * @example
+   * // Get one Transaction
+   * const transaction = await prisma.transaction.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends TransactionFindUniqueArgs>(args: Prisma.SelectSubset<T, TransactionFindUniqueArgs<ExtArgs>>): Prisma.Prisma__TransactionClient<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one Transaction that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {TransactionFindUniqueOrThrowArgs} args - Arguments to find a Transaction
+   * @example
+   * // Get one Transaction
+   * const transaction = await prisma.transaction.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends TransactionFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, TransactionFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__TransactionClient<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Transaction that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {TransactionFindFirstArgs} args - Arguments to find a Transaction
+   * @example
+   * // Get one Transaction
+   * const transaction = await prisma.transaction.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends TransactionFindFirstArgs>(args?: Prisma.SelectSubset<T, TransactionFindFirstArgs<ExtArgs>>): Prisma.Prisma__TransactionClient<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first Transaction that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {TransactionFindFirstOrThrowArgs} args - Arguments to find a Transaction
+   * @example
+   * // Get one Transaction
+   * const transaction = await prisma.transaction.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends TransactionFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, TransactionFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__TransactionClient<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more Transactions that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {TransactionFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all Transactions
+   * const transactions = await prisma.transaction.findMany()
+   * 
+   * // Get first 10 Transactions
+   * const transactions = await prisma.transaction.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const transactionWithIdOnly = await prisma.transaction.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends TransactionFindManyArgs>(args?: Prisma.SelectSubset<T, TransactionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a Transaction.
+   * @param {TransactionCreateArgs} args - Arguments to create a Transaction.
+   * @example
+   * // Create one Transaction
+   * const Transaction = await prisma.transaction.create({
+   *   data: {
+   *     // ... data to create a Transaction
+   *   }
+   * })
+   * 
+   */
+  create<T extends TransactionCreateArgs>(args: Prisma.SelectSubset<T, TransactionCreateArgs<ExtArgs>>): Prisma.Prisma__TransactionClient<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many Transactions.
+   * @param {TransactionCreateManyArgs} args - Arguments to create many Transactions.
+   * @example
+   * // Create many Transactions
+   * const transaction = await prisma.transaction.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends TransactionCreateManyArgs>(args?: Prisma.SelectSubset<T, TransactionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many Transactions and returns the data saved in the database.
+   * @param {TransactionCreateManyAndReturnArgs} args - Arguments to create many Transactions.
+   * @example
+   * // Create many Transactions
+   * const transaction = await prisma.transaction.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many Transactions and only return the `id`
+   * const transactionWithIdOnly = await prisma.transaction.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends TransactionCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, TransactionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a Transaction.
+   * @param {TransactionDeleteArgs} args - Arguments to delete one Transaction.
+   * @example
+   * // Delete one Transaction
+   * const Transaction = await prisma.transaction.delete({
+   *   where: {
+   *     // ... filter to delete one Transaction
+   *   }
+   * })
+   * 
+   */
+  delete<T extends TransactionDeleteArgs>(args: Prisma.SelectSubset<T, TransactionDeleteArgs<ExtArgs>>): Prisma.Prisma__TransactionClient<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one Transaction.
+   * @param {TransactionUpdateArgs} args - Arguments to update one Transaction.
+   * @example
+   * // Update one Transaction
+   * const transaction = await prisma.transaction.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends TransactionUpdateArgs>(args: Prisma.SelectSubset<T, TransactionUpdateArgs<ExtArgs>>): Prisma.Prisma__TransactionClient<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more Transactions.
+   * @param {TransactionDeleteManyArgs} args - Arguments to filter Transactions to delete.
+   * @example
+   * // Delete a few Transactions
+   * const { count } = await prisma.transaction.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends TransactionDeleteManyArgs>(args?: Prisma.SelectSubset<T, TransactionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Transactions.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {TransactionUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many Transactions
+   * const transaction = await prisma.transaction.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends TransactionUpdateManyArgs>(args: Prisma.SelectSubset<T, TransactionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Transactions and returns the data updated in the database.
+   * @param {TransactionUpdateManyAndReturnArgs} args - Arguments to update many Transactions.
+   * @example
+   * // Update many Transactions
+   * const transaction = await prisma.transaction.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more Transactions and only return the `id`
+   * const transactionWithIdOnly = await prisma.transaction.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends TransactionUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, TransactionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one Transaction.
+   * @param {TransactionUpsertArgs} args - Arguments to update or create a Transaction.
+   * @example
+   * // Update or create a Transaction
+   * const transaction = await prisma.transaction.upsert({
+   *   create: {
+   *     // ... data to create a Transaction
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the Transaction we want to update
+   *   }
+   * })
+   */
+  upsert<T extends TransactionUpsertArgs>(args: Prisma.SelectSubset<T, TransactionUpsertArgs<ExtArgs>>): Prisma.Prisma__TransactionClient<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of Transactions.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {TransactionCountArgs} args - Arguments to filter Transactions to count.
+   * @example
+   * // Count the number of Transactions
+   * const count = await prisma.transaction.count({
+   *   where: {
+   *     // ... the filter for the Transactions we want to count
+   *   }
+   * })
+  **/
+  count<T extends TransactionCountArgs>(
+    args?: Prisma.Subset<T, TransactionCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], TransactionCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a Transaction.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {TransactionAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends TransactionAggregateArgs>(args: Prisma.Subset<T, TransactionAggregateArgs>): Prisma.PrismaPromise<GetTransactionAggregateType<T>>
+
+  /**
+   * Group by Transaction.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {TransactionGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends TransactionGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: TransactionGroupByArgs['orderBy'] }
+      : { orderBy?: TransactionGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, TransactionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTransactionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the Transaction model
+ */
+readonly fields: TransactionFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for Transaction.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__TransactionClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  user<T extends Prisma.UserDefaultArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.UserDefaultArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the Transaction model
+ */
+export interface TransactionFieldRefs {
+  readonly id: Prisma.FieldRef<"Transaction", 'Int'>
+  readonly userId: Prisma.FieldRef<"Transaction", 'String'>
+  readonly provider: Prisma.FieldRef<"Transaction", 'SubscriptionProvider'>
+  readonly transactionId: Prisma.FieldRef<"Transaction", 'String'>
+  readonly createdAt: Prisma.FieldRef<"Transaction", 'DateTime'>
+}
+    
+
+// Custom InputTypes
+/**
+ * Transaction findUnique
+ */
+export type TransactionFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+  /**
+   * Filter, which Transaction to fetch.
+   */
+  where: Prisma.TransactionWhereUniqueInput
+}
+
+/**
+ * Transaction findUniqueOrThrow
+ */
+export type TransactionFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+  /**
+   * Filter, which Transaction to fetch.
+   */
+  where: Prisma.TransactionWhereUniqueInput
+}
+
+/**
+ * Transaction findFirst
+ */
+export type TransactionFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+  /**
+   * Filter, which Transaction to fetch.
+   */
+  where?: Prisma.TransactionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Transactions to fetch.
+   */
+  orderBy?: Prisma.TransactionOrderByWithRelationInput | Prisma.TransactionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Transactions.
+   */
+  cursor?: Prisma.TransactionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Transactions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Transactions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Transactions.
+   */
+  distinct?: Prisma.TransactionScalarFieldEnum | Prisma.TransactionScalarFieldEnum[]
+}
+
+/**
+ * Transaction findFirstOrThrow
+ */
+export type TransactionFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+  /**
+   * Filter, which Transaction to fetch.
+   */
+  where?: Prisma.TransactionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Transactions to fetch.
+   */
+  orderBy?: Prisma.TransactionOrderByWithRelationInput | Prisma.TransactionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Transactions.
+   */
+  cursor?: Prisma.TransactionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Transactions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Transactions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Transactions.
+   */
+  distinct?: Prisma.TransactionScalarFieldEnum | Prisma.TransactionScalarFieldEnum[]
+}
+
+/**
+ * Transaction findMany
+ */
+export type TransactionFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+  /**
+   * Filter, which Transactions to fetch.
+   */
+  where?: Prisma.TransactionWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Transactions to fetch.
+   */
+  orderBy?: Prisma.TransactionOrderByWithRelationInput | Prisma.TransactionOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing Transactions.
+   */
+  cursor?: Prisma.TransactionWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Transactions from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Transactions.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Transactions.
+   */
+  distinct?: Prisma.TransactionScalarFieldEnum | Prisma.TransactionScalarFieldEnum[]
+}
+
+/**
+ * Transaction create
+ */
+export type TransactionCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+  /**
+   * The data needed to create a Transaction.
+   */
+  data: Prisma.XOR<Prisma.TransactionCreateInput, Prisma.TransactionUncheckedCreateInput>
+}
+
+/**
+ * Transaction createMany
+ */
+export type TransactionCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many Transactions.
+   */
+  data: Prisma.TransactionCreateManyInput | Prisma.TransactionCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * Transaction createManyAndReturn
+ */
+export type TransactionCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * The data used to create many Transactions.
+   */
+  data: Prisma.TransactionCreateManyInput | Prisma.TransactionCreateManyInput[]
+  skipDuplicates?: boolean
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionIncludeCreateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * Transaction update
+ */
+export type TransactionUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+  /**
+   * The data needed to update a Transaction.
+   */
+  data: Prisma.XOR<Prisma.TransactionUpdateInput, Prisma.TransactionUncheckedUpdateInput>
+  /**
+   * Choose, which Transaction to update.
+   */
+  where: Prisma.TransactionWhereUniqueInput
+}
+
+/**
+ * Transaction updateMany
+ */
+export type TransactionUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update Transactions.
+   */
+  data: Prisma.XOR<Prisma.TransactionUpdateManyMutationInput, Prisma.TransactionUncheckedUpdateManyInput>
+  /**
+   * Filter which Transactions to update
+   */
+  where?: Prisma.TransactionWhereInput
+  /**
+   * Limit how many Transactions to update.
+   */
+  limit?: number
+}
+
+/**
+ * Transaction updateManyAndReturn
+ */
+export type TransactionUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * The data used to update Transactions.
+   */
+  data: Prisma.XOR<Prisma.TransactionUpdateManyMutationInput, Prisma.TransactionUncheckedUpdateManyInput>
+  /**
+   * Filter which Transactions to update
+   */
+  where?: Prisma.TransactionWhereInput
+  /**
+   * Limit how many Transactions to update.
+   */
+  limit?: number
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionIncludeUpdateManyAndReturn<ExtArgs> | null
+}
+
+/**
+ * Transaction upsert
+ */
+export type TransactionUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+  /**
+   * The filter to search for the Transaction to update in case it exists.
+   */
+  where: Prisma.TransactionWhereUniqueInput
+  /**
+   * In case the Transaction found by the `where` argument doesn't exist, create a new Transaction with this data.
+   */
+  create: Prisma.XOR<Prisma.TransactionCreateInput, Prisma.TransactionUncheckedCreateInput>
+  /**
+   * In case the Transaction was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.TransactionUpdateInput, Prisma.TransactionUncheckedUpdateInput>
+}
+
+/**
+ * Transaction delete
+ */
+export type TransactionDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+  /**
+   * Filter which Transaction to delete.
+   */
+  where: Prisma.TransactionWhereUniqueInput
+}
+
+/**
+ * Transaction deleteMany
+ */
+export type TransactionDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Transactions to delete
+   */
+  where?: Prisma.TransactionWhereInput
+  /**
+   * Limit how many Transactions to delete.
+   */
+  limit?: number
+}
+
+/**
+ * Transaction without action
+ */
+export type TransactionDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+}
diff --git a/src/generated/client/models/User.ts b/src/generated/client/models/User.ts
new file mode 100644
index 00000000..4a4bdba9
--- /dev/null
+++ b/src/generated/client/models/User.ts
@@ -0,0 +1,1979 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `User` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model User
+ * 
+ */
+export type UserModel = runtime.Types.Result.DefaultSelection<Prisma.$UserPayload>
+
+export type AggregateUser = {
+  _count: UserCountAggregateOutputType | null
+  _min: UserMinAggregateOutputType | null
+  _max: UserMaxAggregateOutputType | null
+}
+
+export type UserMinAggregateOutputType = {
+  id: string | null
+  createdAt: Date | null
+  email: string | null
+  emailVerified: Date | null
+  username: string | null
+  color: string | null
+  role: $Enums.UserRole | null
+  isProUntil: Date | null
+  isSubscriptionCancelled: boolean | null
+  subscriptionProvider: $Enums.SubscriptionProvider | null
+}
+
+export type UserMaxAggregateOutputType = {
+  id: string | null
+  createdAt: Date | null
+  email: string | null
+  emailVerified: Date | null
+  username: string | null
+  color: string | null
+  role: $Enums.UserRole | null
+  isProUntil: Date | null
+  isSubscriptionCancelled: boolean | null
+  subscriptionProvider: $Enums.SubscriptionProvider | null
+}
+
+export type UserCountAggregateOutputType = {
+  id: number
+  createdAt: number
+  email: number
+  emailVerified: number
+  username: number
+  color: number
+  role: number
+  isProUntil: number
+  isSubscriptionCancelled: number
+  subscriptionProvider: number
+  settings: number
+  _all: number
+}
+
+
+export type UserMinAggregateInputType = {
+  id?: true
+  createdAt?: true
+  email?: true
+  emailVerified?: true
+  username?: true
+  color?: true
+  role?: true
+  isProUntil?: true
+  isSubscriptionCancelled?: true
+  subscriptionProvider?: true
+}
+
+export type UserMaxAggregateInputType = {
+  id?: true
+  createdAt?: true
+  email?: true
+  emailVerified?: true
+  username?: true
+  color?: true
+  role?: true
+  isProUntil?: true
+  isSubscriptionCancelled?: true
+  subscriptionProvider?: true
+}
+
+export type UserCountAggregateInputType = {
+  id?: true
+  createdAt?: true
+  email?: true
+  emailVerified?: true
+  username?: true
+  color?: true
+  role?: true
+  isProUntil?: true
+  isSubscriptionCancelled?: true
+  subscriptionProvider?: true
+  settings?: true
+  _all?: true
+}
+
+export type UserAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which User to aggregate.
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Users to fetch.
+   */
+  orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.UserWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Users from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Users.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned Users
+  **/
+  _count?: true | UserCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: UserMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: UserMaxAggregateInputType
+}
+
+export type GetUserAggregateType<T extends UserAggregateArgs> = {
+      [P in keyof T & keyof AggregateUser]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateUser[P]>
+    : Prisma.GetScalarType<T[P], AggregateUser[P]>
+}
+
+
+
+
+export type UserGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.UserWhereInput
+  orderBy?: Prisma.UserOrderByWithAggregationInput | Prisma.UserOrderByWithAggregationInput[]
+  by: Prisma.UserScalarFieldEnum[] | Prisma.UserScalarFieldEnum
+  having?: Prisma.UserScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: UserCountAggregateInputType | true
+  _min?: UserMinAggregateInputType
+  _max?: UserMaxAggregateInputType
+}
+
+export type UserGroupByOutputType = {
+  id: string
+  createdAt: Date
+  email: string
+  emailVerified: Date | null
+  username: string | null
+  color: string | null
+  role: $Enums.UserRole
+  isProUntil: Date | null
+  isSubscriptionCancelled: boolean
+  subscriptionProvider: $Enums.SubscriptionProvider | null
+  settings: runtime.JsonValue | null
+  _count: UserCountAggregateOutputType | null
+  _min: UserMinAggregateOutputType | null
+  _max: UserMaxAggregateOutputType | null
+}
+
+export type GetUserGroupByPayload<T extends UserGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<UserGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof UserGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], UserGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], UserGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type UserWhereInput = {
+  AND?: Prisma.UserWhereInput | Prisma.UserWhereInput[]
+  OR?: Prisma.UserWhereInput[]
+  NOT?: Prisma.UserWhereInput | Prisma.UserWhereInput[]
+  id?: Prisma.StringFilter<"User"> | string
+  createdAt?: Prisma.DateTimeFilter<"User"> | Date | string
+  email?: Prisma.StringFilter<"User"> | string
+  emailVerified?: Prisma.DateTimeNullableFilter<"User"> | Date | string | null
+  username?: Prisma.StringNullableFilter<"User"> | string | null
+  color?: Prisma.StringNullableFilter<"User"> | string | null
+  role?: Prisma.EnumUserRoleFilter<"User"> | $Enums.UserRole
+  isProUntil?: Prisma.DateTimeNullableFilter<"User"> | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFilter<"User"> | boolean
+  subscriptionProvider?: Prisma.EnumSubscriptionProviderNullableFilter<"User"> | $Enums.SubscriptionProvider | null
+  settings?: Prisma.JsonNullableFilter<"User">
+  accounts?: Prisma.AccountListRelationFilter
+  sessions?: Prisma.SessionListRelationFilter
+  projects?: Prisma.ProjectMemberListRelationFilter
+  transactions?: Prisma.TransactionListRelationFilter
+}
+
+export type UserOrderByWithRelationInput = {
+  id?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  emailVerified?: Prisma.SortOrderInput | Prisma.SortOrder
+  username?: Prisma.SortOrderInput | Prisma.SortOrder
+  color?: Prisma.SortOrderInput | Prisma.SortOrder
+  role?: Prisma.SortOrder
+  isProUntil?: Prisma.SortOrderInput | Prisma.SortOrder
+  isSubscriptionCancelled?: Prisma.SortOrder
+  subscriptionProvider?: Prisma.SortOrderInput | Prisma.SortOrder
+  settings?: Prisma.SortOrderInput | Prisma.SortOrder
+  accounts?: Prisma.AccountOrderByRelationAggregateInput
+  sessions?: Prisma.SessionOrderByRelationAggregateInput
+  projects?: Prisma.ProjectMemberOrderByRelationAggregateInput
+  transactions?: Prisma.TransactionOrderByRelationAggregateInput
+}
+
+export type UserWhereUniqueInput = Prisma.AtLeast<{
+  id?: string
+  email?: string
+  AND?: Prisma.UserWhereInput | Prisma.UserWhereInput[]
+  OR?: Prisma.UserWhereInput[]
+  NOT?: Prisma.UserWhereInput | Prisma.UserWhereInput[]
+  createdAt?: Prisma.DateTimeFilter<"User"> | Date | string
+  emailVerified?: Prisma.DateTimeNullableFilter<"User"> | Date | string | null
+  username?: Prisma.StringNullableFilter<"User"> | string | null
+  color?: Prisma.StringNullableFilter<"User"> | string | null
+  role?: Prisma.EnumUserRoleFilter<"User"> | $Enums.UserRole
+  isProUntil?: Prisma.DateTimeNullableFilter<"User"> | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFilter<"User"> | boolean
+  subscriptionProvider?: Prisma.EnumSubscriptionProviderNullableFilter<"User"> | $Enums.SubscriptionProvider | null
+  settings?: Prisma.JsonNullableFilter<"User">
+  accounts?: Prisma.AccountListRelationFilter
+  sessions?: Prisma.SessionListRelationFilter
+  projects?: Prisma.ProjectMemberListRelationFilter
+  transactions?: Prisma.TransactionListRelationFilter
+}, "id" | "email">
+
+export type UserOrderByWithAggregationInput = {
+  id?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  emailVerified?: Prisma.SortOrderInput | Prisma.SortOrder
+  username?: Prisma.SortOrderInput | Prisma.SortOrder
+  color?: Prisma.SortOrderInput | Prisma.SortOrder
+  role?: Prisma.SortOrder
+  isProUntil?: Prisma.SortOrderInput | Prisma.SortOrder
+  isSubscriptionCancelled?: Prisma.SortOrder
+  subscriptionProvider?: Prisma.SortOrderInput | Prisma.SortOrder
+  settings?: Prisma.SortOrderInput | Prisma.SortOrder
+  _count?: Prisma.UserCountOrderByAggregateInput
+  _max?: Prisma.UserMaxOrderByAggregateInput
+  _min?: Prisma.UserMinOrderByAggregateInput
+}
+
+export type UserScalarWhereWithAggregatesInput = {
+  AND?: Prisma.UserScalarWhereWithAggregatesInput | Prisma.UserScalarWhereWithAggregatesInput[]
+  OR?: Prisma.UserScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.UserScalarWhereWithAggregatesInput | Prisma.UserScalarWhereWithAggregatesInput[]
+  id?: Prisma.StringWithAggregatesFilter<"User"> | string
+  createdAt?: Prisma.DateTimeWithAggregatesFilter<"User"> | Date | string
+  email?: Prisma.StringWithAggregatesFilter<"User"> | string
+  emailVerified?: Prisma.DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
+  username?: Prisma.StringNullableWithAggregatesFilter<"User"> | string | null
+  color?: Prisma.StringNullableWithAggregatesFilter<"User"> | string | null
+  role?: Prisma.EnumUserRoleWithAggregatesFilter<"User"> | $Enums.UserRole
+  isProUntil?: Prisma.DateTimeNullableWithAggregatesFilter<"User"> | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolWithAggregatesFilter<"User"> | boolean
+  subscriptionProvider?: Prisma.EnumSubscriptionProviderNullableWithAggregatesFilter<"User"> | $Enums.SubscriptionProvider | null
+  settings?: Prisma.JsonNullableWithAggregatesFilter<"User">
+}
+
+export type UserCreateInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountCreateNestedManyWithoutUserInput
+  sessions?: Prisma.SessionCreateNestedManyWithoutUserInput
+  projects?: Prisma.ProjectMemberCreateNestedManyWithoutUserInput
+  transactions?: Prisma.TransactionCreateNestedManyWithoutUserInput
+}
+
+export type UserUncheckedCreateInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUncheckedCreateNestedManyWithoutUserInput
+  sessions?: Prisma.SessionUncheckedCreateNestedManyWithoutUserInput
+  projects?: Prisma.ProjectMemberUncheckedCreateNestedManyWithoutUserInput
+  transactions?: Prisma.TransactionUncheckedCreateNestedManyWithoutUserInput
+}
+
+export type UserUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUpdateManyWithoutUserNestedInput
+  sessions?: Prisma.SessionUpdateManyWithoutUserNestedInput
+  projects?: Prisma.ProjectMemberUpdateManyWithoutUserNestedInput
+  transactions?: Prisma.TransactionUpdateManyWithoutUserNestedInput
+}
+
+export type UserUncheckedUpdateInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUncheckedUpdateManyWithoutUserNestedInput
+  sessions?: Prisma.SessionUncheckedUpdateManyWithoutUserNestedInput
+  projects?: Prisma.ProjectMemberUncheckedUpdateManyWithoutUserNestedInput
+  transactions?: Prisma.TransactionUncheckedUpdateManyWithoutUserNestedInput
+}
+
+export type UserCreateManyInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+}
+
+export type UserUpdateManyMutationInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+}
+
+export type UserUncheckedUpdateManyInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+}
+
+export type UserCountOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  emailVerified?: Prisma.SortOrder
+  username?: Prisma.SortOrder
+  color?: Prisma.SortOrder
+  role?: Prisma.SortOrder
+  isProUntil?: Prisma.SortOrder
+  isSubscriptionCancelled?: Prisma.SortOrder
+  subscriptionProvider?: Prisma.SortOrder
+  settings?: Prisma.SortOrder
+}
+
+export type UserMaxOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  emailVerified?: Prisma.SortOrder
+  username?: Prisma.SortOrder
+  color?: Prisma.SortOrder
+  role?: Prisma.SortOrder
+  isProUntil?: Prisma.SortOrder
+  isSubscriptionCancelled?: Prisma.SortOrder
+  subscriptionProvider?: Prisma.SortOrder
+}
+
+export type UserMinOrderByAggregateInput = {
+  id?: Prisma.SortOrder
+  createdAt?: Prisma.SortOrder
+  email?: Prisma.SortOrder
+  emailVerified?: Prisma.SortOrder
+  username?: Prisma.SortOrder
+  color?: Prisma.SortOrder
+  role?: Prisma.SortOrder
+  isProUntil?: Prisma.SortOrder
+  isSubscriptionCancelled?: Prisma.SortOrder
+  subscriptionProvider?: Prisma.SortOrder
+}
+
+export type UserScalarRelationFilter = {
+  is?: Prisma.UserWhereInput
+  isNot?: Prisma.UserWhereInput
+}
+
+export type StringFieldUpdateOperationsInput = {
+  set?: string
+}
+
+export type DateTimeFieldUpdateOperationsInput = {
+  set?: Date | string
+}
+
+export type NullableDateTimeFieldUpdateOperationsInput = {
+  set?: Date | string | null
+}
+
+export type NullableStringFieldUpdateOperationsInput = {
+  set?: string | null
+}
+
+export type EnumUserRoleFieldUpdateOperationsInput = {
+  set?: $Enums.UserRole
+}
+
+export type BoolFieldUpdateOperationsInput = {
+  set?: boolean
+}
+
+export type NullableEnumSubscriptionProviderFieldUpdateOperationsInput = {
+  set?: $Enums.SubscriptionProvider | null
+}
+
+export type UserCreateNestedOneWithoutAccountsInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutAccountsInput, Prisma.UserUncheckedCreateWithoutAccountsInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutAccountsInput
+  connect?: Prisma.UserWhereUniqueInput
+}
+
+export type UserUpdateOneRequiredWithoutAccountsNestedInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutAccountsInput, Prisma.UserUncheckedCreateWithoutAccountsInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutAccountsInput
+  upsert?: Prisma.UserUpsertWithoutAccountsInput
+  connect?: Prisma.UserWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutAccountsInput, Prisma.UserUpdateWithoutAccountsInput>, Prisma.UserUncheckedUpdateWithoutAccountsInput>
+}
+
+export type UserCreateNestedOneWithoutSessionsInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutSessionsInput, Prisma.UserUncheckedCreateWithoutSessionsInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutSessionsInput
+  connect?: Prisma.UserWhereUniqueInput
+}
+
+export type UserUpdateOneRequiredWithoutSessionsNestedInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutSessionsInput, Prisma.UserUncheckedCreateWithoutSessionsInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutSessionsInput
+  upsert?: Prisma.UserUpsertWithoutSessionsInput
+  connect?: Prisma.UserWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutSessionsInput, Prisma.UserUpdateWithoutSessionsInput>, Prisma.UserUncheckedUpdateWithoutSessionsInput>
+}
+
+export type UserCreateNestedOneWithoutTransactionsInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutTransactionsInput, Prisma.UserUncheckedCreateWithoutTransactionsInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutTransactionsInput
+  connect?: Prisma.UserWhereUniqueInput
+}
+
+export type UserUpdateOneRequiredWithoutTransactionsNestedInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutTransactionsInput, Prisma.UserUncheckedCreateWithoutTransactionsInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutTransactionsInput
+  upsert?: Prisma.UserUpsertWithoutTransactionsInput
+  connect?: Prisma.UserWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutTransactionsInput, Prisma.UserUpdateWithoutTransactionsInput>, Prisma.UserUncheckedUpdateWithoutTransactionsInput>
+}
+
+export type UserCreateNestedOneWithoutProjectsInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutProjectsInput, Prisma.UserUncheckedCreateWithoutProjectsInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutProjectsInput
+  connect?: Prisma.UserWhereUniqueInput
+}
+
+export type UserUpdateOneRequiredWithoutProjectsNestedInput = {
+  create?: Prisma.XOR<Prisma.UserCreateWithoutProjectsInput, Prisma.UserUncheckedCreateWithoutProjectsInput>
+  connectOrCreate?: Prisma.UserCreateOrConnectWithoutProjectsInput
+  upsert?: Prisma.UserUpsertWithoutProjectsInput
+  connect?: Prisma.UserWhereUniqueInput
+  update?: Prisma.XOR<Prisma.XOR<Prisma.UserUpdateToOneWithWhereWithoutProjectsInput, Prisma.UserUpdateWithoutProjectsInput>, Prisma.UserUncheckedUpdateWithoutProjectsInput>
+}
+
+export type UserCreateWithoutAccountsInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  sessions?: Prisma.SessionCreateNestedManyWithoutUserInput
+  projects?: Prisma.ProjectMemberCreateNestedManyWithoutUserInput
+  transactions?: Prisma.TransactionCreateNestedManyWithoutUserInput
+}
+
+export type UserUncheckedCreateWithoutAccountsInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  sessions?: Prisma.SessionUncheckedCreateNestedManyWithoutUserInput
+  projects?: Prisma.ProjectMemberUncheckedCreateNestedManyWithoutUserInput
+  transactions?: Prisma.TransactionUncheckedCreateNestedManyWithoutUserInput
+}
+
+export type UserCreateOrConnectWithoutAccountsInput = {
+  where: Prisma.UserWhereUniqueInput
+  create: Prisma.XOR<Prisma.UserCreateWithoutAccountsInput, Prisma.UserUncheckedCreateWithoutAccountsInput>
+}
+
+export type UserUpsertWithoutAccountsInput = {
+  update: Prisma.XOR<Prisma.UserUpdateWithoutAccountsInput, Prisma.UserUncheckedUpdateWithoutAccountsInput>
+  create: Prisma.XOR<Prisma.UserCreateWithoutAccountsInput, Prisma.UserUncheckedCreateWithoutAccountsInput>
+  where?: Prisma.UserWhereInput
+}
+
+export type UserUpdateToOneWithWhereWithoutAccountsInput = {
+  where?: Prisma.UserWhereInput
+  data: Prisma.XOR<Prisma.UserUpdateWithoutAccountsInput, Prisma.UserUncheckedUpdateWithoutAccountsInput>
+}
+
+export type UserUpdateWithoutAccountsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  sessions?: Prisma.SessionUpdateManyWithoutUserNestedInput
+  projects?: Prisma.ProjectMemberUpdateManyWithoutUserNestedInput
+  transactions?: Prisma.TransactionUpdateManyWithoutUserNestedInput
+}
+
+export type UserUncheckedUpdateWithoutAccountsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  sessions?: Prisma.SessionUncheckedUpdateManyWithoutUserNestedInput
+  projects?: Prisma.ProjectMemberUncheckedUpdateManyWithoutUserNestedInput
+  transactions?: Prisma.TransactionUncheckedUpdateManyWithoutUserNestedInput
+}
+
+export type UserCreateWithoutSessionsInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountCreateNestedManyWithoutUserInput
+  projects?: Prisma.ProjectMemberCreateNestedManyWithoutUserInput
+  transactions?: Prisma.TransactionCreateNestedManyWithoutUserInput
+}
+
+export type UserUncheckedCreateWithoutSessionsInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUncheckedCreateNestedManyWithoutUserInput
+  projects?: Prisma.ProjectMemberUncheckedCreateNestedManyWithoutUserInput
+  transactions?: Prisma.TransactionUncheckedCreateNestedManyWithoutUserInput
+}
+
+export type UserCreateOrConnectWithoutSessionsInput = {
+  where: Prisma.UserWhereUniqueInput
+  create: Prisma.XOR<Prisma.UserCreateWithoutSessionsInput, Prisma.UserUncheckedCreateWithoutSessionsInput>
+}
+
+export type UserUpsertWithoutSessionsInput = {
+  update: Prisma.XOR<Prisma.UserUpdateWithoutSessionsInput, Prisma.UserUncheckedUpdateWithoutSessionsInput>
+  create: Prisma.XOR<Prisma.UserCreateWithoutSessionsInput, Prisma.UserUncheckedCreateWithoutSessionsInput>
+  where?: Prisma.UserWhereInput
+}
+
+export type UserUpdateToOneWithWhereWithoutSessionsInput = {
+  where?: Prisma.UserWhereInput
+  data: Prisma.XOR<Prisma.UserUpdateWithoutSessionsInput, Prisma.UserUncheckedUpdateWithoutSessionsInput>
+}
+
+export type UserUpdateWithoutSessionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUpdateManyWithoutUserNestedInput
+  projects?: Prisma.ProjectMemberUpdateManyWithoutUserNestedInput
+  transactions?: Prisma.TransactionUpdateManyWithoutUserNestedInput
+}
+
+export type UserUncheckedUpdateWithoutSessionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUncheckedUpdateManyWithoutUserNestedInput
+  projects?: Prisma.ProjectMemberUncheckedUpdateManyWithoutUserNestedInput
+  transactions?: Prisma.TransactionUncheckedUpdateManyWithoutUserNestedInput
+}
+
+export type UserCreateWithoutTransactionsInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountCreateNestedManyWithoutUserInput
+  sessions?: Prisma.SessionCreateNestedManyWithoutUserInput
+  projects?: Prisma.ProjectMemberCreateNestedManyWithoutUserInput
+}
+
+export type UserUncheckedCreateWithoutTransactionsInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUncheckedCreateNestedManyWithoutUserInput
+  sessions?: Prisma.SessionUncheckedCreateNestedManyWithoutUserInput
+  projects?: Prisma.ProjectMemberUncheckedCreateNestedManyWithoutUserInput
+}
+
+export type UserCreateOrConnectWithoutTransactionsInput = {
+  where: Prisma.UserWhereUniqueInput
+  create: Prisma.XOR<Prisma.UserCreateWithoutTransactionsInput, Prisma.UserUncheckedCreateWithoutTransactionsInput>
+}
+
+export type UserUpsertWithoutTransactionsInput = {
+  update: Prisma.XOR<Prisma.UserUpdateWithoutTransactionsInput, Prisma.UserUncheckedUpdateWithoutTransactionsInput>
+  create: Prisma.XOR<Prisma.UserCreateWithoutTransactionsInput, Prisma.UserUncheckedCreateWithoutTransactionsInput>
+  where?: Prisma.UserWhereInput
+}
+
+export type UserUpdateToOneWithWhereWithoutTransactionsInput = {
+  where?: Prisma.UserWhereInput
+  data: Prisma.XOR<Prisma.UserUpdateWithoutTransactionsInput, Prisma.UserUncheckedUpdateWithoutTransactionsInput>
+}
+
+export type UserUpdateWithoutTransactionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUpdateManyWithoutUserNestedInput
+  sessions?: Prisma.SessionUpdateManyWithoutUserNestedInput
+  projects?: Prisma.ProjectMemberUpdateManyWithoutUserNestedInput
+}
+
+export type UserUncheckedUpdateWithoutTransactionsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUncheckedUpdateManyWithoutUserNestedInput
+  sessions?: Prisma.SessionUncheckedUpdateManyWithoutUserNestedInput
+  projects?: Prisma.ProjectMemberUncheckedUpdateManyWithoutUserNestedInput
+}
+
+export type UserCreateWithoutProjectsInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountCreateNestedManyWithoutUserInput
+  sessions?: Prisma.SessionCreateNestedManyWithoutUserInput
+  transactions?: Prisma.TransactionCreateNestedManyWithoutUserInput
+}
+
+export type UserUncheckedCreateWithoutProjectsInput = {
+  id?: string
+  createdAt?: Date | string
+  email: string
+  emailVerified?: Date | string | null
+  username?: string | null
+  color?: string | null
+  role?: $Enums.UserRole
+  isProUntil?: Date | string | null
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUncheckedCreateNestedManyWithoutUserInput
+  sessions?: Prisma.SessionUncheckedCreateNestedManyWithoutUserInput
+  transactions?: Prisma.TransactionUncheckedCreateNestedManyWithoutUserInput
+}
+
+export type UserCreateOrConnectWithoutProjectsInput = {
+  where: Prisma.UserWhereUniqueInput
+  create: Prisma.XOR<Prisma.UserCreateWithoutProjectsInput, Prisma.UserUncheckedCreateWithoutProjectsInput>
+}
+
+export type UserUpsertWithoutProjectsInput = {
+  update: Prisma.XOR<Prisma.UserUpdateWithoutProjectsInput, Prisma.UserUncheckedUpdateWithoutProjectsInput>
+  create: Prisma.XOR<Prisma.UserCreateWithoutProjectsInput, Prisma.UserUncheckedCreateWithoutProjectsInput>
+  where?: Prisma.UserWhereInput
+}
+
+export type UserUpdateToOneWithWhereWithoutProjectsInput = {
+  where?: Prisma.UserWhereInput
+  data: Prisma.XOR<Prisma.UserUpdateWithoutProjectsInput, Prisma.UserUncheckedUpdateWithoutProjectsInput>
+}
+
+export type UserUpdateWithoutProjectsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUpdateManyWithoutUserNestedInput
+  sessions?: Prisma.SessionUpdateManyWithoutUserNestedInput
+  transactions?: Prisma.TransactionUpdateManyWithoutUserNestedInput
+}
+
+export type UserUncheckedUpdateWithoutProjectsInput = {
+  id?: Prisma.StringFieldUpdateOperationsInput | string
+  createdAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+  email?: Prisma.StringFieldUpdateOperationsInput | string
+  emailVerified?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  username?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  color?: Prisma.NullableStringFieldUpdateOperationsInput | string | null
+  role?: Prisma.EnumUserRoleFieldUpdateOperationsInput | $Enums.UserRole
+  isProUntil?: Prisma.NullableDateTimeFieldUpdateOperationsInput | Date | string | null
+  isSubscriptionCancelled?: Prisma.BoolFieldUpdateOperationsInput | boolean
+  subscriptionProvider?: Prisma.NullableEnumSubscriptionProviderFieldUpdateOperationsInput | $Enums.SubscriptionProvider | null
+  settings?: Prisma.NullableJsonNullValueInput | runtime.InputJsonValue
+  accounts?: Prisma.AccountUncheckedUpdateManyWithoutUserNestedInput
+  sessions?: Prisma.SessionUncheckedUpdateManyWithoutUserNestedInput
+  transactions?: Prisma.TransactionUncheckedUpdateManyWithoutUserNestedInput
+}
+
+
+/**
+ * Count Type UserCountOutputType
+ */
+
+export type UserCountOutputType = {
+  accounts: number
+  sessions: number
+  projects: number
+  transactions: number
+}
+
+export type UserCountOutputTypeSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  accounts?: boolean | UserCountOutputTypeCountAccountsArgs
+  sessions?: boolean | UserCountOutputTypeCountSessionsArgs
+  projects?: boolean | UserCountOutputTypeCountProjectsArgs
+  transactions?: boolean | UserCountOutputTypeCountTransactionsArgs
+}
+
+/**
+ * UserCountOutputType without action
+ */
+export type UserCountOutputTypeDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the UserCountOutputType
+   */
+  select?: Prisma.UserCountOutputTypeSelect<ExtArgs> | null
+}
+
+/**
+ * UserCountOutputType without action
+ */
+export type UserCountOutputTypeCountAccountsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.AccountWhereInput
+}
+
+/**
+ * UserCountOutputType without action
+ */
+export type UserCountOutputTypeCountSessionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.SessionWhereInput
+}
+
+/**
+ * UserCountOutputType without action
+ */
+export type UserCountOutputTypeCountProjectsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.ProjectMemberWhereInput
+}
+
+/**
+ * UserCountOutputType without action
+ */
+export type UserCountOutputTypeCountTransactionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.TransactionWhereInput
+}
+
+
+export type UserSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  createdAt?: boolean
+  email?: boolean
+  emailVerified?: boolean
+  username?: boolean
+  color?: boolean
+  role?: boolean
+  isProUntil?: boolean
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: boolean
+  settings?: boolean
+  accounts?: boolean | Prisma.User$accountsArgs<ExtArgs>
+  sessions?: boolean | Prisma.User$sessionsArgs<ExtArgs>
+  projects?: boolean | Prisma.User$projectsArgs<ExtArgs>
+  transactions?: boolean | Prisma.User$transactionsArgs<ExtArgs>
+  _count?: boolean | Prisma.UserCountOutputTypeDefaultArgs<ExtArgs>
+}, ExtArgs["result"]["user"]>
+
+export type UserSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  createdAt?: boolean
+  email?: boolean
+  emailVerified?: boolean
+  username?: boolean
+  color?: boolean
+  role?: boolean
+  isProUntil?: boolean
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: boolean
+  settings?: boolean
+}, ExtArgs["result"]["user"]>
+
+export type UserSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  id?: boolean
+  createdAt?: boolean
+  email?: boolean
+  emailVerified?: boolean
+  username?: boolean
+  color?: boolean
+  role?: boolean
+  isProUntil?: boolean
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: boolean
+  settings?: boolean
+}, ExtArgs["result"]["user"]>
+
+export type UserSelectScalar = {
+  id?: boolean
+  createdAt?: boolean
+  email?: boolean
+  emailVerified?: boolean
+  username?: boolean
+  color?: boolean
+  role?: boolean
+  isProUntil?: boolean
+  isSubscriptionCancelled?: boolean
+  subscriptionProvider?: boolean
+  settings?: boolean
+}
+
+export type UserOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"id" | "createdAt" | "email" | "emailVerified" | "username" | "color" | "role" | "isProUntil" | "isSubscriptionCancelled" | "subscriptionProvider" | "settings", ExtArgs["result"]["user"]>
+export type UserInclude<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  accounts?: boolean | Prisma.User$accountsArgs<ExtArgs>
+  sessions?: boolean | Prisma.User$sessionsArgs<ExtArgs>
+  projects?: boolean | Prisma.User$projectsArgs<ExtArgs>
+  transactions?: boolean | Prisma.User$transactionsArgs<ExtArgs>
+  _count?: boolean | Prisma.UserCountOutputTypeDefaultArgs<ExtArgs>
+}
+export type UserIncludeCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
+export type UserIncludeUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {}
+
+export type $UserPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "User"
+  objects: {
+    accounts: Prisma.$AccountPayload<ExtArgs>[]
+    sessions: Prisma.$SessionPayload<ExtArgs>[]
+    projects: Prisma.$ProjectMemberPayload<ExtArgs>[]
+    transactions: Prisma.$TransactionPayload<ExtArgs>[]
+  }
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    id: string
+    createdAt: Date
+    email: string
+    emailVerified: Date | null
+    username: string | null
+    color: string | null
+    role: $Enums.UserRole
+    isProUntil: Date | null
+    isSubscriptionCancelled: boolean
+    subscriptionProvider: $Enums.SubscriptionProvider | null
+    settings: runtime.JsonValue | null
+  }, ExtArgs["result"]["user"]>
+  composites: {}
+}
+
+export type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$UserPayload, S>
+
+export type UserCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<UserFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: UserCountAggregateInputType | true
+  }
+
+export interface UserDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['User'], meta: { name: 'User' } }
+  /**
+   * Find zero or one User that matches the filter.
+   * @param {UserFindUniqueArgs} args - Arguments to find a User
+   * @example
+   * // Get one User
+   * const user = await prisma.user.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends UserFindUniqueArgs>(args: Prisma.SelectSubset<T, UserFindUniqueArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one User that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {UserFindUniqueOrThrowArgs} args - Arguments to find a User
+   * @example
+   * // Get one User
+   * const user = await prisma.user.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends UserFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, UserFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first User that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserFindFirstArgs} args - Arguments to find a User
+   * @example
+   * // Get one User
+   * const user = await prisma.user.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends UserFindFirstArgs>(args?: Prisma.SelectSubset<T, UserFindFirstArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first User that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserFindFirstOrThrowArgs} args - Arguments to find a User
+   * @example
+   * // Get one User
+   * const user = await prisma.user.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends UserFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more Users that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all Users
+   * const users = await prisma.user.findMany()
+   * 
+   * // Get first 10 Users
+   * const users = await prisma.user.findMany({ take: 10 })
+   * 
+   * // Only select the `id`
+   * const userWithIdOnly = await prisma.user.findMany({ select: { id: true } })
+   * 
+   */
+  findMany<T extends UserFindManyArgs>(args?: Prisma.SelectSubset<T, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a User.
+   * @param {UserCreateArgs} args - Arguments to create a User.
+   * @example
+   * // Create one User
+   * const User = await prisma.user.create({
+   *   data: {
+   *     // ... data to create a User
+   *   }
+   * })
+   * 
+   */
+  create<T extends UserCreateArgs>(args: Prisma.SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many Users.
+   * @param {UserCreateManyArgs} args - Arguments to create many Users.
+   * @example
+   * // Create many Users
+   * const user = await prisma.user.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends UserCreateManyArgs>(args?: Prisma.SelectSubset<T, UserCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many Users and returns the data saved in the database.
+   * @param {UserCreateManyAndReturnArgs} args - Arguments to create many Users.
+   * @example
+   * // Create many Users
+   * const user = await prisma.user.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many Users and only return the `id`
+   * const userWithIdOnly = await prisma.user.createManyAndReturn({
+   *   select: { id: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends UserCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, UserCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a User.
+   * @param {UserDeleteArgs} args - Arguments to delete one User.
+   * @example
+   * // Delete one User
+   * const User = await prisma.user.delete({
+   *   where: {
+   *     // ... filter to delete one User
+   *   }
+   * })
+   * 
+   */
+  delete<T extends UserDeleteArgs>(args: Prisma.SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one User.
+   * @param {UserUpdateArgs} args - Arguments to update one User.
+   * @example
+   * // Update one User
+   * const user = await prisma.user.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends UserUpdateArgs>(args: Prisma.SelectSubset<T, UserUpdateArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more Users.
+   * @param {UserDeleteManyArgs} args - Arguments to filter Users to delete.
+   * @example
+   * // Delete a few Users
+   * const { count } = await prisma.user.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends UserDeleteManyArgs>(args?: Prisma.SelectSubset<T, UserDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Users.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many Users
+   * const user = await prisma.user.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends UserUpdateManyArgs>(args: Prisma.SelectSubset<T, UserUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more Users and returns the data updated in the database.
+   * @param {UserUpdateManyAndReturnArgs} args - Arguments to update many Users.
+   * @example
+   * // Update many Users
+   * const user = await prisma.user.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more Users and only return the `id`
+   * const userWithIdOnly = await prisma.user.updateManyAndReturn({
+   *   select: { id: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends UserUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, UserUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one User.
+   * @param {UserUpsertArgs} args - Arguments to update or create a User.
+   * @example
+   * // Update or create a User
+   * const user = await prisma.user.upsert({
+   *   create: {
+   *     // ... data to create a User
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the User we want to update
+   *   }
+   * })
+   */
+  upsert<T extends UserUpsertArgs>(args: Prisma.SelectSubset<T, UserUpsertArgs<ExtArgs>>): Prisma.Prisma__UserClient<runtime.Types.Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of Users.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserCountArgs} args - Arguments to filter Users to count.
+   * @example
+   * // Count the number of Users
+   * const count = await prisma.user.count({
+   *   where: {
+   *     // ... the filter for the Users we want to count
+   *   }
+   * })
+  **/
+  count<T extends UserCountArgs>(
+    args?: Prisma.Subset<T, UserCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], UserCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a User.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends UserAggregateArgs>(args: Prisma.Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>>
+
+  /**
+   * Group by User.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {UserGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends UserGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: UserGroupByArgs['orderBy'] }
+      : { orderBy?: UserGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the User model
+ */
+readonly fields: UserFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for User.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__UserClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  accounts<T extends Prisma.User$accountsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$accountsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  sessions<T extends Prisma.User$sessionsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$SessionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  projects<T extends Prisma.User$projectsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$projectsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$ProjectMemberPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  transactions<T extends Prisma.User$transactionsArgs<ExtArgs> = {}>(args?: Prisma.Subset<T, Prisma.User$transactionsArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$TransactionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the User model
+ */
+export interface UserFieldRefs {
+  readonly id: Prisma.FieldRef<"User", 'String'>
+  readonly createdAt: Prisma.FieldRef<"User", 'DateTime'>
+  readonly email: Prisma.FieldRef<"User", 'String'>
+  readonly emailVerified: Prisma.FieldRef<"User", 'DateTime'>
+  readonly username: Prisma.FieldRef<"User", 'String'>
+  readonly color: Prisma.FieldRef<"User", 'String'>
+  readonly role: Prisma.FieldRef<"User", 'UserRole'>
+  readonly isProUntil: Prisma.FieldRef<"User", 'DateTime'>
+  readonly isSubscriptionCancelled: Prisma.FieldRef<"User", 'Boolean'>
+  readonly subscriptionProvider: Prisma.FieldRef<"User", 'SubscriptionProvider'>
+  readonly settings: Prisma.FieldRef<"User", 'Json'>
+}
+    
+
+// Custom InputTypes
+/**
+ * User findUnique
+ */
+export type UserFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter, which User to fetch.
+   */
+  where: Prisma.UserWhereUniqueInput
+}
+
+/**
+ * User findUniqueOrThrow
+ */
+export type UserFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter, which User to fetch.
+   */
+  where: Prisma.UserWhereUniqueInput
+}
+
+/**
+ * User findFirst
+ */
+export type UserFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter, which User to fetch.
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Users to fetch.
+   */
+  orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Users.
+   */
+  cursor?: Prisma.UserWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Users from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Users.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Users.
+   */
+  distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[]
+}
+
+/**
+ * User findFirstOrThrow
+ */
+export type UserFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter, which User to fetch.
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Users to fetch.
+   */
+  orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for Users.
+   */
+  cursor?: Prisma.UserWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Users from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Users.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Users.
+   */
+  distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[]
+}
+
+/**
+ * User findMany
+ */
+export type UserFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter, which Users to fetch.
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of Users to fetch.
+   */
+  orderBy?: Prisma.UserOrderByWithRelationInput | Prisma.UserOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing Users.
+   */
+  cursor?: Prisma.UserWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` Users from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` Users.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of Users.
+   */
+  distinct?: Prisma.UserScalarFieldEnum | Prisma.UserScalarFieldEnum[]
+}
+
+/**
+ * User create
+ */
+export type UserCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * The data needed to create a User.
+   */
+  data: Prisma.XOR<Prisma.UserCreateInput, Prisma.UserUncheckedCreateInput>
+}
+
+/**
+ * User createMany
+ */
+export type UserCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many Users.
+   */
+  data: Prisma.UserCreateManyInput | Prisma.UserCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * User createManyAndReturn
+ */
+export type UserCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * The data used to create many Users.
+   */
+  data: Prisma.UserCreateManyInput | Prisma.UserCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * User update
+ */
+export type UserUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * The data needed to update a User.
+   */
+  data: Prisma.XOR<Prisma.UserUpdateInput, Prisma.UserUncheckedUpdateInput>
+  /**
+   * Choose, which User to update.
+   */
+  where: Prisma.UserWhereUniqueInput
+}
+
+/**
+ * User updateMany
+ */
+export type UserUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update Users.
+   */
+  data: Prisma.XOR<Prisma.UserUpdateManyMutationInput, Prisma.UserUncheckedUpdateManyInput>
+  /**
+   * Filter which Users to update
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * Limit how many Users to update.
+   */
+  limit?: number
+}
+
+/**
+ * User updateManyAndReturn
+ */
+export type UserUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * The data used to update Users.
+   */
+  data: Prisma.XOR<Prisma.UserUpdateManyMutationInput, Prisma.UserUncheckedUpdateManyInput>
+  /**
+   * Filter which Users to update
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * Limit how many Users to update.
+   */
+  limit?: number
+}
+
+/**
+ * User upsert
+ */
+export type UserUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * The filter to search for the User to update in case it exists.
+   */
+  where: Prisma.UserWhereUniqueInput
+  /**
+   * In case the User found by the `where` argument doesn't exist, create a new User with this data.
+   */
+  create: Prisma.XOR<Prisma.UserCreateInput, Prisma.UserUncheckedCreateInput>
+  /**
+   * In case the User was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.UserUpdateInput, Prisma.UserUncheckedUpdateInput>
+}
+
+/**
+ * User delete
+ */
+export type UserDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+  /**
+   * Filter which User to delete.
+   */
+  where: Prisma.UserWhereUniqueInput
+}
+
+/**
+ * User deleteMany
+ */
+export type UserDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which Users to delete
+   */
+  where?: Prisma.UserWhereInput
+  /**
+   * Limit how many Users to delete.
+   */
+  limit?: number
+}
+
+/**
+ * User.accounts
+ */
+export type User$accountsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Account
+   */
+  select?: Prisma.AccountSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Account
+   */
+  omit?: Prisma.AccountOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.AccountInclude<ExtArgs> | null
+  where?: Prisma.AccountWhereInput
+  orderBy?: Prisma.AccountOrderByWithRelationInput | Prisma.AccountOrderByWithRelationInput[]
+  cursor?: Prisma.AccountWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.AccountScalarFieldEnum | Prisma.AccountScalarFieldEnum[]
+}
+
+/**
+ * User.sessions
+ */
+export type User$sessionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Session
+   */
+  select?: Prisma.SessionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Session
+   */
+  omit?: Prisma.SessionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.SessionInclude<ExtArgs> | null
+  where?: Prisma.SessionWhereInput
+  orderBy?: Prisma.SessionOrderByWithRelationInput | Prisma.SessionOrderByWithRelationInput[]
+  cursor?: Prisma.SessionWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.SessionScalarFieldEnum | Prisma.SessionScalarFieldEnum[]
+}
+
+/**
+ * User.projects
+ */
+export type User$projectsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the ProjectMember
+   */
+  select?: Prisma.ProjectMemberSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the ProjectMember
+   */
+  omit?: Prisma.ProjectMemberOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.ProjectMemberInclude<ExtArgs> | null
+  where?: Prisma.ProjectMemberWhereInput
+  orderBy?: Prisma.ProjectMemberOrderByWithRelationInput | Prisma.ProjectMemberOrderByWithRelationInput[]
+  cursor?: Prisma.ProjectMemberWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.ProjectMemberScalarFieldEnum | Prisma.ProjectMemberScalarFieldEnum[]
+}
+
+/**
+ * User.transactions
+ */
+export type User$transactionsArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the Transaction
+   */
+  select?: Prisma.TransactionSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the Transaction
+   */
+  omit?: Prisma.TransactionOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.TransactionInclude<ExtArgs> | null
+  where?: Prisma.TransactionWhereInput
+  orderBy?: Prisma.TransactionOrderByWithRelationInput | Prisma.TransactionOrderByWithRelationInput[]
+  cursor?: Prisma.TransactionWhereUniqueInput
+  take?: number
+  skip?: number
+  distinct?: Prisma.TransactionScalarFieldEnum | Prisma.TransactionScalarFieldEnum[]
+}
+
+/**
+ * User without action
+ */
+export type UserDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the User
+   */
+  select?: Prisma.UserSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the User
+   */
+  omit?: Prisma.UserOmit<ExtArgs> | null
+  /**
+   * Choose, which related nodes to fetch as well
+   */
+  include?: Prisma.UserInclude<ExtArgs> | null
+}
diff --git a/src/generated/client/models/VerificationToken.ts b/src/generated/client/models/VerificationToken.ts
new file mode 100644
index 00000000..9b850854
--- /dev/null
+++ b/src/generated/client/models/VerificationToken.ts
@@ -0,0 +1,1099 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file exports the `VerificationToken` model and its related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+import type * as runtime from "@prisma/client/runtime/client"
+import type * as $Enums from "../enums"
+import type * as Prisma from "../internal/prismaNamespace"
+
+/**
+ * Model VerificationToken
+ * 
+ */
+export type VerificationTokenModel = runtime.Types.Result.DefaultSelection<Prisma.$VerificationTokenPayload>
+
+export type AggregateVerificationToken = {
+  _count: VerificationTokenCountAggregateOutputType | null
+  _min: VerificationTokenMinAggregateOutputType | null
+  _max: VerificationTokenMaxAggregateOutputType | null
+}
+
+export type VerificationTokenMinAggregateOutputType = {
+  identifier: string | null
+  token: string | null
+  expires: Date | null
+}
+
+export type VerificationTokenMaxAggregateOutputType = {
+  identifier: string | null
+  token: string | null
+  expires: Date | null
+}
+
+export type VerificationTokenCountAggregateOutputType = {
+  identifier: number
+  token: number
+  expires: number
+  _all: number
+}
+
+
+export type VerificationTokenMinAggregateInputType = {
+  identifier?: true
+  token?: true
+  expires?: true
+}
+
+export type VerificationTokenMaxAggregateInputType = {
+  identifier?: true
+  token?: true
+  expires?: true
+}
+
+export type VerificationTokenCountAggregateInputType = {
+  identifier?: true
+  token?: true
+  expires?: true
+  _all?: true
+}
+
+export type VerificationTokenAggregateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which VerificationToken to aggregate.
+   */
+  where?: Prisma.VerificationTokenWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of VerificationTokens to fetch.
+   */
+  orderBy?: Prisma.VerificationTokenOrderByWithRelationInput | Prisma.VerificationTokenOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the start position
+   */
+  cursor?: Prisma.VerificationTokenWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` VerificationTokens from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` VerificationTokens.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Count returned VerificationTokens
+  **/
+  _count?: true | VerificationTokenCountAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the minimum value
+  **/
+  _min?: VerificationTokenMinAggregateInputType
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+   * 
+   * Select which fields to find the maximum value
+  **/
+  _max?: VerificationTokenMaxAggregateInputType
+}
+
+export type GetVerificationTokenAggregateType<T extends VerificationTokenAggregateArgs> = {
+      [P in keyof T & keyof AggregateVerificationToken]: P extends '_count' | 'count'
+    ? T[P] extends true
+      ? number
+      : Prisma.GetScalarType<T[P], AggregateVerificationToken[P]>
+    : Prisma.GetScalarType<T[P], AggregateVerificationToken[P]>
+}
+
+
+
+
+export type VerificationTokenGroupByArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  where?: Prisma.VerificationTokenWhereInput
+  orderBy?: Prisma.VerificationTokenOrderByWithAggregationInput | Prisma.VerificationTokenOrderByWithAggregationInput[]
+  by: Prisma.VerificationTokenScalarFieldEnum[] | Prisma.VerificationTokenScalarFieldEnum
+  having?: Prisma.VerificationTokenScalarWhereWithAggregatesInput
+  take?: number
+  skip?: number
+  _count?: VerificationTokenCountAggregateInputType | true
+  _min?: VerificationTokenMinAggregateInputType
+  _max?: VerificationTokenMaxAggregateInputType
+}
+
+export type VerificationTokenGroupByOutputType = {
+  identifier: string
+  token: string
+  expires: Date
+  _count: VerificationTokenCountAggregateOutputType | null
+  _min: VerificationTokenMinAggregateOutputType | null
+  _max: VerificationTokenMaxAggregateOutputType | null
+}
+
+export type GetVerificationTokenGroupByPayload<T extends VerificationTokenGroupByArgs> = Prisma.PrismaPromise<
+  Array<
+    Prisma.PickEnumerable<VerificationTokenGroupByOutputType, T['by']> &
+      {
+        [P in ((keyof T) & (keyof VerificationTokenGroupByOutputType))]: P extends '_count'
+          ? T[P] extends boolean
+            ? number
+            : Prisma.GetScalarType<T[P], VerificationTokenGroupByOutputType[P]>
+          : Prisma.GetScalarType<T[P], VerificationTokenGroupByOutputType[P]>
+      }
+    >
+  >
+
+
+
+export type VerificationTokenWhereInput = {
+  AND?: Prisma.VerificationTokenWhereInput | Prisma.VerificationTokenWhereInput[]
+  OR?: Prisma.VerificationTokenWhereInput[]
+  NOT?: Prisma.VerificationTokenWhereInput | Prisma.VerificationTokenWhereInput[]
+  identifier?: Prisma.StringFilter<"VerificationToken"> | string
+  token?: Prisma.StringFilter<"VerificationToken"> | string
+  expires?: Prisma.DateTimeFilter<"VerificationToken"> | Date | string
+}
+
+export type VerificationTokenOrderByWithRelationInput = {
+  identifier?: Prisma.SortOrder
+  token?: Prisma.SortOrder
+  expires?: Prisma.SortOrder
+}
+
+export type VerificationTokenWhereUniqueInput = Prisma.AtLeast<{
+  token?: string
+  identifier_token?: Prisma.VerificationTokenIdentifierTokenCompoundUniqueInput
+  AND?: Prisma.VerificationTokenWhereInput | Prisma.VerificationTokenWhereInput[]
+  OR?: Prisma.VerificationTokenWhereInput[]
+  NOT?: Prisma.VerificationTokenWhereInput | Prisma.VerificationTokenWhereInput[]
+  identifier?: Prisma.StringFilter<"VerificationToken"> | string
+  expires?: Prisma.DateTimeFilter<"VerificationToken"> | Date | string
+}, "token" | "identifier_token">
+
+export type VerificationTokenOrderByWithAggregationInput = {
+  identifier?: Prisma.SortOrder
+  token?: Prisma.SortOrder
+  expires?: Prisma.SortOrder
+  _count?: Prisma.VerificationTokenCountOrderByAggregateInput
+  _max?: Prisma.VerificationTokenMaxOrderByAggregateInput
+  _min?: Prisma.VerificationTokenMinOrderByAggregateInput
+}
+
+export type VerificationTokenScalarWhereWithAggregatesInput = {
+  AND?: Prisma.VerificationTokenScalarWhereWithAggregatesInput | Prisma.VerificationTokenScalarWhereWithAggregatesInput[]
+  OR?: Prisma.VerificationTokenScalarWhereWithAggregatesInput[]
+  NOT?: Prisma.VerificationTokenScalarWhereWithAggregatesInput | Prisma.VerificationTokenScalarWhereWithAggregatesInput[]
+  identifier?: Prisma.StringWithAggregatesFilter<"VerificationToken"> | string
+  token?: Prisma.StringWithAggregatesFilter<"VerificationToken"> | string
+  expires?: Prisma.DateTimeWithAggregatesFilter<"VerificationToken"> | Date | string
+}
+
+export type VerificationTokenCreateInput = {
+  identifier: string
+  token: string
+  expires: Date | string
+}
+
+export type VerificationTokenUncheckedCreateInput = {
+  identifier: string
+  token: string
+  expires: Date | string
+}
+
+export type VerificationTokenUpdateInput = {
+  identifier?: Prisma.StringFieldUpdateOperationsInput | string
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type VerificationTokenUncheckedUpdateInput = {
+  identifier?: Prisma.StringFieldUpdateOperationsInput | string
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type VerificationTokenCreateManyInput = {
+  identifier: string
+  token: string
+  expires: Date | string
+}
+
+export type VerificationTokenUpdateManyMutationInput = {
+  identifier?: Prisma.StringFieldUpdateOperationsInput | string
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type VerificationTokenUncheckedUpdateManyInput = {
+  identifier?: Prisma.StringFieldUpdateOperationsInput | string
+  token?: Prisma.StringFieldUpdateOperationsInput | string
+  expires?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string
+}
+
+export type VerificationTokenIdentifierTokenCompoundUniqueInput = {
+  identifier: string
+  token: string
+}
+
+export type VerificationTokenCountOrderByAggregateInput = {
+  identifier?: Prisma.SortOrder
+  token?: Prisma.SortOrder
+  expires?: Prisma.SortOrder
+}
+
+export type VerificationTokenMaxOrderByAggregateInput = {
+  identifier?: Prisma.SortOrder
+  token?: Prisma.SortOrder
+  expires?: Prisma.SortOrder
+}
+
+export type VerificationTokenMinOrderByAggregateInput = {
+  identifier?: Prisma.SortOrder
+  token?: Prisma.SortOrder
+  expires?: Prisma.SortOrder
+}
+
+
+
+export type VerificationTokenSelect<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  identifier?: boolean
+  token?: boolean
+  expires?: boolean
+}, ExtArgs["result"]["verificationToken"]>
+
+export type VerificationTokenSelectCreateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  identifier?: boolean
+  token?: boolean
+  expires?: boolean
+}, ExtArgs["result"]["verificationToken"]>
+
+export type VerificationTokenSelectUpdateManyAndReturn<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetSelect<{
+  identifier?: boolean
+  token?: boolean
+  expires?: boolean
+}, ExtArgs["result"]["verificationToken"]>
+
+export type VerificationTokenSelectScalar = {
+  identifier?: boolean
+  token?: boolean
+  expires?: boolean
+}
+
+export type VerificationTokenOmit<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = runtime.Types.Extensions.GetOmit<"identifier" | "token" | "expires", ExtArgs["result"]["verificationToken"]>
+
+export type $VerificationTokenPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  name: "VerificationToken"
+  objects: {}
+  scalars: runtime.Types.Extensions.GetPayloadResult<{
+    identifier: string
+    token: string
+    expires: Date
+  }, ExtArgs["result"]["verificationToken"]>
+  composites: {}
+}
+
+export type VerificationTokenGetPayload<S extends boolean | null | undefined | VerificationTokenDefaultArgs> = runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload, S>
+
+export type VerificationTokenCountArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> =
+  Omit<VerificationTokenFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: VerificationTokenCountAggregateInputType | true
+  }
+
+export interface VerificationTokenDelegate<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['VerificationToken'], meta: { name: 'VerificationToken' } }
+  /**
+   * Find zero or one VerificationToken that matches the filter.
+   * @param {VerificationTokenFindUniqueArgs} args - Arguments to find a VerificationToken
+   * @example
+   * // Get one VerificationToken
+   * const verificationToken = await prisma.verificationToken.findUnique({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUnique<T extends VerificationTokenFindUniqueArgs>(args: Prisma.SelectSubset<T, VerificationTokenFindUniqueArgs<ExtArgs>>): Prisma.Prisma__VerificationTokenClient<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find one VerificationToken that matches the filter or throw an error with `error.code='P2025'`
+   * if no matches were found.
+   * @param {VerificationTokenFindUniqueOrThrowArgs} args - Arguments to find a VerificationToken
+   * @example
+   * // Get one VerificationToken
+   * const verificationToken = await prisma.verificationToken.findUniqueOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findUniqueOrThrow<T extends VerificationTokenFindUniqueOrThrowArgs>(args: Prisma.SelectSubset<T, VerificationTokenFindUniqueOrThrowArgs<ExtArgs>>): Prisma.Prisma__VerificationTokenClient<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first VerificationToken that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {VerificationTokenFindFirstArgs} args - Arguments to find a VerificationToken
+   * @example
+   * // Get one VerificationToken
+   * const verificationToken = await prisma.verificationToken.findFirst({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirst<T extends VerificationTokenFindFirstArgs>(args?: Prisma.SelectSubset<T, VerificationTokenFindFirstArgs<ExtArgs>>): Prisma.Prisma__VerificationTokenClient<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find the first VerificationToken that matches the filter or
+   * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {VerificationTokenFindFirstOrThrowArgs} args - Arguments to find a VerificationToken
+   * @example
+   * // Get one VerificationToken
+   * const verificationToken = await prisma.verificationToken.findFirstOrThrow({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   */
+  findFirstOrThrow<T extends VerificationTokenFindFirstOrThrowArgs>(args?: Prisma.SelectSubset<T, VerificationTokenFindFirstOrThrowArgs<ExtArgs>>): Prisma.Prisma__VerificationTokenClient<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Find zero or more VerificationTokens that matches the filter.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {VerificationTokenFindManyArgs} args - Arguments to filter and select certain fields only.
+   * @example
+   * // Get all VerificationTokens
+   * const verificationTokens = await prisma.verificationToken.findMany()
+   * 
+   * // Get first 10 VerificationTokens
+   * const verificationTokens = await prisma.verificationToken.findMany({ take: 10 })
+   * 
+   * // Only select the `identifier`
+   * const verificationTokenWithIdentifierOnly = await prisma.verificationToken.findMany({ select: { identifier: true } })
+   * 
+   */
+  findMany<T extends VerificationTokenFindManyArgs>(args?: Prisma.SelectSubset<T, VerificationTokenFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+  /**
+   * Create a VerificationToken.
+   * @param {VerificationTokenCreateArgs} args - Arguments to create a VerificationToken.
+   * @example
+   * // Create one VerificationToken
+   * const VerificationToken = await prisma.verificationToken.create({
+   *   data: {
+   *     // ... data to create a VerificationToken
+   *   }
+   * })
+   * 
+   */
+  create<T extends VerificationTokenCreateArgs>(args: Prisma.SelectSubset<T, VerificationTokenCreateArgs<ExtArgs>>): Prisma.Prisma__VerificationTokenClient<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Create many VerificationTokens.
+   * @param {VerificationTokenCreateManyArgs} args - Arguments to create many VerificationTokens.
+   * @example
+   * // Create many VerificationTokens
+   * const verificationToken = await prisma.verificationToken.createMany({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   *     
+   */
+  createMany<T extends VerificationTokenCreateManyArgs>(args?: Prisma.SelectSubset<T, VerificationTokenCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Create many VerificationTokens and returns the data saved in the database.
+   * @param {VerificationTokenCreateManyAndReturnArgs} args - Arguments to create many VerificationTokens.
+   * @example
+   * // Create many VerificationTokens
+   * const verificationToken = await prisma.verificationToken.createManyAndReturn({
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Create many VerificationTokens and only return the `identifier`
+   * const verificationTokenWithIdentifierOnly = await prisma.verificationToken.createManyAndReturn({
+   *   select: { identifier: true },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  createManyAndReturn<T extends VerificationTokenCreateManyAndReturnArgs>(args?: Prisma.SelectSubset<T, VerificationTokenCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Delete a VerificationToken.
+   * @param {VerificationTokenDeleteArgs} args - Arguments to delete one VerificationToken.
+   * @example
+   * // Delete one VerificationToken
+   * const VerificationToken = await prisma.verificationToken.delete({
+   *   where: {
+   *     // ... filter to delete one VerificationToken
+   *   }
+   * })
+   * 
+   */
+  delete<T extends VerificationTokenDeleteArgs>(args: Prisma.SelectSubset<T, VerificationTokenDeleteArgs<ExtArgs>>): Prisma.Prisma__VerificationTokenClient<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Update one VerificationToken.
+   * @param {VerificationTokenUpdateArgs} args - Arguments to update one VerificationToken.
+   * @example
+   * // Update one VerificationToken
+   * const verificationToken = await prisma.verificationToken.update({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  update<T extends VerificationTokenUpdateArgs>(args: Prisma.SelectSubset<T, VerificationTokenUpdateArgs<ExtArgs>>): Prisma.Prisma__VerificationTokenClient<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+  /**
+   * Delete zero or more VerificationTokens.
+   * @param {VerificationTokenDeleteManyArgs} args - Arguments to filter VerificationTokens to delete.
+   * @example
+   * // Delete a few VerificationTokens
+   * const { count } = await prisma.verificationToken.deleteMany({
+   *   where: {
+   *     // ... provide filter here
+   *   }
+   * })
+   * 
+   */
+  deleteMany<T extends VerificationTokenDeleteManyArgs>(args?: Prisma.SelectSubset<T, VerificationTokenDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more VerificationTokens.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {VerificationTokenUpdateManyArgs} args - Arguments to update one or more rows.
+   * @example
+   * // Update many VerificationTokens
+   * const verificationToken = await prisma.verificationToken.updateMany({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: {
+   *     // ... provide data here
+   *   }
+   * })
+   * 
+   */
+  updateMany<T extends VerificationTokenUpdateManyArgs>(args: Prisma.SelectSubset<T, VerificationTokenUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<Prisma.BatchPayload>
+
+  /**
+   * Update zero or more VerificationTokens and returns the data updated in the database.
+   * @param {VerificationTokenUpdateManyAndReturnArgs} args - Arguments to update many VerificationTokens.
+   * @example
+   * // Update many VerificationTokens
+   * const verificationToken = await prisma.verificationToken.updateManyAndReturn({
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * 
+   * // Update zero or more VerificationTokens and only return the `identifier`
+   * const verificationTokenWithIdentifierOnly = await prisma.verificationToken.updateManyAndReturn({
+   *   select: { identifier: true },
+   *   where: {
+   *     // ... provide filter here
+   *   },
+   *   data: [
+   *     // ... provide data here
+   *   ]
+   * })
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * 
+   */
+  updateManyAndReturn<T extends VerificationTokenUpdateManyAndReturnArgs>(args: Prisma.SelectSubset<T, VerificationTokenUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+  /**
+   * Create or update one VerificationToken.
+   * @param {VerificationTokenUpsertArgs} args - Arguments to update or create a VerificationToken.
+   * @example
+   * // Update or create a VerificationToken
+   * const verificationToken = await prisma.verificationToken.upsert({
+   *   create: {
+   *     // ... data to create a VerificationToken
+   *   },
+   *   update: {
+   *     // ... in case it already exists, update
+   *   },
+   *   where: {
+   *     // ... the filter for the VerificationToken we want to update
+   *   }
+   * })
+   */
+  upsert<T extends VerificationTokenUpsertArgs>(args: Prisma.SelectSubset<T, VerificationTokenUpsertArgs<ExtArgs>>): Prisma.Prisma__VerificationTokenClient<runtime.Types.Result.GetResult<Prisma.$VerificationTokenPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+  /**
+   * Count the number of VerificationTokens.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {VerificationTokenCountArgs} args - Arguments to filter VerificationTokens to count.
+   * @example
+   * // Count the number of VerificationTokens
+   * const count = await prisma.verificationToken.count({
+   *   where: {
+   *     // ... the filter for the VerificationTokens we want to count
+   *   }
+   * })
+  **/
+  count<T extends VerificationTokenCountArgs>(
+    args?: Prisma.Subset<T, VerificationTokenCountArgs>,
+  ): Prisma.PrismaPromise<
+    T extends runtime.Types.Utils.Record<'select', any>
+      ? T['select'] extends true
+        ? number
+        : Prisma.GetScalarType<T['select'], VerificationTokenCountAggregateOutputType>
+      : number
+  >
+
+  /**
+   * Allows you to perform aggregations operations on a VerificationToken.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {VerificationTokenAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+   * @example
+   * // Ordered by age ascending
+   * // Where email contains prisma.io
+   * // Limited to the 10 users
+   * const aggregations = await prisma.user.aggregate({
+   *   _avg: {
+   *     age: true,
+   *   },
+   *   where: {
+   *     email: {
+   *       contains: "prisma.io",
+   *     },
+   *   },
+   *   orderBy: {
+   *     age: "asc",
+   *   },
+   *   take: 10,
+   * })
+  **/
+  aggregate<T extends VerificationTokenAggregateArgs>(args: Prisma.Subset<T, VerificationTokenAggregateArgs>): Prisma.PrismaPromise<GetVerificationTokenAggregateType<T>>
+
+  /**
+   * Group by VerificationToken.
+   * Note, that providing `undefined` is treated as the value not being there.
+   * Read more here: https://pris.ly/d/null-undefined
+   * @param {VerificationTokenGroupByArgs} args - Group by arguments.
+   * @example
+   * // Group by city, order by createdAt, get count
+   * const result = await prisma.user.groupBy({
+   *   by: ['city', 'createdAt'],
+   *   orderBy: {
+   *     createdAt: true
+   *   },
+   *   _count: {
+   *     _all: true
+   *   },
+   * })
+   * 
+  **/
+  groupBy<
+    T extends VerificationTokenGroupByArgs,
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
+    >,
+    OrderByArg extends Prisma.True extends HasSelectOrTake
+      ? { orderBy: VerificationTokenGroupByArgs['orderBy'] }
+      : { orderBy?: VerificationTokenGroupByArgs['orderBy'] },
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
+    ? `Error: "by" must not be empty.`
+    : HavingValid extends Prisma.False
+    ? {
+        [P in HavingFields]: P extends ByFields
+          ? never
+          : P extends string
+          ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+          : [
+              Error,
+              'Field ',
+              P,
+              ` in "having" needs to be provided in "by"`,
+            ]
+      }[HavingFields]
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "take", you also need to provide "orderBy"'
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
+        ? {}
+        : {
+            [P in OrderFields]: P extends ByFields
+              ? never
+              : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+          }[OrderFields]
+      : 'Error: If you provide "skip", you also need to provide "orderBy"'
+    : ByValid extends Prisma.True
+    ? {}
+    : {
+        [P in OrderFields]: P extends ByFields
+          ? never
+          : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+      }[OrderFields]
+  >(args: Prisma.SubsetIntersection<T, VerificationTokenGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetVerificationTokenGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+/**
+ * Fields of the VerificationToken model
+ */
+readonly fields: VerificationTokenFieldRefs;
+}
+
+/**
+ * The delegate class that acts as a "Promise-like" for VerificationToken.
+ * Why is this prefixed with `Prisma__`?
+ * Because we want to prevent naming conflicts as mentioned in
+ * https://github.com/prisma/prisma-client-js/issues/707
+ */
+export interface Prisma__VerificationTokenClient<T, Null = never, ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+  readonly [Symbol.toStringTag]: "PrismaPromise"
+  /**
+   * Attaches callbacks for the resolution and/or rejection of the Promise.
+   * @param onfulfilled The callback to execute when the Promise is resolved.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of which ever callback is executed.
+   */
+  then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): runtime.Types.Utils.JsPromise<TResult1 | TResult2>
+  /**
+   * Attaches a callback for only the rejection of the Promise.
+   * @param onrejected The callback to execute when the Promise is rejected.
+   * @returns A Promise for the completion of the callback.
+   */
+  catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): runtime.Types.Utils.JsPromise<T | TResult>
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): runtime.Types.Utils.JsPromise<T>
+}
+
+
+
+
+/**
+ * Fields of the VerificationToken model
+ */
+export interface VerificationTokenFieldRefs {
+  readonly identifier: Prisma.FieldRef<"VerificationToken", 'String'>
+  readonly token: Prisma.FieldRef<"VerificationToken", 'String'>
+  readonly expires: Prisma.FieldRef<"VerificationToken", 'DateTime'>
+}
+    
+
+// Custom InputTypes
+/**
+ * VerificationToken findUnique
+ */
+export type VerificationTokenFindUniqueArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * Filter, which VerificationToken to fetch.
+   */
+  where: Prisma.VerificationTokenWhereUniqueInput
+}
+
+/**
+ * VerificationToken findUniqueOrThrow
+ */
+export type VerificationTokenFindUniqueOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * Filter, which VerificationToken to fetch.
+   */
+  where: Prisma.VerificationTokenWhereUniqueInput
+}
+
+/**
+ * VerificationToken findFirst
+ */
+export type VerificationTokenFindFirstArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * Filter, which VerificationToken to fetch.
+   */
+  where?: Prisma.VerificationTokenWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of VerificationTokens to fetch.
+   */
+  orderBy?: Prisma.VerificationTokenOrderByWithRelationInput | Prisma.VerificationTokenOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for VerificationTokens.
+   */
+  cursor?: Prisma.VerificationTokenWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` VerificationTokens from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` VerificationTokens.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of VerificationTokens.
+   */
+  distinct?: Prisma.VerificationTokenScalarFieldEnum | Prisma.VerificationTokenScalarFieldEnum[]
+}
+
+/**
+ * VerificationToken findFirstOrThrow
+ */
+export type VerificationTokenFindFirstOrThrowArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * Filter, which VerificationToken to fetch.
+   */
+  where?: Prisma.VerificationTokenWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of VerificationTokens to fetch.
+   */
+  orderBy?: Prisma.VerificationTokenOrderByWithRelationInput | Prisma.VerificationTokenOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for searching for VerificationTokens.
+   */
+  cursor?: Prisma.VerificationTokenWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` VerificationTokens from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` VerificationTokens.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of VerificationTokens.
+   */
+  distinct?: Prisma.VerificationTokenScalarFieldEnum | Prisma.VerificationTokenScalarFieldEnum[]
+}
+
+/**
+ * VerificationToken findMany
+ */
+export type VerificationTokenFindManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * Filter, which VerificationTokens to fetch.
+   */
+  where?: Prisma.VerificationTokenWhereInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+   * 
+   * Determine the order of VerificationTokens to fetch.
+   */
+  orderBy?: Prisma.VerificationTokenOrderByWithRelationInput | Prisma.VerificationTokenOrderByWithRelationInput[]
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+   * 
+   * Sets the position for listing VerificationTokens.
+   */
+  cursor?: Prisma.VerificationTokenWhereUniqueInput
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Take `±n` VerificationTokens from the position of the cursor.
+   */
+  take?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+   * 
+   * Skip the first `n` VerificationTokens.
+   */
+  skip?: number
+  /**
+   * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+   * 
+   * Filter by unique combinations of VerificationTokens.
+   */
+  distinct?: Prisma.VerificationTokenScalarFieldEnum | Prisma.VerificationTokenScalarFieldEnum[]
+}
+
+/**
+ * VerificationToken create
+ */
+export type VerificationTokenCreateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * The data needed to create a VerificationToken.
+   */
+  data: Prisma.XOR<Prisma.VerificationTokenCreateInput, Prisma.VerificationTokenUncheckedCreateInput>
+}
+
+/**
+ * VerificationToken createMany
+ */
+export type VerificationTokenCreateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to create many VerificationTokens.
+   */
+  data: Prisma.VerificationTokenCreateManyInput | Prisma.VerificationTokenCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * VerificationToken createManyAndReturn
+ */
+export type VerificationTokenCreateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelectCreateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * The data used to create many VerificationTokens.
+   */
+  data: Prisma.VerificationTokenCreateManyInput | Prisma.VerificationTokenCreateManyInput[]
+  skipDuplicates?: boolean
+}
+
+/**
+ * VerificationToken update
+ */
+export type VerificationTokenUpdateArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * The data needed to update a VerificationToken.
+   */
+  data: Prisma.XOR<Prisma.VerificationTokenUpdateInput, Prisma.VerificationTokenUncheckedUpdateInput>
+  /**
+   * Choose, which VerificationToken to update.
+   */
+  where: Prisma.VerificationTokenWhereUniqueInput
+}
+
+/**
+ * VerificationToken updateMany
+ */
+export type VerificationTokenUpdateManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * The data used to update VerificationTokens.
+   */
+  data: Prisma.XOR<Prisma.VerificationTokenUpdateManyMutationInput, Prisma.VerificationTokenUncheckedUpdateManyInput>
+  /**
+   * Filter which VerificationTokens to update
+   */
+  where?: Prisma.VerificationTokenWhereInput
+  /**
+   * Limit how many VerificationTokens to update.
+   */
+  limit?: number
+}
+
+/**
+ * VerificationToken updateManyAndReturn
+ */
+export type VerificationTokenUpdateManyAndReturnArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelectUpdateManyAndReturn<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * The data used to update VerificationTokens.
+   */
+  data: Prisma.XOR<Prisma.VerificationTokenUpdateManyMutationInput, Prisma.VerificationTokenUncheckedUpdateManyInput>
+  /**
+   * Filter which VerificationTokens to update
+   */
+  where?: Prisma.VerificationTokenWhereInput
+  /**
+   * Limit how many VerificationTokens to update.
+   */
+  limit?: number
+}
+
+/**
+ * VerificationToken upsert
+ */
+export type VerificationTokenUpsertArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * The filter to search for the VerificationToken to update in case it exists.
+   */
+  where: Prisma.VerificationTokenWhereUniqueInput
+  /**
+   * In case the VerificationToken found by the `where` argument doesn't exist, create a new VerificationToken with this data.
+   */
+  create: Prisma.XOR<Prisma.VerificationTokenCreateInput, Prisma.VerificationTokenUncheckedCreateInput>
+  /**
+   * In case the VerificationToken was found with the provided `where` argument, update it with this data.
+   */
+  update: Prisma.XOR<Prisma.VerificationTokenUpdateInput, Prisma.VerificationTokenUncheckedUpdateInput>
+}
+
+/**
+ * VerificationToken delete
+ */
+export type VerificationTokenDeleteArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+  /**
+   * Filter which VerificationToken to delete.
+   */
+  where: Prisma.VerificationTokenWhereUniqueInput
+}
+
+/**
+ * VerificationToken deleteMany
+ */
+export type VerificationTokenDeleteManyArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Filter which VerificationTokens to delete
+   */
+  where?: Prisma.VerificationTokenWhereInput
+  /**
+   * Limit how many VerificationTokens to delete.
+   */
+  limit?: number
+}
+
+/**
+ * VerificationToken without action
+ */
+export type VerificationTokenDefaultArgs<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = {
+  /**
+   * Select specific fields to fetch from the VerificationToken
+   */
+  select?: Prisma.VerificationTokenSelect<ExtArgs> | null
+  /**
+   * Omit specific fields from the VerificationToken
+   */
+  omit?: Prisma.VerificationTokenOmit<ExtArgs> | null
+}
diff --git a/src/lib/collaboration/.dev.vars b/src/lib/cloud/.dev.vars
similarity index 100%
rename from src/lib/collaboration/.dev.vars
rename to src/lib/cloud/.dev.vars
diff --git a/src/lib/collaboration/index.ts b/src/lib/cloud/index.ts
similarity index 100%
rename from src/lib/collaboration/index.ts
rename to src/lib/cloud/index.ts
diff --git a/src/lib/collaboration/protocol.ts b/src/lib/cloud/protocol.ts
similarity index 100%
rename from src/lib/collaboration/protocol.ts
rename to src/lib/cloud/protocol.ts
diff --git a/src/lib/collaboration/room.ts b/src/lib/cloud/room.ts
similarity index 100%
rename from src/lib/collaboration/room.ts
rename to src/lib/cloud/room.ts
diff --git a/src/lib/collaboration/tsconfig.json b/src/lib/cloud/tsconfig.json
similarity index 100%
rename from src/lib/collaboration/tsconfig.json
rename to src/lib/cloud/tsconfig.json
diff --git a/src/lib/collaboration/types.ts b/src/lib/cloud/types.ts
similarity index 100%
rename from src/lib/collaboration/types.ts
rename to src/lib/cloud/types.ts
diff --git a/src/lib/collaboration/utils.ts b/src/lib/cloud/utils.ts
similarity index 100%
rename from src/lib/collaboration/utils.ts
rename to src/lib/cloud/utils.ts
diff --git a/src/lib/collaboration/wrangler.toml b/src/lib/cloud/wrangler.toml
similarity index 100%
rename from src/lib/collaboration/wrangler.toml
rename to src/lib/cloud/wrangler.toml
diff --git a/src/lib/metrics/db-size-collector.ts b/src/lib/metrics/db-size-collector.ts
new file mode 100644
index 00000000..bd7af953
--- /dev/null
+++ b/src/lib/metrics/db-size-collector.ts
@@ -0,0 +1,27 @@
+import prisma from "../../server/db";
+import { dbSizeBytes } from "./registry";
+
+const POLL_INTERVAL_MS = 30_000;
+
+declare global {
+    // eslint-disable-next-line no-var
+    var __scriptio_db_size_timer__: NodeJS.Timeout | undefined;
+}
+
+const refreshDbSize = async () => {
+    try {
+        const rows = await prisma.$queryRaw<{ size: bigint }[]>`
+            SELECT pg_database_size(current_database())::bigint AS size
+        `;
+        const size = rows[0]?.size;
+        if (size !== undefined) dbSizeBytes.set(Number(size));
+    } catch (err) {
+        console.error("[metrics] Failed to refresh DB size:", err);
+    }
+};
+
+export const startDbSizeCollector = () => {
+    if (globalThis.__scriptio_db_size_timer__) return;
+    void refreshDbSize();
+    globalThis.__scriptio_db_size_timer__ = setInterval(refreshDbSize, POLL_INTERVAL_MS);
+};
diff --git a/src/lib/metrics/registry.ts b/src/lib/metrics/registry.ts
new file mode 100644
index 00000000..1f132ac2
--- /dev/null
+++ b/src/lib/metrics/registry.ts
@@ -0,0 +1,46 @@
+import { collectDefaultMetrics, Counter, Gauge, Histogram, Registry } from "prom-client";
+
+type MetricsBundle = {
+    registry: Registry;
+    httpRequestsTotal: Counter<"method" | "route" | "status">;
+    httpRequestDurationSeconds: Histogram<"method" | "route" | "status">;
+    dbSizeBytes: Gauge<string>;
+};
+
+declare global {
+    // eslint-disable-next-line no-var
+    var __scriptio_metrics__: MetricsBundle | undefined;
+}
+
+const buildMetrics = (): MetricsBundle => {
+    const registry = new Registry();
+    collectDefaultMetrics({ register: registry });
+
+    const httpRequestsTotal = new Counter({
+        name: "http_requests_total",
+        help: "Total HTTP requests handled by apiHandler.",
+        labelNames: ["method", "route", "status"] as const,
+        registers: [registry],
+    });
+
+    const httpRequestDurationSeconds = new Histogram({
+        name: "http_request_duration_seconds",
+        help: "HTTP request latency in seconds.",
+        labelNames: ["method", "route", "status"] as const,
+        registers: [registry],
+    });
+
+    const dbSizeBytes = new Gauge({
+        name: "scriptio_db_size_bytes",
+        help: "Current size of the application database in bytes.",
+        registers: [registry],
+    });
+
+    return { registry, httpRequestsTotal, httpRequestDurationSeconds, dbSizeBytes };
+};
+
+const metrics = globalThis.__scriptio_metrics__ ?? buildMetrics();
+
+if (process.env.NODE_ENV !== "production") globalThis.__scriptio_metrics__ = metrics;
+
+export const { registry, httpRequestsTotal, httpRequestDurationSeconds, dbSizeBytes } = metrics;
diff --git a/src/lib/project/project-state.ts b/src/lib/project/project-state.ts
index 5c92e20b..572c298c 100644
--- a/src/lib/project/project-state.ts
+++ b/src/lib/project/project-state.ts
@@ -7,7 +7,7 @@ import { JSONContent } from "@tiptap/react";
 import { Screenplay } from "../utils/types";
 import { PageFormat } from "../utils/enums";
 import * as Y from "yjs";
-import type { ThrottledWebsocketProvider } from "../collaboration/utils";
+import type { ThrottledWebsocketProvider } from "../cloud/utils";
 import { ScreenplaySchema } from "../screenplay/editor";
 import { TitlePageSchema } from "../titlepage/editor";
 import { yXmlFragmentToProseMirrorRootNode } from "y-prosemirror";
@@ -175,7 +175,10 @@ export type ProjectData = {
  * Helper to provide stronger typing for Y.Map where different keys have different types.
  * This avoids manual casts when accessing known keys.
  */
-export interface TypedMap<T extends Record<string, unknown>> extends Omit<Y.Map<T[keyof T]>, "get" | "set" | "toJSON"> {
+export interface TypedMap<T extends Record<string, unknown>> extends Omit<
+    Y.Map<T[keyof T]>,
+    "get" | "set" | "toJSON"
+> {
     get<K extends keyof T>(key: K): T[K] | undefined;
     set<K extends keyof T>(key: K, value: T[K]): T[K];
     toJSON(): T;
@@ -402,7 +405,11 @@ export const useLocalPersistence = (projectId: string | null) => {
 /**
  * Hook to manage cloud WebSocket synchronization.
  */
-export const useCloudSync = (projectId: string | null, ydoc: ProjectState | null, userInfo: UserInfo) => {
+export const useCloudSync = (
+    projectId: string | null,
+    ydoc: ProjectState | null,
+    userInfo: UserInfo,
+) => {
     const [provider, setProvider] = useState<ThrottledWebsocketProvider | null>(null);
     const [users, setUsers] = useState<CollaboratorInfo[]>([]);
     const [connectionStatus, setConnectionStatus] = useState<ConnectionStatus>("disconnected");
@@ -467,7 +474,8 @@ export const useCloudSync = (projectId: string | null, ydoc: ProjectState | null
                 const isDesktop = isTauri();
 
                 // Local-only projects (not cloud-synced) don't need cloud sync
-                const { isLocalOnlyProject } = await import("../persistence/storage-provider/local-persistence");
+                const { isLocalOnlyProject } =
+                    await import("../persistence/storage-provider/local-persistence");
                 if (await isLocalOnlyProject(projectId)) {
                     setConnectionStatus("disconnected");
                     setIsCloudSynced(true);
@@ -487,7 +495,7 @@ export const useCloudSync = (projectId: string | null, ydoc: ProjectState | null
                 }
 
                 // Dynamically import collaboration utils
-                const { ThrottledWebsocketProvider } = await import("../collaboration/utils");
+                const { ThrottledWebsocketProvider } = await import("../cloud/utils");
 
                 const cloudProvider = new ThrottledWebsocketProvider(
                     `${process.env.NEXT_PUBLIC_COLLAB_WEBSOCKET_URL}`,
@@ -566,7 +574,9 @@ export const useCloudSync = (projectId: string | null, ydoc: ProjectState | null
                 // Handle document restore
                 cloudProvider.on("document-restored", async () => {
                     if (!isMountedRef.current) return;
-                    console.log("[ProjectYjs] Document restored — clearing local cache and reloading");
+                    console.log(
+                        "[ProjectYjs] Document restored — clearing local cache and reloading",
+                    );
                     await clearLocalProjectCache(projectId);
                     window.location.reload();
                 });
@@ -598,7 +608,11 @@ export const useCloudSync = (projectId: string | null, ydoc: ProjectState | null
         const handleUnload = async () => {
             if (providerRef.current && ydoc) {
                 const { removeAwarenessStates } = await getYProtocols();
-                removeAwarenessStates(providerRef.current.awareness, [ydoc.clientID], "window unload");
+                removeAwarenessStates(
+                    providerRef.current.awareness,
+                    [ydoc.clientID],
+                    "window unload",
+                );
             }
         };
 
@@ -622,7 +636,11 @@ export const useCloudSync = (projectId: string | null, ydoc: ProjectState | null
                 if (ydoc) {
                     getYProtocols().then(({ removeAwarenessStates }) => {
                         if (providerRef.current) {
-                            removeAwarenessStates(providerRef.current.awareness, [ydoc.clientID], "component unmount");
+                            removeAwarenessStates(
+                                providerRef.current.awareness,
+                                [ydoc.clientID],
+                                "component unmount",
+                            );
                             providerRef.current.destroy();
                             providerRef.current = null;
                             setProvider(null);
@@ -731,19 +749,22 @@ const ymapToMap = <T>(ymap: Y.Map<T>): Map<string, T> => {
 export const useYMap = <T>(ymap: Y.Map<T> | null): Map<string, T> => {
     const cache = useRef<Map<string, T>>(new Map());
     return useSyncExternalStore(
-        useCallback((callback: () => void) => {
-            if (!ymap) {
-                cache.current = new Map();
-                return () => {};
-            }
-            cache.current = ymapToMap(ymap);
-            const observer = () => {
+        useCallback(
+            (callback: () => void) => {
+                if (!ymap) {
+                    cache.current = new Map();
+                    return () => {};
+                }
                 cache.current = ymapToMap(ymap);
-                callback();
-            };
-            ymap.observe(observer);
-            return () => ymap.unobserve(observer);
-        }, [ymap]),
+                const observer = () => {
+                    cache.current = ymapToMap(ymap);
+                    callback();
+                };
+                ymap.observe(observer);
+                return () => ymap.unobserve(observer);
+            },
+            [ymap],
+        ),
         () => cache.current,
         () => new Map(),
     );
@@ -755,19 +776,22 @@ export const useYMap = <T>(ymap: Y.Map<T> | null): Map<string, T> => {
 export const useYArray = <T>(yarray: Y.Array<T> | null): T[] => {
     const cache = useRef<T[]>([]);
     return useSyncExternalStore(
-        useCallback((callback: () => void) => {
-            if (!yarray) {
-                cache.current = [];
-                return () => {};
-            }
-            cache.current = yarray.toArray();
-            const observer = () => {
+        useCallback(
+            (callback: () => void) => {
+                if (!yarray) {
+                    cache.current = [];
+                    return () => {};
+                }
                 cache.current = yarray.toArray();
-                callback();
-            };
-            yarray.observe(observer);
-            return () => yarray.unobserve(observer);
-        }, [yarray]),
+                const observer = () => {
+                    cache.current = yarray.toArray();
+                    callback();
+                };
+                yarray.observe(observer);
+                return () => yarray.unobserve(observer);
+            },
+            [yarray],
+        ),
         () => cache.current,
         () => [],
     );
diff --git a/src/lib/session.ts b/src/lib/session.ts
index 5d468e49..6c177649 100644
--- a/src/lib/session.ts
+++ b/src/lib/session.ts
@@ -1,6 +1,7 @@
 import { CookieUser } from "@src/lib/utils/types";
 import { headers } from "next/headers";
 import { decode } from "next-auth/jwt";
+import { UserRole } from "../generated/client/client";
 import { auth } from "@src/auth";
 
 const SESSION_COOKIE_SALT = "authjs.session-token";
@@ -30,6 +31,7 @@ export const getCookieUser = async (): Promise<CookieUser | undefined> => {
                     id: decoded.id as string,
                     email: decoded.email as string,
                     createdAt: new Date(decoded.createdAt as string),
+                    role: (decoded.role as UserRole) ?? UserRole.USER,
                 };
             }
         } catch {
diff --git a/src/lib/utils/admin-guard.ts b/src/lib/utils/admin-guard.ts
new file mode 100644
index 00000000..354613ab
--- /dev/null
+++ b/src/lib/utils/admin-guard.ts
@@ -0,0 +1,10 @@
+import { UserRole } from "../../generated/client/client";
+import { ForbiddenError, UserNotFoundError } from "./api-utils";
+import type { CookieUser } from "./types";
+import * as UserService from "@src/server/service/user-service";
+
+export async function assertAdmin(user: CookieUser) {
+    const dbUser = await UserService.getUserFromId(user.id);
+    if (!dbUser) throw new UserNotFoundError();
+    if (dbUser.role !== UserRole.ADMIN) throw new ForbiddenError();
+}
diff --git a/src/lib/utils/api-handler.ts b/src/lib/utils/api-handler.ts
index 7cc7582e..f8903e02 100644
--- a/src/lib/utils/api-handler.ts
+++ b/src/lib/utils/api-handler.ts
@@ -1,7 +1,9 @@
 import { NextRequest, NextResponse } from "next/server";
 import { AppError } from "./api-utils";
 import { isRedirectError } from "next/dist/client/components/redirect-error";
+import { UserRole } from "../../generated/client/client";
 import type { CookieUser } from "./types";
+import { httpRequestDurationSeconds, httpRequestsTotal } from "../metrics/registry";
 
 export type ApiContext = {
     routeParams: RouteParams;
@@ -14,6 +16,15 @@ export type AuthApiContext = ApiContext & { user: CookieUser };
 export type RouteParams = Record<string, string>;
 export type SearchParams = Record<string, string>;
 
+const ID_SEGMENT = /^[0-9a-z_-]{20,}$/i;
+
+const normalizeRoute = (pathname: string): string => {
+    return pathname
+        .split("/")
+        .map((segment) => (ID_SEGMENT.test(segment) ? ":id" : segment))
+        .join("/");
+};
+
 function handleError(err: unknown): NextResponse {
     if (err instanceof AppError) {
         return NextResponse.json(
@@ -33,27 +44,41 @@ export const apiHandler = <T extends ApiContext>(
         req: NextRequest,
         { params }: { params?: Promise<RouteParams> | RouteParams } = {},
     ) => {
-        try {
-            const url = new URL(req.url);
-            const searchParams = Object.fromEntries(url.searchParams);
-            const routeParams = params ? (params instanceof Promise ? await params : params) : {};
-
-            const userId = req.headers.get("x-user-id");
-            const user = userId
-                ? {
-                      id: userId,
-                      email: req.headers.get("x-user-email") ?? "",
-                      createdAt: new Date(req.headers.get("x-user-created-at") ?? 0),
-                  }
-                : undefined;
-            const context = { routeParams, searchParams, user } as T;
-            const result = await handler(req, context);
-
-            if (result instanceof Response) return result;
-            return NextResponse.json(result, { status: 200 });
-        } catch (err: unknown) {
-            if (isRedirectError(err)) throw err;
-            return handleError(err);
-        }
+        const start = performance.now();
+        const method = req.method;
+        const route = normalizeRoute(req.nextUrl.pathname);
+
+        const run = async (): Promise<Response> => {
+            try {
+                const url = new URL(req.url);
+                const searchParams = Object.fromEntries(url.searchParams);
+                const routeParams = params ? (params instanceof Promise ? await params : params) : {};
+
+                const userId = req.headers.get("x-user-id");
+                const user = userId
+                    ? {
+                          id: userId,
+                          email: req.headers.get("x-user-email") ?? "",
+                          createdAt: new Date(req.headers.get("x-user-created-at") ?? 0),
+                          role: (req.headers.get("x-user-role") as UserRole) ?? UserRole.USER,
+                      }
+                    : undefined;
+                const context = { routeParams, searchParams, user } as T;
+                const result = await handler(req, context);
+
+                if (result instanceof Response) return result;
+                return NextResponse.json(result, { status: 200 });
+            } catch (err: unknown) {
+                if (isRedirectError(err)) throw err;
+                return handleError(err);
+            }
+        };
+
+        const response = await run();
+        const status = String(response.status);
+        const durationSeconds = (performance.now() - start) / 1000;
+        httpRequestsTotal.inc({ method, route, status });
+        httpRequestDurationSeconds.observe({ method, route, status }, durationSeconds);
+        return response;
     };
 };
diff --git a/src/lib/utils/hooks.ts b/src/lib/utils/hooks.ts
index c0feddbf..88c6cbc1 100644
--- a/src/lib/utils/hooks.ts
+++ b/src/lib/utils/hooks.ts
@@ -11,7 +11,7 @@ import { Collaborator, ProjectInvite, ProjectMembershipPayload } from "@src/serv
 import { KeyBindingMap, tinykeys } from "tinykeys";
 import { DEFAULT_KEYBINDS, executeKeybindAction, KeybindId } from "./keybinds";
 import { usePathname, useRouter, useSearchParams } from "next/navigation";
-import { ProjectRole } from "@prisma/client";
+import { ProjectRole } from "../../generated/client/browser";
 import { isTauri } from "@tauri-apps/api/core";
 
 interface Position {
diff --git a/src/lib/utils/roles.ts b/src/lib/utils/roles.ts
index 2cd492b3..c063f0ad 100644
--- a/src/lib/utils/roles.ts
+++ b/src/lib/utils/roles.ts
@@ -1,4 +1,4 @@
-import { ProjectRole } from "@prisma/client";
+import { ProjectRole } from "../../generated/client/browser";
 
 const ROLES: Record<ProjectRole, number> = {
     // Viewers can only view project
diff --git a/src/lib/utils/types.ts b/src/lib/utils/types.ts
index d467983d..e270db6d 100644
--- a/src/lib/utils/types.ts
+++ b/src/lib/utils/types.ts
@@ -1,4 +1,5 @@
 import { JSONContent } from "@tiptap/core";
+import { UserRole } from "../../generated/client/browser";
 import { UpdateSettings } from "../../server/repository/user-repository";
 
 export type Screenplay = JSONContent[];
@@ -7,6 +8,7 @@ export type CookieUser = {
     id: string;
     email: string;
     createdAt: Date;
+    role: UserRole;
 };
 
 export type User = CookieUser & {
diff --git a/src/proxy.ts b/src/proxy.ts
index 2ef9df2f..4398c0e5 100644
--- a/src/proxy.ts
+++ b/src/proxy.ts
@@ -8,15 +8,38 @@ const PUBLIC_API_PREFIXES = [
     "/api/webhooks/", // External webhooks (Stripe, etc.)
     "/api/projects/accept-invite", // Accessible to unauthenticated users via invite link
     "/api/contact", // Public contact form
+    "/api/metrics", // Prometheus scrape (gated by bearer token in route handler)
 ];
 
 function isPublicApiRoute(pathname: string): boolean {
     return PUBLIC_API_PREFIXES.some((prefix) => pathname.startsWith(prefix));
 }
 
+function isAdminPageRoute(pathname: string): boolean {
+    return pathname === "/admin" || pathname.startsWith("/admin/");
+}
+
 export async function proxy(request: NextRequest) {
-    if (!isPublicApiRoute(request.nextUrl.pathname)) {
-        const token = await getToken({ req: request, secret: process.env.AUTH_SECRET });
+    const { pathname } = request.nextUrl;
+    const token = await getToken({ req: request, secret: process.env.AUTH_SECRET });
+
+    // Admin pages: proxy only checks authentication.
+    // Role enforcement happens in src/app/admin/layout.tsx via auth(), which runs the
+    // full jwt callback in Node.js (with DB access) and always carries a fresh role.
+    // Checking role here via getToken() would read a potentially-stale JWT cookie.
+    if (isAdminPageRoute(pathname)) {
+        if (!token) {
+            return NextResponse.redirect(new URL("/", request.url));
+        }
+        return NextResponse.next();
+    }
+
+    // API surface
+    if (pathname.startsWith("/api/")) {
+        if (isPublicApiRoute(pathname)) {
+            return NextResponse.next();
+        }
+
         if (!token) {
             return NextResponse.json(
                 { status: "error", message: "Authentication required" },
@@ -28,11 +51,13 @@ export async function proxy(request: NextRequest) {
         headers.set("x-user-id", token.id as string);
         headers.set("x-user-email", token.email as string);
         headers.set("x-user-created-at", (token.createdAt as string) ?? "0");
+        headers.set("x-user-role", (token.role as string) ?? "USER");
         return NextResponse.next({ request: { headers } });
     }
+
     return NextResponse.next();
 }
 
 export const config = {
-    matcher: "/api/:path*",
+    matcher: ["/api/:path*", "/admin/:path*"],
 };
diff --git a/src/server/db.ts b/src/server/db.ts
index 27b30cb1..c339eb28 100644
--- a/src/server/db.ts
+++ b/src/server/db.ts
@@ -1,7 +1,11 @@
-import { PrismaClient } from "@prisma/client";
+import { PrismaClient } from "../generated/client/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+import pg from "pg";
 
 const prismaClientSingleton = () => {
-    return new PrismaClient();
+    const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });
+    const adapter = new PrismaPg(pool);
+    return new PrismaClient({ adapter });
 };
 
 declare global {
diff --git a/src/server/repository/project-repository.ts b/src/server/repository/project-repository.ts
index 51226675..df9780a5 100644
--- a/src/server/repository/project-repository.ts
+++ b/src/server/repository/project-repository.ts
@@ -1,5 +1,5 @@
 import { ProjectCreation, ProjectUpdate } from "../../lib/utils/types";
-import { Prisma, ProjectRole } from "@prisma/client";
+import { Prisma, ProjectRole } from "../../generated/client/client";
 import prisma from "../db";
 
 import * as S3 from "@src/lib/s3";
@@ -19,7 +19,7 @@ const projectMembershipSelect = {
     role: true,
 };
 
-const collaboratorSelect = Prisma.validator<Prisma.ProjectMemberSelect>()({
+const collaboratorSelect = {
     user: {
         select: {
             id: true,
@@ -27,7 +27,7 @@ const collaboratorSelect = Prisma.validator<Prisma.ProjectMemberSelect>()({
         },
     },
     role: true,
-});
+} satisfies Prisma.ProjectMemberSelect;
 
 export type Collaborator = Prisma.ProjectMemberGetPayload<{
     select: typeof collaboratorSelect;
@@ -232,4 +232,69 @@ export class ProjectRepository {
             },
         });
     }
+
+    countAll() {
+        return prisma.project.count();
+    }
+
+    countMembershipsByUser(userId: string) {
+        return prisma.projectMember.count({ where: { userId } });
+    }
+
+    fetchProjectById(projectId: string) {
+        return prisma.project.findUnique({
+            where: { id: projectId },
+            select: {
+                id: true,
+                title: true,
+                author: true,
+                description: true,
+                createdAt: true,
+                updatedAt: true,
+                _count: { select: { members: true, invitations: true } },
+            },
+        });
+    }
+
+    fetchInvitesWithMeta(projectId: string) {
+        return prisma.projectInvitation.findMany({
+            where: { projectId },
+            select: { email: true, createdAt: true },
+            orderBy: { createdAt: "asc" },
+        });
+    }
+
+    async searchProjects(term: string, limit: number, cursor?: number) {
+        const isUuid = /^[0-9a-f-]{36,}$/i.test(term);
+
+        if (isUuid) {
+            const project = await prisma.project.findUnique({
+                where: { id: term },
+                select: {
+                    id: true,
+                    title: true,
+                    author: true,
+                    createdAt: true,
+                    updatedAt: true,
+                    _count: { select: { members: true } },
+                },
+            });
+            return project ? [project] : [];
+        }
+
+        return prisma.project.findMany({
+            where: { title: { contains: term, mode: "insensitive" } },
+            select: {
+                id: true,
+                title: true,
+                author: true,
+                createdAt: true,
+                updatedAt: true,
+                _count: { select: { members: true } },
+            },
+            orderBy: { updatedAt: "desc" },
+            take: limit,
+            skip: cursor ?? 0,
+        });
+    }
 }
diff --git a/src/server/repository/transaction-repository.ts b/src/server/repository/transaction-repository.ts
new file mode 100644
index 00000000..15797cf4
--- /dev/null
+++ b/src/server/repository/transaction-repository.ts
@@ -0,0 +1,26 @@
+import prisma from "../db";
+
+export class TransactionRepository {
+    fetchByUser(userId: string) {
+        return prisma.transaction.findMany({
+            where: { userId },
+            orderBy: { createdAt: "desc" },
+            select: {
+                id: true,
+                provider: true,
+                transactionId: true,
+                createdAt: true,
+            },
+        });
+    }
+
+    countByUser(userId: string) {
+        return prisma.transaction.count({ where: { userId } });
+    }
+
+    countSince(since: Date) {
+        return prisma.transaction.count({
+            where: { createdAt: { gte: since } },
+        });
+    }
+}
diff --git a/src/server/repository/user-repository.ts b/src/server/repository/user-repository.ts
index 0ce7bf9f..a8374617 100644
--- a/src/server/repository/user-repository.ts
+++ b/src/server/repository/user-repository.ts
@@ -1,5 +1,5 @@
 import { UserSettings } from "@src/lib/utils/types";
-import { Prisma, SubscriptionProvider } from "@prisma/client";
+import { Prisma, SubscriptionProvider } from "../../generated/client/client";
 import prisma from "../db";
 
 export type UpdateSettings = {
@@ -71,6 +71,7 @@ export class UserRepository {
                 settings: true,
                 username: true,
                 color: true,
+                role: true,
                 isProUntil: true,
                 isSubscriptionCancelled: true,
                 subscriptionProvider: true,
@@ -78,6 +79,38 @@ export class UserRepository {
         });
     }
 
+    countAll() {
+        return prisma.user.count();
+    }
+
+    countActivePro(now: Date = new Date()) {
+        return prisma.user.count({
+            where: { isProUntil: { gt: now } },
+        });
+    }
+
+    searchUsers(term: string, limit: number, cursor?: number) {
+        const isLikelyId = /^[0-9a-f-]{30,}$/i.test(term);
+        const where: Prisma.UserWhereInput = isLikelyId
+            ? { OR: [{ id: term }, { email: { contains: term, mode: "insensitive" } }] }
+            : { email: { contains: term, mode: "insensitive" } };
+
+        return prisma.user.findMany({
+            where,
+            orderBy: { createdAt: "desc" },
+            take: limit,
+            ...(cursor !== undefined && { skip: cursor }),
+            select: {
+                id: true,
+                email: true,
+                createdAt: true,
+                role: true,
+                isProUntil: true,
+                subscriptionProvider: true,
+            },
+        });
+    }
+
     /** Find the user who owns a given Stripe subscription ID. */
     fetchUserByStripeSubscriptionId(subscriptionId: string) {
         return prisma.transaction.findFirst({
diff --git a/src/server/service/project-service.ts b/src/server/service/project-service.ts
index ebad0ecc..1d743c22 100644
--- a/src/server/service/project-service.ts
+++ b/src/server/service/project-service.ts
@@ -1,4 +1,4 @@
-import { ProjectRole } from "@prisma/client";
+import { ProjectRole } from "../../generated/client/client";
 import { ProjectUpdate, ProjectCreation } from "../../lib/utils/types";
 import { ProjectRepository } from "../repository/project-repository";
 
@@ -59,3 +59,23 @@ export async function deleteInviteFromEmail(email: string, projectId: string) {
 export async function deleteProjectMember(projectId: string, userId: string) {
     return repository.deleteProjectMember(projectId, userId);
 }
+
+export async function countProjects() {
+    return repository.countAll();
+}
+
+export async function countMembershipsByUser(userId: string) {
+    return repository.countMembershipsByUser(userId);
+}
+
+export async function searchProjects(term: string, limit: number, cursor?: number) {
+    return repository.searchProjects(term, limit, cursor);
+}
+
+export async function getProjectById(projectId: string) {
+    return repository.fetchProjectById(projectId);
+}
+
+export async function getInvitesWithMeta(projectId: string) {
+    return repository.fetchInvitesWithMeta(projectId);
+}
diff --git a/src/server/service/transaction-service.ts b/src/server/service/transaction-service.ts
new file mode 100644
index 00000000..d2eb42c7
--- /dev/null
+++ b/src/server/service/transaction-service.ts
@@ -0,0 +1,15 @@
+import { TransactionRepository } from "../repository/transaction-repository";
+
+const repository = new TransactionRepository();
+
+export const getTransactionsByUser = async (userId: string) => {
+    return repository.fetchByUser(userId);
+};
+
+export const countTransactionsByUser = async (userId: string) => {
+    return repository.countByUser(userId);
+};
+
+export const countTransactionsSince = async (since: Date) => {
+    return repository.countSince(since);
+};
diff --git a/src/server/service/user-service.ts b/src/server/service/user-service.ts
index 85c09cc7..6cde07f0 100644
--- a/src/server/service/user-service.ts
+++ b/src/server/service/user-service.ts
@@ -39,3 +39,15 @@ export const getStripeSubscriptionId = async (userId: string) => {
     return result?.transactionId ?? null;
 };
 
+export const searchUsers = async (term: string, limit: number, cursor?: number) => {
+    return repository.searchUsers(term, limit, cursor);
+};
+
+export const countUsers = async () => {
+    return repository.countAll();
+};
+
+export const countActiveProUsers = async () => {
+    return repository.countActivePro();
+};
+
diff --git a/vitest.config.ts b/vitest.config.ts
index 2b617081..75c028a3 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -1,7 +1,10 @@
 import { defineConfig } from "vitest/config";
 import path from "path";
+import { fileURLToPath } from "url";
 import BenchJsonReporter from "./src/tests/helpers/bench-json-reporter";
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
 export default defineConfig({
     test: {
         browser: {