@lssm/lib.schema 0.0.0-canary-20251207012602 → 0.0.0-canary-20251207043720

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lssm/lib.schema",
-  "version": "0.0.0-canary-20251207012602",
+  "version": "0.0.0-canary-20251207043720",
   "scripts": {
     "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
     "build": "bun build:bundle && bun build:types",
@@ -31,26 +31,29 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js",
-    "./entity": "./dist/entity/index.js",
-    "./entity/defineEntity": "./dist/entity/defineEntity.js",
-    "./entity/generator": "./dist/entity/generator.js",
-    "./entity/types": "./dist/entity/types.js",
-    "./EnumType": "./dist/EnumType.js",
-    "./FieldType": "./dist/FieldType.js",
-    "./ScalarTypeEnum": "./dist/ScalarTypeEnum.js",
-    "./SchemaModel": "./dist/SchemaModel.js",
+    ".": "./src/index.ts",
+    "./entity": "./src/entity/index.ts",
+    "./entity/defineEntity": "./src/entity/defineEntity.ts",
+    "./entity/generator": "./src/entity/generator.ts",
+    "./entity/types": "./src/entity/types.ts",
+    "./EnumType": "./src/EnumType.ts",
+    "./FieldType": "./src/FieldType.ts",
+    "./ScalarTypeEnum": "./src/ScalarTypeEnum.ts",
+    "./SchemaModel": "./src/SchemaModel.ts",
     "./*": "./*"
   },
   "publishConfig": {
     "access": "public",
     "exports": {
       ".": "./dist/index.js",
+      "./entity": "./dist/entity/index.js",
+      "./entity/defineEntity": "./dist/entity/defineEntity.js",
+      "./entity/generator": "./dist/entity/generator.js",
+      "./entity/types": "./dist/entity/types.js",
       "./EnumType": "./dist/EnumType.js",
       "./FieldType": "./dist/FieldType.js",
       "./ScalarTypeEnum": "./dist/ScalarTypeEnum.js",
       "./SchemaModel": "./dist/SchemaModel.js",
-      "./entity": "./dist/entity/index.js",
       "./*": "./*"
     }
   }

package/dist/EnumType.d.ts

@@ -1,41 +0,0 @@
-import { z } from "zod";
-import { GraphQLEnumType } from "graphql";
-
-//#region src/EnumType.d.ts
-
-/**
- * Strongly-typed string enum wrapper with one source of truth for zod, GraphQL, and JSON Schema.
- */
-declare class EnumType<T extends [string, ...string[]]> {
-  private readonly name;
-  private readonly values;
-  private readonly gqlEnum;
-  constructor(name: string, values: T);
-  /** Enum type name (used by GraphQL and JSON Schema). */
-  getName(): string;
-  /** Returns the literal tuple of allowed values. */
-  getEnumValues(): T;
-  /** GraphQL enum instance suitable for Pothos or vanilla GraphQL schemas. */
-  getPothos(): GraphQLEnumType;
-  /** zod schema representing this enum. */
-  getZod(): z.ZodEnum<{ [K in T[number]]: K }>;
-  /** Minimal JSON representation (alias of getJsonSchema). */
-  getJson(): {
-    type: 'string';
-    enum: T;
-  };
-  /** JSON Schema for this enum. */
-  getJsonSchema(): {
-    type: 'string';
-    enum: T;
-  };
-}
-type AnyEnumType = EnumType<[string, ...string[]]>;
-/**
- * Helper to define an EnumType.
- * @param name Display/type name used across GraphQL and JSON Schema
- * @param values Literal tuple of allowed string values (at least one)
- */
-declare const defineEnum: <T extends [string, ...string[]]>(name: string, values: T) => EnumType<T>;
-//#endregion
-export { AnyEnumType, EnumType, defineEnum };

package/dist/FieldType.d.ts

@@ -1,30 +0,0 @@
-import { z } from "zod";
-import { GraphQLScalarType, GraphQLScalarTypeConfig } from "graphql";
-
-//#region src/FieldType.d.ts
-interface FieldTypeConfig<TInternal, TExternal = TInternal> extends GraphQLScalarTypeConfig<TInternal, TExternal> {
-  zod: z.ZodType<TInternal>;
-  jsonSchema: unknown | (() => unknown);
-}
-type AnyFieldType = FieldType<any, any>;
-/**
- * GraphQL scalar wrapper that carries zod and JSON Schema metadata.
- *
- * TInternal is the runtime representation; TExternal is the GraphQL output.
- */
-declare class FieldType<TInternal, TExternal = TInternal> extends GraphQLScalarType<TInternal, TExternal> {
-  private zodSchema;
-  private readonly jsonSchemaDef?;
-  constructor(config: FieldTypeConfig<TInternal, TExternal>);
-  /** Return the attached zod schema for validation. */
-  getZod(): z.ZodType<TInternal>;
-  /** GraphQL scalar instance usable by Pothos or vanilla GraphQL. */
-  getPothos(): GraphQLScalarType<TInternal, TExternal>;
-  /** Return the JSON Schema (evaluates factory if provided). */
-  getJson(): unknown;
-  getJsonSchemaDef(): unknown | (() => unknown);
-  getJsonSchema(): unknown;
-}
-type ZodFieldType<Field extends AnyFieldType> = z.infer<ReturnType<Field['getZod']>>;
-//#endregion
-export { AnyFieldType, FieldType, FieldTypeConfig, ZodFieldType };

package/dist/ScalarTypeEnum.d.ts

@@ -1,32 +0,0 @@
-import { FieldType } from "./FieldType.js";
-
-//#region src/ScalarTypeEnum.d.ts
-
-/**
- * Factory functions for common scalar FieldTypes with zod/GraphQL/JSON Schema.
- */
-declare const ScalarTypeEnum: {
-  readonly String_unsecure: () => FieldType<string>;
-  readonly Int_unsecure: () => FieldType<number>;
-  readonly Float_unsecure: () => FieldType<number>;
-  readonly Boolean: () => FieldType<boolean>;
-  readonly ID: () => FieldType<string>;
-  readonly JSON: () => FieldType<unknown>;
-  readonly JSONObject: () => FieldType<Record<string, unknown>>;
-  readonly Date: () => FieldType<Date, string>;
-  readonly DateTime: () => FieldType<Date, string>;
-  readonly Time: () => FieldType<string>;
-  readonly EmailAddress: () => FieldType<string>;
-  readonly URL: () => FieldType<string>;
-  readonly PhoneNumber: () => FieldType<string>;
-  readonly NonEmptyString: () => FieldType<string>;
-  readonly Locale: () => FieldType<string>;
-  readonly TimeZone: () => FieldType<string>;
-  readonly Latitude: () => FieldType<number>;
-  readonly Longitude: () => FieldType<number>;
-  readonly Currency: () => FieldType<string>;
-  readonly CountryCode: () => FieldType<string>;
-};
-type ScalarTypeEnum = [keyof typeof ScalarTypeEnum];
-//#endregion
-export { ScalarTypeEnum };

package/dist/SchemaModel.d.ts

@@ -1,61 +0,0 @@
-import { AnyEnumType } from "./EnumType.js";
-import { AnyFieldType } from "./FieldType.js";
-import { z } from "zod";
-import { Maybe } from "graphql/jsutils/Maybe";
-
-//#region src/SchemaModel.d.ts
-type FieldLike = AnyFieldType | AnyEnumType | AnySchemaModel;
-/** Field configuration for a SchemaModel property. */
-interface SchemaFieldConfig<Type extends FieldLike = FieldLike> {
-  type: Type;
-  isOptional: boolean;
-  /** When present and true, the field is an array */
-  isArray?: true;
-}
-type SchemaModelFieldsAnyConfig<Type extends FieldLike = FieldLike> = Record<string, SchemaFieldConfig<Type>>;
-/** Model definition: name and fields. */
-interface SchemaModelConfig<Fields extends SchemaModelFieldsAnyConfig> {
-  name: string;
-  description?: Maybe<string>;
-  fields: Fields;
-}
-/**
- * Named object model built from FieldType/EnumType/SchemaModel fields.
- * Provides zod and GraphQL input helpers, and supports arrays/optional fields.
- */
-declare class SchemaModel<Fields extends SchemaModelFieldsAnyConfig> {
-  readonly config: SchemaModelConfig<Fields>;
-  constructor(config: SchemaModelConfig<Fields>);
-  /**
-   * Build a typed ZodObject from the model fields, preserving each field's
-   * Zod schema and optionality at the type level when possible.
-   */
-  getZod(): TopLevelZodFromModel<Fields>;
-  /** Input object name for GraphQL builder adapters. */
-  getPothosInput(): string;
-}
-type AnySchemaModel = SchemaModel<SchemaModelFieldsAnyConfig>;
-type ZodSchemaModel<Field extends AnySchemaModel> = z.infer<ReturnType<Field['getZod']>>;
-type InferZodFromType<T> = T extends SchemaModel<any> ? z.ZodObject<any> : T extends AnyFieldType ? ReturnType<T['getZod']> : T extends AnyEnumType ? ReturnType<T['getZod']> : never;
-type MaybeArray<Z extends z.ZodType, A> = A extends true ? z.ZodArray<Z> : Z;
-type MaybeOptional<Z extends z.ZodType, O> = O extends true ? z.ZodOptional<Z> : Z;
-/**
- * Helper type: derive the Zod shape from the field config.
- * Supports nested SchemaModel and arrays, preserving optionality and list-ness.
- */
-type FieldIsArray<FC> = FC extends {
-  isArray: true;
-} ? true : false;
-type ZodShapeFromFields<F extends SchemaModelFieldsAnyConfig> = { [K in keyof F]: MaybeOptional<MaybeArray<InferZodFromType<F[K]['type']>, FieldIsArray<F[K]>>, F[K]['isOptional']> };
-/**
- * The top-level Zod schema returned by getZod():
- * either ZodObject<...> or ZodArray<ZodObject<...>> when config.isArray.
- */
-type TopLevelZodFromModel<F extends SchemaModelFieldsAnyConfig> = z.ZodObject<ZodShapeFromFields<F>>;
-/**
- * Helper to define a SchemaModel with type inference.
- * Equivalent to `new SchemaModel(config)` but with better ergonomics.
- */
-declare const defineSchemaModel: <Fields extends SchemaModelFieldsAnyConfig>(config: SchemaModelConfig<Fields>) => SchemaModel<Fields>;
-//#endregion
-export { AnySchemaModel, SchemaFieldConfig, SchemaModel, SchemaModelConfig, SchemaModelFieldsAnyConfig, TopLevelZodFromModel, ZodSchemaModel, ZodShapeFromFields, defineSchemaModel };

package/dist/entity/defineEntity.d.ts

@@ -1,92 +0,0 @@
-import { EntityEnumDef, EntityEnumField, EntityField, EntityIndex, EntityRelationField, EntityScalarField, EntitySpec } from "./types.js";
-
-//#region src/entity/defineEntity.d.ts
-
-/**
- * Helper to define a database entity with full type safety.
- *
- * @example
- * ```typescript
- * const UserEntity = defineEntity({
- *   name: 'User',
- *   schema: 'lssm_sigil',
- *   description: 'A user of the platform.',
- *   fields: {
- *     id: field.id(),
- *     email: field.string({ isUnique: true, zod: z.string().email() }),
- *     name: field.string({ isOptional: true }),
- *     createdAt: field.createdAt(),
- *     updatedAt: field.updatedAt(),
- *     memberships: field.hasMany('Member'),
- *   },
- *   indexes: [{ fields: ['email'], unique: true }],
- * });
- * ```
- */
-declare function defineEntity<TFields extends Record<string, EntityField>>(spec: EntitySpec<TFields>): EntitySpec<TFields>;
-/**
- * Helper to define an enum that can be shared across entities.
- */
-declare function defineEntityEnum(def: EntityEnumDef): EntityEnumDef;
-/**
- * Field builder helpers for common field patterns.
- */
-declare const field: {
-  /** String field */
-  string(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** Integer field */
-  int(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** Float field */
-  float(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** Boolean field */
-  boolean(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** DateTime field */
-  dateTime(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** JSON field */
-  json(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** BigInt field */
-  bigInt(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** Decimal field */
-  decimal(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** Bytes field */
-  bytes(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** Primary key field with cuid() default */
-  id(opts?: Partial<Omit<EntityScalarField, "kind" | "type" | "isId">>): EntityScalarField;
-  /** Primary key field with uuid() default */
-  uuid(opts?: Partial<Omit<EntityScalarField, "kind" | "type" | "isId">>): EntityScalarField;
-  /** Auto-increment integer primary key */
-  autoIncrement(opts?: Partial<Omit<EntityScalarField, "kind" | "type" | "isId">>): EntityScalarField;
-  /** createdAt timestamp with now() default */
-  createdAt(opts?: Partial<Omit<EntityScalarField, "kind" | "type" | "default">>): EntityScalarField;
-  /** updatedAt timestamp with @updatedAt */
-  updatedAt(opts?: Partial<Omit<EntityScalarField, "kind" | "type" | "updatedAt">>): EntityScalarField;
-  /** Email field with validation */
-  email(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** URL field with validation */
-  url(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-  /** Enum field */
-  enum(enumName: string, opts?: Partial<Omit<EntityEnumField, "kind" | "enumName">>): EntityEnumField;
-  /** Inline enum field with values */
-  inlineEnum(enumName: string, values: readonly string[], opts?: Partial<Omit<EntityEnumField, "kind" | "enumName" | "values">>): EntityEnumField;
-  /** Has one relation (1:1 inverse side) */
-  hasOne(target: string, opts?: Partial<Omit<EntityRelationField, "kind" | "type" | "target">>): EntityRelationField;
-  /** Has many relation (1:N inverse side) */
-  hasMany(target: string, opts?: Partial<Omit<EntityRelationField, "kind" | "type" | "target">>): EntityRelationField;
-  /** Belongs to relation (N:1 owning side with foreign key) */
-  belongsTo(target: string, fields: string[], references: string[], opts?: Partial<Omit<EntityRelationField, "kind" | "type" | "target" | "fields" | "references">>): EntityRelationField;
-  /** Foreign key field (string) - use with belongsTo */
-  foreignKey(opts?: Partial<Omit<EntityScalarField, "kind" | "type">>): EntityScalarField;
-};
-/**
- * Index builder helpers.
- */
-declare const index: {
-  /** Create a regular index */
-  on(fields: string[], opts?: Partial<Omit<EntityIndex, "fields">>): EntityIndex;
-  /** Create a unique constraint index */
-  unique(fields: string[], opts?: Partial<Omit<EntityIndex, "fields" | "unique">>): EntityIndex;
-  /** Create a compound index with sort orders */
-  compound(fields: string[], sort: Record<string, "Asc" | "Desc">, opts?: Partial<Omit<EntityIndex, "fields" | "sort">>): EntityIndex;
-};
-//#endregion
-export { defineEntity, defineEntityEnum, field, index };

package/dist/entity/generator.d.ts

@@ -1,37 +0,0 @@
-import { EntityEnumDef, EntitySpec, ModuleSchemaContribution } from "./types.js";
-
-//#region src/entity/generator.d.ts
-
-/**
- * Options for Prisma schema generation.
- */
-interface PrismaGeneratorOptions {
-  /** Output file path for the generated schema */
-  outputPath?: string;
-  /** Prisma datasource provider (default: 'postgresql') */
-  provider?: 'postgresql' | 'mysql' | 'sqlite' | 'mongodb' | 'sqlserver';
-  /** Prisma generator output path */
-  clientOutput?: string;
-  /** Include Pothos generator */
-  includePothos?: boolean;
-  /** Pothos output path */
-  pothosOutput?: string;
-}
-/**
- * Generate Prisma schema content from entity specifications.
- */
-declare function generatePrismaSchema(entities: EntitySpec[], options?: PrismaGeneratorOptions): string;
-/**
- * Compose multiple module schema contributions into a single schema.
- */
-declare function composeModuleSchemas(contributions: ModuleSchemaContribution[], options?: PrismaGeneratorOptions): string;
-/**
- * Generate a single entity's Prisma schema fragment (for modular output).
- */
-declare function generateEntityFragment(entity: EntitySpec): string;
-/**
- * Generate a single enum's Prisma schema fragment (for modular output).
- */
-declare function generateEnumFragment(enumDef: EntityEnumDef): string;
-//#endregion
-export { PrismaGeneratorOptions, composeModuleSchemas, generateEntityFragment, generateEnumFragment, generatePrismaSchema };

package/dist/entity/index.d.ts

@@ -1,4 +0,0 @@
-import { EntityEnumDef, EntityEnumField, EntityField, EntityIndex, EntityRelationField, EntityScalarField, EntitySpec, ModuleSchemaContribution, PrismaFieldModifiers, PrismaScalarType, RelationType } from "./types.js";
-import { defineEntity, defineEntityEnum, field, index } from "./defineEntity.js";
-import { PrismaGeneratorOptions, composeModuleSchemas, generateEntityFragment, generateEnumFragment, generatePrismaSchema } from "./generator.js";
-export { EntityEnumDef, EntityEnumField, EntityField, EntityIndex, EntityRelationField, EntityScalarField, EntitySpec, ModuleSchemaContribution, PrismaFieldModifiers, PrismaGeneratorOptions, PrismaScalarType, RelationType, composeModuleSchemas, defineEntity, defineEntityEnum, field, generateEntityFragment, generateEnumFragment, generatePrismaSchema, index };

package/dist/entity/types.d.ts

@@ -1,145 +0,0 @@
-import { z } from "zod";
-
-//#region src/entity/types.d.ts
-
-/**
- * Prisma scalar types that can be used in entity field definitions.
- */
-type PrismaScalarType = 'String' | 'Int' | 'Float' | 'Boolean' | 'DateTime' | 'Json' | 'BigInt' | 'Decimal' | 'Bytes';
-/**
- * Prisma field modifiers.
- */
-interface PrismaFieldModifiers {
-  /** Field is optional (nullable) */
-  isOptional?: boolean;
-  /** Field is an array */
-  isArray?: boolean;
-  /** Field is unique */
-  isUnique?: boolean;
-  /** Field is the primary key (use @id) */
-  isId?: boolean;
-  /** Default value expression (e.g., 'cuid()', 'now()', 'autoincrement()') */
-  default?: string | number | boolean;
-  /** Field is auto-updated on record update (e.g., @updatedAt) */
-  updatedAt?: boolean;
-  /** Database column name override */
-  map?: string;
-  /** Database column type override */
-  dbType?: string;
-}
-/**
- * Scalar field definition for an entity.
- */
-interface EntityScalarField extends PrismaFieldModifiers {
-  kind: 'scalar';
-  type: PrismaScalarType;
-  /** Zod schema for validation */
-  zod?: z.ZodType;
-  /** Human-readable description (becomes Prisma /// comment) */
-  description?: string;
-}
-/**
- * Enum field definition for an entity.
- */
-interface EntityEnumField extends PrismaFieldModifiers {
-  kind: 'enum';
-  /** Name of the enum type */
-  enumName: string;
-  /** Enum values (for inline enum definition) */
-  values?: readonly string[];
-  /** Zod schema for validation */
-  zod?: z.ZodType;
-  /** Human-readable description */
-  description?: string;
-}
-/**
- * Relation types supported by Prisma.
- */
-type RelationType = 'hasOne' | 'hasMany' | 'belongsTo';
-/**
- * Relation field definition for an entity.
- */
-interface EntityRelationField {
-  kind: 'relation';
-  type: RelationType;
-  /** Target entity name */
-  target: string;
-  /** Foreign key field(s) on this model (for belongsTo) */
-  fields?: string[];
-  /** Referenced field(s) on the target model */
-  references?: string[];
-  /** Relation name for disambiguation */
-  name?: string;
-  /** On delete action */
-  onDelete?: 'Cascade' | 'SetNull' | 'Restrict' | 'NoAction' | 'SetDefault';
-  /** On update action */
-  onUpdate?: 'Cascade' | 'SetNull' | 'Restrict' | 'NoAction' | 'SetDefault';
-  /** Human-readable description */
-  description?: string;
-}
-/**
- * Union of all entity field types.
- */
-type EntityField = EntityScalarField | EntityEnumField | EntityRelationField;
-/**
- * Index definition for an entity.
- */
-interface EntityIndex {
-  /** Fields included in the index */
-  fields: string[];
-  /** Index is unique constraint */
-  unique?: boolean;
-  /** Index name override */
-  name?: string;
-  /** Sort order per field */
-  sort?: Record<string, 'Asc' | 'Desc'>;
-  /** Index type */
-  type?: 'BTree' | 'Hash' | 'Gist' | 'Gin';
-}
-/**
- * Enum definition that can be shared across entities.
- */
-interface EntityEnumDef {
-  /** Enum name */
-  name: string;
-  /** Enum values */
-  values: readonly string[];
-  /** Postgres schema where the enum is defined */
-  schema?: string;
-  /** Human-readable description */
-  description?: string;
-}
-/**
- * Complete entity specification for database-backed models.
- */
-interface EntitySpec<TFields extends Record<string, EntityField> = Record<string, EntityField>> {
-  /** Entity/model name (PascalCase) */
-  name: string;
-  /** Human-readable description (becomes Prisma /// comment) */
-  description?: string;
-  /** Postgres schema name (default: 'public') */
-  schema?: string;
-  /** Database table name override */
-  map?: string;
-  /** Field definitions */
-  fields: TFields;
-  /** Index definitions */
-  indexes?: EntityIndex[];
-  /** Enum definitions used by this entity */
-  enums?: EntityEnumDef[];
-  /** Module/domain this entity belongs to (for schema composition) */
-  module?: string;
-}
-/**
- * Module schema contribution for composition.
- */
-interface ModuleSchemaContribution {
-  /** Module identifier (e.g., '@lssm/lib.identity-rbac') */
-  moduleId: string;
-  /** Entity specs provided by this module */
-  entities: EntitySpec[];
-  /** Shared enum definitions */
-  enums?: EntityEnumDef[];
-}
-//#endregion
-export { EntityEnumDef, EntityEnumField, EntityField, EntityIndex, EntityRelationField, EntityScalarField, EntitySpec, ModuleSchemaContribution, PrismaFieldModifiers, PrismaScalarType, RelationType };

package/dist/index.d.ts

@@ -1,9 +0,0 @@
-import { AnyEnumType, EnumType, defineEnum } from "./EnumType.js";
-import { AnyFieldType, FieldType, FieldTypeConfig, ZodFieldType } from "./FieldType.js";
-import { ScalarTypeEnum } from "./ScalarTypeEnum.js";
-import { AnySchemaModel, SchemaFieldConfig, SchemaModel, SchemaModelConfig, SchemaModelFieldsAnyConfig, TopLevelZodFromModel, ZodSchemaModel, ZodShapeFromFields, defineSchemaModel } from "./SchemaModel.js";
-import { EntityEnumDef, EntityEnumField, EntityField, EntityIndex, EntityRelationField, EntityScalarField, EntitySpec, ModuleSchemaContribution, PrismaFieldModifiers, PrismaScalarType, RelationType } from "./entity/types.js";
-import { defineEntity, defineEntityEnum, field, index } from "./entity/defineEntity.js";
-import { PrismaGeneratorOptions, composeModuleSchemas, generateEntityFragment, generateEnumFragment, generatePrismaSchema } from "./entity/generator.js";
-import "./entity/index.js";
-export { AnyEnumType, AnyFieldType, AnySchemaModel, EntityEnumDef, EntityEnumField, EntityField, EntityIndex, EntityRelationField, EntityScalarField, EntitySpec, EnumType, FieldType, FieldTypeConfig, ModuleSchemaContribution, PrismaFieldModifiers, PrismaGeneratorOptions, PrismaScalarType, RelationType, ScalarTypeEnum, SchemaFieldConfig, SchemaModel, SchemaModelConfig, SchemaModelFieldsAnyConfig, TopLevelZodFromModel, ZodFieldType, ZodSchemaModel, ZodShapeFromFields, composeModuleSchemas, defineEntity, defineEntityEnum, defineEnum, defineSchemaModel, field, generateEntityFragment, generateEnumFragment, generatePrismaSchema, index };