@rawan-temo/prisma-zod-generator 3.3.1-config-coercion.0

package/LICENSE-PRO.md

@@ -0,0 +1,246 @@
+<!-- SPDX-License-Identifier: LicenseRef-PZG-Pro -->
+
+# PZG Pro Commercial License Agreement
+
+**Version 1.0 - Effective Date: 2025**
+
+This Commercial License Agreement ("Agreement") is between Omar Dulaimi ("Licensor") and the individual or organization purchasing a PZG Pro license ("Licensee").
+
+## 1. Definitions
+
+**"Pro Features"** refers to all code, features, and functionality contained in:
+- The `src/pro/` directory of the private submodule repository
+- The obfuscated code in `lib/pro/` directory of the published npm package
+- Any features requiring a valid PZG Pro license key
+
+**"Core Features"** refers to all code, features, and functionality licensed under the MIT License (see LICENSE file).
+
+**"License Key"** refers to the unique cryptographic key provided to Licensee upon purchase.
+
+**"Developer Seat"** refers to one individual developer authorized to use Pro Features.
+
+**"Organization"** refers to the legal entity (company, non-profit, or individual) purchasing the license.
+
+## 2. Grant of License
+
+Subject to the terms of this Agreement and payment of applicable fees, Licensor grants Licensee a **non-exclusive, non-transferable, non-sublicensable** license to:
+
+1. Use Pro Features in Licensee's applications
+2. Modify Pro Features for internal use only
+3. Deploy applications using Pro Features to production
+
+**This license is limited to the number of Developer Seats purchased.**
+
+## 3. License Tiers
+
+### Starter License ($69/year)
+- **Developer Seats:** 1
+- **Usage:** Individual developers or solo entrepreneurs
+- **Support:** Community channels with occasional check-ins
+- **Features:** Core generator, Server Actions Pack, Form UX Pack, basic drift detection
+- **Restrictions:** Seat limit enforced at 1 developer
+
+### Professional License ($199/year)
+- **Developer Seats:** Up to 5
+- **Usage:** Production teams that need policy and governance tooling
+- **Support:** Prioritized responses via GitHub discussions/issues
+- **Features:** Everything in Starter plus Policies & Redaction, Drift Guard, PostgreSQL RLS, Performance Pack, SDK Publisher
+- **Restrictions:** None
+
+### Business License ($599/year)
+- **Developer Seats:** Unlimited
+- **Usage:** Growing companies collaborating across squads
+- **Support:** Priority support with expedited responses and preview builds
+- **Features:** Everything in Professional plus API Docs Pack, Contract Testing Pack, Data Factories
+- **Restrictions:** None
+
+### Enterprise License (Custom Pricing)
+- **Developer Seats:** Unlimited
+- **Usage:** Enterprise organizations with strategic integration needs
+- **Support:** Priority support with roadmap sessions
+- **Features:** Everything in Business plus Multi-Tenant Kit, quarterly roadmap reviews, co-developed integration or feature pack
+- **Additional:** White-glove onboarding playbooks, optional source code escrow
+
+## 4. Restrictions
+
+Licensee **SHALL NOT**:
+
+1. **Reverse Engineer:** Decompile, deobfuscate, disassemble, or reverse engineer Pro Features
+2. **Redistribute:** Distribute, sublicense, sell, or transfer Pro Features to third parties
+3. **Share License Keys:** Share, publish, or distribute License Keys
+4. **Remove Protection:** Attempt to bypass, remove, or disable license validation
+5. **Exceed Seats:** Use Pro Features with more Developer Seats than licensed
+6. **Create Derivatives:** Create derivative works based on Pro Features for distribution
+7. **Competitive Use:** Use Pro Features to build competing products
+
+## 5. Permitted Uses
+
+Licensee **MAY**:
+
+1. **Internal Use:** Use Pro Features within the licensed Organization
+2. **Client Projects:** Build applications for clients using Pro Features (license stays with developer, not client)
+3. **Deployment:** Deploy unlimited applications to production
+4. **Modifications:** Modify Pro Features for internal use
+5. **Backup:** Create backup copies for disaster recovery
+
+## 6. License Validation
+
+Pro Features include **license validation** that:
+
+1. Checks for valid License Key via environment variable (`PZG_LICENSE_KEY`)
+2. Validates key authenticity using cryptographic signatures
+3. Enforces seat limits and feature access
+4. Caches license status locally (30-day offline grace period)
+
+**Tampering with license validation is strictly prohibited** and will result in immediate termination.
+
+## 7. Compliance & Auditing
+
+### 7.1 Self-Reporting
+Licensee agrees to accurately report the number of Developer Seats using Pro Features.
+
+### 7.2 Audit Rights
+Licensor reserves the right to audit Licensee's use of Pro Features upon reasonable notice (minimum 14 days). Audits may include:
+- Reviewing License Key usage
+- Inspecting deployment environments
+- Requesting documentation of Developer Seat allocation
+
+### 7.3 Audit Findings
+If audit reveals under-licensing (more seats than licensed):
+- Licensee must purchase additional licenses within 30 days
+- Licensee pays for audit costs if under-licensing >20%
+
+## 8. Payment Terms
+
+### 8.1 Annual Subscription
+All licenses are **annual subscriptions** billed yearly in advance.
+
+### 8.2 Automatic Renewal
+Licenses automatically renew unless canceled 30 days before renewal date.
+
+### 8.3 Refund Policy
+- **14-day trial:** No credit card required
+- **Refunds:** Available within 30 days of initial purchase if Pro Features are unused
+- **Cancellation:** No refunds for mid-term cancellations (access continues until end of period)
+
+### 8.4 Late Payment
+Licenses unpaid 14 days after due date will be automatically suspended.
+
+## 9. Ownership & Intellectual Property
+
+### 9.1 Licensor Ownership
+Licensor retains all rights, title, and interest in Pro Features, including:
+- Source code
+- Trade secrets
+- Patents (if applicable)
+- Trademarks
+
+### 9.2 Licensee Ownership
+Licensee retains ownership of:
+- Applications built using Pro Features
+- Modifications made for internal use
+- Generated code/schemas (not the generator itself)
+
+## 10. Support & Updates
+
+### 10.1 Updates
+Licensee receives all updates and bug fixes for Pro Features during the active license period.
+
+### 10.2 Breaking Changes
+Major version updates (e.g., v2.0 → v3.0) may require license upgrade or renewal.
+
+### 10.3 Support Levels
+- **Starter:** Best-effort email responses (1 seat)
+- **Professional:** Prioritized responses via GitHub discussions/issues
+- **Business:** Priority support with early access previews
+- **Enterprise:** Dedicated support with quarterly roadmap reviews and co-planning
+
+## 11. Warranty & Disclaimer
+
+### 11.1 Limited Warranty
+Licensor warrants that Pro Features will substantially conform to documentation for 90 days from purchase.
+
+### 11.2 Disclaimer
+EXCEPT AS EXPRESSLY PROVIDED, PRO FEATURES ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+## 12. Limitation of Liability
+
+IN NO EVENT SHALL LICENSOR BE LIABLE FOR:
+- Indirect, incidental, special, or consequential damages
+- Loss of profits, data, or business interruption
+- Damages exceeding fees paid in the 12 months prior to claim
+
+## 13. Term & Termination
+
+### 13.1 Term
+License begins on purchase date and continues for one year (annual subscription).
+
+### 13.2 Termination for Breach
+Licensor may terminate immediately if Licensee:
+- Violates reverse engineering restrictions
+- Exceeds licensed Developer Seats
+- Shares License Keys
+- Fails to pay within 30 days of due date
+
+### 13.3 Effect of Termination
+Upon termination, Licensee must:
+- Cease using Pro Features
+- Remove Pro Features from production
+- Destroy all copies of obfuscated code
+
+**Core Features (MIT Licensed) remain usable after termination.**
+
+## 14. Confidentiality
+
+Pro Features include **trade secrets** and **proprietary information**. Licensee agrees to:
+- Maintain confidentiality of Pro Features
+- Not disclose implementation details to third parties
+- Take reasonable measures to prevent unauthorized access
+
+## 15. Export Compliance
+
+Licensee agrees to comply with all applicable export control laws and regulations.
+
+## 16. Governing Law
+
+This Agreement is governed by the laws of **the State of California, United States**, without regard to conflict of law principles.
+
+## 17. Dispute Resolution
+
+### 17.1 Negotiation
+Parties agree to first attempt good-faith negotiation for 30 days.
+
+### 17.2 Arbitration
+If negotiation fails, disputes will be resolved through binding arbitration.
+
+## 18. Entire Agreement
+
+This Agreement constitutes the entire agreement between parties and supersedes all prior agreements.
+
+## 19. Amendments
+
+Licensor may update this Agreement with 30 days notice. Continued use after notice period constitutes acceptance.
+
+## 20. Severability
+
+If any provision is found invalid, the remaining provisions remain in effect.
+
+## 21. Contact Information
+
+**Licensor:** Omar Dulaimi
+**Contact:** DM [@omardulaimidev on X](https://x.com/omardulaimidev)
+**Website:** https://omar-dulaimi.github.io/prisma-zod-generator/pricing
+**Support:** https://github.com/omar-dulaimi/prisma-zod-generator/issues
+
+---
+
+## Acceptance
+
+By purchasing a PZG Pro license, using Pro Features, or entering a License Key, you acknowledge that you have read, understood, and agree to be bound by this Agreement.
+
+**Last Updated:** January 2025
+**Version:** 1.0
+
+---
+
+**Questions about licensing?** Reach out via [@omardulaimidev on X](https://x.com/omardulaimidev)

package/README.md

@@ -0,0 +1,244 @@
+# Prisma Zod Generator
+
+A Prisma generator that emits [Zod](https://zod.dev) schemas from your Prisma schema. It runs as part of
+`prisma generate`, so your validation schemas are regenerated from the same source of truth as your Prisma Client.
+
+[![npm version](https://img.shields.io/npm/v/prisma-zod-generator.svg?color=16C464&label=npm)](https://www.npmjs.com/package/prisma-zod-generator)
+[![downloads](https://img.shields.io/npm/dw/prisma-zod-generator.svg?color=8B5CF6&label=downloads)](https://www.npmjs.com/package/prisma-zod-generator)
+[![CI](https://img.shields.io/github/actions/workflow/status/omar-dulaimi/prisma-zod-generator/ci.yml?branch=master&label=CI)](https://github.com/omar-dulaimi/prisma-zod-generator/actions)
+[![license MIT](https://img.shields.io/badge/license-MIT-0a0a0a.svg)](https://github.com/omar-dulaimi/prisma-zod-generator/blob/master/LICENSE)
+
+[Documentation](https://omar-dulaimi.github.io/prisma-zod-generator/) ·
+[PZG Pro](https://omar-dulaimi.github.io/prisma-zod-generator/pricing)
+
+## Requirements
+
+| Dependency | Supported                                         |
+| ---------- | ------------------------------------------------- |
+| Node.js    | >= 20.19.0 (22.x recommended)                     |
+| Prisma     | 7.x                                               |
+| Zod        | >= 3.25.0 < 5 (both v3 and v4 output are emitted) |
+| TypeScript | >= 5.4 (5.9.x recommended)                        |
+
+## Install
+
+```bash
+npm install --save-dev prisma-zod-generator
+npm install zod
+```
+
+Install the generator locally rather than globally: Prisma resolves the generator executable from
+`node_modules/.bin`, so a project-local install is what makes `provider = "prisma-zod-generator"` work.
+`zod` is a peer dependency (`>=3.25.0 <5`) because the generated files import it at runtime.
+
+## Usage
+
+Add the generator to `schema.prisma`:
+
+```prisma
+generator client {
+  provider = "prisma-client"
+  output   = "../src/generated/prisma"
+}
+
+generator zod {
+  provider = "prisma-zod-generator"
+  // output defaults to <schema dir>/generated
+  // config = "./zod-generator.config.json"
+}
+```
+
+Then run:
+
+```bash
+npx prisma generate
+```
+
+With no configuration you get one schema file per Prisma CRUD operation, plus the input object and enum
+schemas they reference:
+
+```
+prisma/generated/schemas/
+├── findManyUser.schema.ts     # UserFindManySchema, UserFindManyZodSchema
+├── createOneUser.schema.ts    # UserCreateOneSchema, UserCreateOneZodSchema
+├── objects/                   # UserWhereInputObjectSchema, UserCreateInputObjectSchema, ...
+├── enums/                     # SortOrderSchema, UserScalarFieldEnumSchema, ...
+├── results/                   # UserFindManyResultSchema, ...
+├── variants/                  # pure/ input/ result/ variants of each model
+└── index.ts                   # barrel re-export
+```
+
+A `helpers/` directory is emitted next to `schemas/` when the Prisma schema contains `Json` or `Decimal`
+fields, and `models/` appears under `schemas/` once `pureModels` is enabled.
+
+Every operation file exports the schema twice. `<Model><Operation>Schema` is annotated as
+`z.ZodType<Prisma.<Model><Operation>Args>`, so parsed output can be handed straight to the Prisma Client;
+`<Model><Operation>ZodSchema` is the unannotated object, for when you need `.extend()`, `.partial()` or
+`.omit()`.
+
+```ts
+import { UserFindManySchema } from './prisma/generated/schemas/findManyUser.schema';
+
+const args = UserFindManySchema.parse(req.query);
+const users = await prisma.user.findMany(args);
+```
+
+### Model schemas
+
+Set `pureModels: true` to also emit one plain schema per model, with no CRUD wrappers and no Prisma types:
+
+```ts
+// prisma/generated/schemas/models/User.schema.ts
+import * as z from 'zod';
+
+export const UserSchema = z.object({
+  id: z.number().int(),
+  email: z.string(),
+  name: z.string().nullish(),
+});
+
+export type UserType = z.infer<typeof UserSchema>;
+```
+
+### Validators declared in the Prisma schema
+
+`@zod` annotations in triple-slash comments are compiled into the generated field schemas:
+
+```prisma
+model User {
+  id    Int     @id @default(autoincrement())
+  /// @zod.email()
+  email String  @unique
+  /// @zod.min(2).max(80)
+  name  String?
+}
+```
+
+See [Zod comment annotations](https://omar-dulaimi.github.io/prisma-zod-generator/docs/pipeline/zod-comments)
+for the supported validators, custom imports, and metadata annotations.
+
+### Already using prisma-json-types-generator?
+
+PZG can read [prisma-json-types-generator](https://github.com/arthurfiorette/prisma-json-types-generator)
+(PJTG) annotations directly, so the `/// [TypeName]` and `/// ![<ts type>]` comments you already have
+start validating at runtime. No annotation changes, no schema changes:
+
+```json
+{
+  "typedJson": {
+    "schemaModule": "./json-types"
+  }
+}
+```
+
+```prisma
+model Workflow {
+  id Int @id @default(autoincrement())
+  /// [WorkflowNode]
+  nodes Json
+  /// !['draft' | 'published']
+  status String
+}
+```
+
+```ts
+// objects/WorkflowCreateInput.schema.ts
+  nodes: z.union([JsonNullValueInputSchema, WorkflowNodeSchema]),
+  status: z.enum(['draft', 'published'])
+```
+
+**This is additive, not a migration. Keep PJTG installed.** PJTG types the generated Prisma Client so
+`prisma.workflow.findFirst()` returns a typed `nodes`; PZG cannot do that and does not try. What PZG adds
+is the half PJTG leaves out: runtime validation, including on `String`/`Int`/`Float` literal unions that
+neither library checked before. Add `"emitNamespace": true` and the Zod schema becomes the single authored
+definition, with the `PrismaJson` type derived from it via `z.infer`, so the two cannot drift.
+
+Fields with no annotation are untouched, and with no `typedJson` block output is unchanged.
+See [prisma-json-types-generator interop](https://omar-dulaimi.github.io/prisma-zod-generator/docs/integrations/prisma-json-types-generator)
+for the option reference, the supported `![...]` conversions, and the limitations.
+
+## Configuration
+
+Options can be set in the generator block or in a JSON file next to `schema.prisma`.
+`zod-generator.config.json` is discovered automatically; any other path can be passed via
+`config = "./my-config.json"` (resolved relative to the schema file).
+
+```json
+{
+  "$schema": "../node_modules/prisma-zod-generator/lib/config/schema.json",
+  "mode": "full",
+  "pureModels": true,
+  "useMultipleFiles": true
+}
+```
+
+The `$schema` line gives autocomplete, hover docs, and validation in any JSON-aware editor; adjust the
+relative path to match your layout. Commonly used options: `mode` (`full` | `minimal` | `custom`), `output`,
+`useMultipleFiles` / `singleFileName`, `pureModels`, `variants`, `naming`, `optionalFieldBehavior`,
+`dateTimeStrategy`, `strictMode`, `emit`, `zodImportTarget`, `zodImportPath`. `useMultipleFiles: false`
+collapses the output into a single `schemas.ts`.
+
+- [Quick start](https://omar-dulaimi.github.io/prisma-zod-generator/docs/intro/quick-start)
+- [Configuration precedence](https://omar-dulaimi.github.io/prisma-zod-generator/docs/config/precedence)
+- [File layout and single-file mode](https://omar-dulaimi.github.io/prisma-zod-generator/docs/config/file-layout)
+- [JSON Schema IntelliSense](https://omar-dulaimi.github.io/prisma-zod-generator/docs/config/schema-json)
+- [Troubleshooting](https://omar-dulaimi.github.io/prisma-zod-generator/docs/reference/troubleshooting)
+
+The [`recipes/`](recipes) directory holds ready-made config presets (minimal CRUD, models only, single file,
+tRPC-optimized, and more); each one is a `zod-generator.config.json` with a short README explaining the
+trade-offs.
+
+## PZG Pro
+
+The generator above is MIT licensed and complete on its own. The commercial packs generate the layers
+people usually hand-write around it:
+
+- **Server Actions**: typed Next.js `'use server'` actions per model, validation already wired in.
+- **Form UX**: working forms from your schema for shadcn, MUI, Chakra, Mantine, or plain elements,
+  with react-hook-form and your Zod schemas connected.
+- **Policies & Redaction**: turn `/// @policy` and `/// @pii` comments in your schema into enforced
+  access rules and redacted logs, plus PostgreSQL row-level security.
+- **Drift Guard**: a CI command that compares two git refs and fails the build on a breaking schema
+  change, with an allow-list for the ones you accept.
+- **SDK Publisher**: a publishable TypeScript or Python client for your models.
+- **API Docs, Contract Testing, Data Factories, Performance, Multi-Tenant Kit**: OpenAPI plus a mock
+  server, Pact consumer and provider tests, seed factories typed to your schema, precompiled
+  generation for large schemas, and tenant isolation enforced in the client.
+
+| Pack                                                                          | Minimum plan |
+| ----------------------------------------------------------------------------- | ------------ |
+| Server Actions, Form UX                                                       | Starter      |
+| Policies & Redaction, Drift Guard, PostgreSQL RLS, SDK Publisher, Performance  | Professional |
+| API Docs, Contract Testing, Data Factories                                    | Business     |
+| Multi-Tenant Kit                                                              | Enterprise   |
+
+Pro code ships inside the published package, is unlocked with a `PZG_LICENSE_KEY`, and is invoked
+through the bundled `pzg-pro` CLI.
+[Pro features](https://omar-dulaimi.github.io/prisma-zod-generator/docs/features/overview) ·
+[Pricing](https://omar-dulaimi.github.io/prisma-zod-generator/pricing)
+
+### Buying a licence
+
+Licences are sold through GitHub Sponsors, which needs one thing spelled out: open the
+**One-time** tab, the second one, and pick a yearly **PZG Starter**, **PZG Professional**,
+**PZG Business**, or **PZG Enterprise** tier. The monthly support tiers on the first tab do **not**
+include a PZG Pro licence.
+
+<img src="website/static/img/tiers.png" alt="GitHub Sponsors One-time tab showing the PZG yearly tiers" width="320" />
+
+<https://github.com/sponsors/omar-dulaimi>
+
+## Sponsor
+
+Sponsorships fund maintenance and new feature work, separately from any Pro licence:
+<https://github.com/sponsors/omar-dulaimi>
+
+## Contributing
+
+Issues and pull requests are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for the repository layout,
+commit conventions, and test commands. Please open an issue before large refactors, and keep diffs focused.
+
+## License
+
+MIT © [Omar Dulaimi](https://github.com/omar-dulaimi). See [LICENSE](LICENSE).
+PZG Pro packs are covered by a separate commercial license ([LICENSE-PRO.md](LICENSE-PRO.md)).

package/SECURITY.md

@@ -0,0 +1,34 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please report security issues **privately** via GitHub's private vulnerability reporting:
+
+**[Report a vulnerability](https://github.com/omar-dulaimi/prisma-zod-generator/security/advisories/new)**
+
+Do not open public issues for undisclosed vulnerabilities. If private reporting is not an option for you, contact the maintainer through the email listed on their GitHub profile.
+
+Security reports are treated with the highest priority among incoming work, and you can expect an acknowledgement as soon as possible.
+
+## Supported Versions
+
+Only the latest published version of `prisma-zod-generator` receives security fixes.
+
+## Scope
+
+Relevant reports include, for example:
+
+- Generated code that introduces vulnerabilities into consuming projects
+- Command injection or arbitrary file write during schema generation
+- Supply-chain issues affecting the published npm package or its dependencies
+
+## A Note on Supply-Chain Hygiene for Contributors
+
+This project was the target of a supply-chain campaign in which malware was injected into a contributor's pull request **without their knowledge** via an infected development machine (see the [PolinRider campaign](https://github.com/OpenSourceMalware/PolinRider)).
+
+Because of this:
+
+- Pull requests that modify configuration files (`eslint.config.*`, `*.config.mjs`, `postinstall` scripts, etc.) unrelated to their stated purpose will be **rejected and investigated**, regardless of the author's standing.
+- Before contributing, consider auditing your own machine if you have recently installed unfamiliar npm packages or worked on "take-home test" projects from unverified sources.
+
+This is not distrust of contributors — it protects contributors and users alike.

package/app/generated/browser.ts

@@ -0,0 +1,39 @@
+
+/* !!! 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 Profile
+ * 
+ */
+export type Profile = Prisma.ProfileModel
+/**
+ * Model Project
+ * 
+ */
+export type Project = Prisma.ProjectModel
+/**
+ * Model Task
+ * 
+ */
+export type Task = Prisma.TaskModel

package/app/generated/client.ts

@@ -0,0 +1,61 @@
+
+/* !!! 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 * 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 Profile
+ * 
+ */
+export type Profile = Prisma.ProfileModel
+/**
+ * Model Project
+ * 
+ */
+export type Project = Prisma.ProjectModel
+/**
+ * Model Task
+ * 
+ */
+export type Task = Prisma.TaskModel