@pothos/plugin-prisma 3.35.1 → 3.35.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Change Log
 
+## 3.35.3
+
+### Patch Changes
+
+- 3a82d645: Apply esm transform to esm d.ts definitions
+
+## 3.35.2
+
+### Patch Changes
+
+- 218fc68b: Fix script for copying ems d.ts definitions
+
 ## 3.35.1
 
 ### Patch Changes

package/esm/field-builder.d.ts

@@ -0,0 +1,2 @@
+export * from './prisma-field-builder.js';
+//# sourceMappingURL=field-builder.d.ts.map

package/esm/generator.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generator.d.ts.map

package/esm/global-types.d.ts

@@ -0,0 +1,123 @@
+import { FieldKind, FieldNullability, FieldRef, InputFieldMap, InputFieldRef, InterfaceParam, NormalizeArgs, OutputType, PluginName, SchemaTypes, ShapeFromTypeParam, TypeParam } from '@pothos/core';
+import PrismaNodeRef from './node-ref.js';
+import { prismaModelKey, PrismaObjectRef } from './object-ref.js';
+import { PrismaObjectFieldBuilder as InternalPrismaObjectFieldBuilder } from './prisma-field-builder.js';
+import { PrismaClient, PrismaConnectionFieldOptions, PrismaFieldOptions, PrismaFieldWithInputOptions, PrismaModelTypes, PrismaNodeOptions, PrismaObjectFieldOptions, PrismaObjectTypeOptions, ShapeFromConnection, ShapeFromSelection } from './types.js';
+import type { PrismaPlugin } from './index.js';
+declare global {
+    export namespace PothosSchemaTypes {
+        interface Plugins<Types extends SchemaTypes> {
+            prisma: PrismaPlugin<Types>;
+        }
+        interface SchemaBuilderOptions<Types extends SchemaTypes> {
+            prisma: {
+                filterConnectionTotalCount?: boolean;
+                client: PrismaClient;
+                exposeDescriptions?: boolean | {
+                    models?: boolean;
+                    fields?: boolean;
+                };
+            } | {
+                filterConnectionTotalCount?: boolean;
+                client: (ctx: Types["Context"]) => PrismaClient;
+                dmmf: {
+                    datamodel: unknown;
+                };
+                exposeDescriptions?: boolean | {
+                    models?: boolean;
+                    fields?: boolean;
+                };
+            };
+        }
+        interface UserSchemaTypes {
+            PrismaTypes: {};
+        }
+        interface ExtendDefaultTypes<PartialTypes extends Partial<UserSchemaTypes>> {
+            PrismaTypes: PartialTypes["PrismaTypes"] & {};
+        }
+        interface PothosKindToGraphQLType {
+            PrismaObject: "Object";
+        }
+        interface FieldOptionsByKind<Types extends SchemaTypes, ParentShape, Type extends TypeParam<Types>, Nullable extends FieldNullability<Type>, Args extends InputFieldMap, ResolveShape, ResolveReturnShape> {
+            PrismaObject: PrismaObjectFieldOptions<Types, ParentShape, Type, Nullable, Args, ResolveShape, ResolveReturnShape>;
+        }
+        interface SchemaBuilder<Types extends SchemaTypes> {
+            prismaObject: <Name extends keyof Types["PrismaTypes"], Interfaces extends InterfaceParam<Types>[], FindUnique, Model extends PrismaModelTypes & Types["PrismaTypes"][Name], Include = unknown, Select = unknown>(name: Name, options: PrismaObjectTypeOptions<Types, Model, Interfaces, FindUnique, Include, Select, ShapeFromSelection<Model, {
+                select: Select;
+                include: Include;
+            }>>) => PrismaObjectRef<Model, ShapeFromSelection<Model, {
+                select: Select;
+                include: Include;
+            }>>;
+            prismaNode: "relay" extends PluginName ? <Name extends keyof Types["PrismaTypes"], Interfaces extends InterfaceParam<Types>[] = [
+            ], Include = unknown, Select = unknown, UniqueField = unknown>(name: Name, options: PrismaNodeOptions<Types, Types["PrismaTypes"][Name] & PrismaModelTypes, Interfaces, Include, Select, ShapeFromSelection<PrismaModelTypes & Types["PrismaTypes"][Name], {
+                select: Select;
+                include: Include;
+            }>, UniqueField>) => PrismaNodeRef<Types["PrismaTypes"][Name] & PrismaModelTypes, ShapeFromSelection<PrismaModelTypes & Types["PrismaTypes"][Name], {
+                select: Select;
+                include: Include;
+            }>> : "@pothos/plugin-relay is required to use this method";
+        }
+        interface RootFieldBuilder<Types extends SchemaTypes, ParentShape, Kind extends FieldKind = FieldKind> {
+            prismaField: <Args extends InputFieldMap, TypeParam extends PrismaObjectRef<PrismaModelTypes> | keyof Types["PrismaTypes"] | [
+                keyof Types["PrismaTypes"]
+            ] | [
+                PrismaObjectRef<PrismaModelTypes>
+            ], Nullable extends FieldNullability<Type>, ResolveShape, ResolveReturnShape, Type extends TypeParam extends [
+                unknown
+            ] ? [
+                ObjectRef<Model["Shape"]>
+            ] : ObjectRef<Model["Shape"]>, Model extends PrismaModelTypes = PrismaModelTypes & (TypeParam extends [
+                keyof Types["PrismaTypes"]
+            ] ? Types["PrismaTypes"][TypeParam[0]] : TypeParam extends [
+                PrismaObjectRef<PrismaModelTypes>
+            ] ? TypeParam[0][typeof prismaModelKey] : TypeParam extends PrismaObjectRef<PrismaModelTypes> ? TypeParam[typeof prismaModelKey] : TypeParam extends keyof Types["PrismaTypes"] ? Types["PrismaTypes"][TypeParam] : never)>(options: PrismaFieldOptions<Types, ParentShape, TypeParam, Model, Type, Args, Nullable, ResolveShape, ResolveReturnShape, Kind>) => FieldRef<ShapeFromTypeParam<Types, Type, Nullable>>;
+            prismaConnection: "relay" extends PluginName ? <Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types["PrismaTypes"], Nullable extends boolean, ResolveReturnShape, Args extends InputFieldMap = {}, Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer T> ? T : PrismaModelTypes & Types["PrismaTypes"][Type & keyof Types["PrismaTypes"]]>(options: PrismaConnectionFieldOptions<Types, ParentShape, Type, Model, ObjectRef<Model["Shape"]>, Nullable, Args, ResolveReturnShape, Kind>, ...args: NormalizeArgs<[
+                connectionOptions: ConnectionObjectOptions<Types, ObjectRef<Model["Shape"]>, false, false, ResolveReturnShape>,
+                edgeOptions: ConnectionEdgeObjectOptions<Types, ObjectRef<Model["Shape"]>, false, ResolveReturnShape>
+            ], 0>) => FieldRef<ShapeFromConnection<ConnectionShapeHelper<Types, Model["Shape"], Nullable>>> : "@pothos/plugin-relay is required to use this method";
+            prismaFieldWithInput: "prisma" extends PluginName ? <Fields extends Record<string, InputFieldRef<unknown, "InputObject">>, TypeParam extends PrismaObjectRef<PrismaModelTypes> | keyof Types["PrismaTypes"] | [
+                keyof Types["PrismaTypes"]
+            ] | [
+                PrismaObjectRef<PrismaModelTypes>
+            ], Type extends TypeParam extends [
+                unknown
+            ] ? [
+                ObjectRef<Model["Shape"]>
+            ] : ObjectRef<Model["Shape"]>, ResolveShape, ResolveReturnShape, ArgRequired extends boolean, Args extends Record<string, InputFieldRef<unknown, "Arg">> = {}, Nullable extends FieldNullability<Type> = Types["DefaultFieldNullability"], InputName extends string = "input", Model extends PrismaModelTypes = PrismaModelTypes & (TypeParam extends [
+                keyof Types["PrismaTypes"]
+            ] ? Types["PrismaTypes"][TypeParam[0]] : TypeParam extends [
+                PrismaObjectRef<PrismaModelTypes>
+            ] ? TypeParam[0][typeof prismaModelKey] : TypeParam extends PrismaObjectRef<PrismaModelTypes> ? TypeParam[typeof prismaModelKey] : TypeParam extends keyof Types["PrismaTypes"] ? Types["PrismaTypes"][TypeParam] : never)>(options: PrismaFieldWithInputOptions<Types, ParentShape, Kind, Args, Fields, TypeParam, Model, Type, Nullable, InputName, ResolveShape, ResolveReturnShape, boolean extends ArgRequired ? (Types & {
+                WithInputArgRequired: boolean;
+            })["WithInputArgRequired"] : ArgRequired>) => FieldRef<ShapeFromTypeParam<Types, Type, Nullable>> : "@pothos/plugin-prisma is required to use this method";
+        }
+        interface ConnectionFieldOptions<Types extends SchemaTypes, ParentShape, Type extends OutputType<Types>, Nullable extends boolean, EdgeNullability extends FieldNullability<[
+            unknown
+        ]>, NodeNullability extends boolean, Args extends InputFieldMap, ResolveReturnShape> {
+        }
+        interface ConnectionObjectOptions<Types extends SchemaTypes, Type extends OutputType<Types>, EdgeNullability extends FieldNullability<[
+            unknown
+        ]>, NodeNullability extends boolean, Resolved> {
+        }
+        interface ConnectionEdgeObjectOptions<Types extends SchemaTypes, Type extends OutputType<Types>, NodeNullability extends boolean, Resolved> {
+        }
+        interface DefaultConnectionArguments {
+            first?: number | null | undefined;
+            last?: number | null | undefined;
+            before?: string | null | undefined;
+            after?: string | null | undefined;
+        }
+        interface ConnectionShapeHelper<Types extends SchemaTypes, T, Nullable> {
+        }
+        interface ScopeAuthFieldAuthScopes<Types extends SchemaTypes, Parent, Args extends {} = {}> {
+        }
+        interface ScopeAuthContextForAuth<Types extends SchemaTypes, Scopes extends {}> {
+        }
+        interface PrismaObjectFieldBuilder<Types extends SchemaTypes, Model extends PrismaModelTypes, NeedsResolve extends boolean, Shape extends object = Model["Shape"]> extends InternalPrismaObjectFieldBuilder<Types, Model, NeedsResolve, Shape>, RootFieldBuilder<Types, Shape, "PrismaObject"> {
+        }
+        interface FieldWithInputBaseOptions<Types extends SchemaTypes, Args extends Record<string, InputFieldRef<unknown, "Arg">>, Fields extends Record<string, InputFieldRef<unknown, "InputObject">>, InputName extends string, ArgRequired extends boolean> {
+        }
+    }
+}
+//# sourceMappingURL=global-types.d.ts.map

package/esm/{dts/index.d.ts → index.d.ts}

@@ -1,10 +1,10 @@
-import './global-types';
-import './schema-builder';
+import './global-types.js';
+import './schema-builder.js';
 import { GraphQLFieldResolver } from 'graphql';
 import SchemaBuilder, { BasePlugin, BuildCache, PothosOutputFieldConfig, SchemaTypes } from '@pothos/core';
-import { PrismaModelTypes } from './types';
-import { queryFromInfo } from './util/map-query';
-export * from './types';
+import { PrismaModelTypes } from './types.js';
+import { queryFromInfo } from './util/map-query.js';
+export * from './types.js';
 declare const pluginName: "prisma";
 export default pluginName;
 export { queryFromInfo };
@@ -13,6 +13,6 @@ export declare const ObjectFieldBuilder: new <Types extends SchemaTypes, Model e
 export declare class PrismaPlugin<Types extends SchemaTypes> extends BasePlugin<Types> {
     constructor(cache: BuildCache<Types>);
     onOutputFieldConfig(fieldConfig: PothosOutputFieldConfig<Types>): PothosOutputFieldConfig<Types> | null;
-    wrapResolve(resolver: GraphQLFieldResolver<unknown, Types['Context'], object, unknown>, fieldConfig: PothosOutputFieldConfig<Types>): GraphQLFieldResolver<unknown, Types['Context'], object>;
+    wrapResolve(resolver: GraphQLFieldResolver<unknown, Types["Context"], object, unknown>, fieldConfig: PothosOutputFieldConfig<Types>): GraphQLFieldResolver<unknown, Types["Context"], object>;
 }
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/esm/{dts/model-loader.d.ts → model-loader.d.ts}

@@ -1,5 +1,5 @@
 import { ObjectRef, SchemaTypes } from '@pothos/core';
-import { SelectionState } from './util/selections';
+import { SelectionState } from './util/selections.js';
 export declare class ModelLoader {
     model: object;
     builder: PothosSchemaTypes.SchemaBuilder<never>;
@@ -10,7 +10,8 @@ export declare class ModelLoader {
         state: SelectionState;
     }>;
     constructor(model: object, builder: PothosSchemaTypes.SchemaBuilder<never>, modelName: string, findUnique: (model: Record<string, unknown>, ctx: {}) => unknown);
-    static forRef<Types extends SchemaTypes>(ref: ObjectRef<unknown>, modelName: string, findUnique: ((model: Record<string, unknown>, ctx: {}) => unknown) | undefined, builder: PothosSchemaTypes.SchemaBuilder<Types>): import("@pothos/core").ContextCache<ModelLoader, object, []>;
+    static forRef<Types extends SchemaTypes>(ref: ObjectRef<unknown>, modelName: string, findUnique: ((model: Record<string, unknown>, ctx: {}) => unknown) | undefined, builder: PothosSchemaTypes.SchemaBuilder<Types>): import("@pothos/core").ContextCache<ModelLoader, object, [
+    ]>;
     static getFindUnique(findBy: {
         name: string | null;
         fields: string[];
@@ -26,4 +27,4 @@ export declare class ModelLoader {
     loadSelection(selection: SelectionState, context: object): Promise<Record<string, unknown>>;
     initLoad(state: SelectionState, context: {}): Promise<Record<string, unknown>>;
 }
-//# sourceMappingURL=model-loader.d.ts.map
+//# sourceMappingURL=model-loader.d.ts.map

package/esm/node-ref.d.ts

@@ -0,0 +1,5 @@
+import { PrismaObjectRef } from './object-ref.js';
+import type { PrismaModelTypes } from './types.js';
+export default class PrismaNodeRef<Model extends PrismaModelTypes, T> extends PrismaObjectRef<Model, T> {
+}
+//# sourceMappingURL=node-ref.d.ts.map

package/esm/{dts/object-ref.d.ts → object-ref.d.ts}

@@ -1,5 +1,5 @@
 import { abstractReturnShapeKey, ObjectRef } from '@pothos/core';
-import type { PrismaModelTypes, WithBrand } from './types';
+import type { PrismaModelTypes, WithBrand } from './types.js';
 export declare const prismaModelKey: unique symbol;
 export declare class PrismaObjectRef<Model extends PrismaModelTypes, T = {}> extends ObjectRef<T> {
     [prismaModelKey]: Model;
@@ -9,4 +9,4 @@ export declare class PrismaObjectRef<Model extends PrismaModelTypes, T = {}> ext
     } : WithBrand<V>;
     hasBrand(value: unknown): boolean;
 }
-//# sourceMappingURL=object-ref.d.ts.map
+//# sourceMappingURL=object-ref.d.ts.map

package/esm/{dts/prisma-field-builder.d.ts → prisma-field-builder.d.ts}

@@ -1,7 +1,7 @@
 import { CompatibleTypes, FieldKind, FieldRef, InputFieldMap, NormalizeArgs, ObjectRef, PluginName, SchemaTypes, ShapeFromTypeParam, TypeParam } from '@pothos/core';
-import { PrismaObjectRef } from './object-ref';
-import { PrismaModelTypes, RelatedConnectionOptions, RelatedFieldOptions, RelationCountOptions, ShapeFromConnection, VariantFieldOptions } from './types';
-import { FieldMap } from './util/relation-map';
+import { PrismaObjectRef } from './object-ref.js';
+import { PrismaModelTypes, RelatedConnectionOptions, RelatedFieldOptions, RelationCountOptions, ShapeFromConnection, VariantFieldOptions } from './types.js';
+import { FieldMap } from './util/relation-map.js';
 declare const RootBuilder: {
     new <Types extends SchemaTypes, Shape, Kind extends FieldKind>(name: string, builder: PothosSchemaTypes.SchemaBuilder<Types>, kind: FieldKind, graphqlKind: PothosSchemaTypes.PothosKindToGraphQLType[FieldKind]): PothosSchemaTypes.RootFieldBuilder<Types, Shape, Kind>;
 };
@@ -11,7 +11,7 @@ declare type ContextForAuth<Types extends SchemaTypes, Scopes extends {} = {}> =
 declare type FieldAuthScopes<Types extends SchemaTypes, Parent, Args extends {} = {}> = PothosSchemaTypes.ScopeAuthFieldAuthScopes<Types, Parent, Args> extends {
     Scopes: infer T;
 } ? T : never;
-export declare class PrismaObjectFieldBuilder<Types extends SchemaTypes, Model extends PrismaModelTypes, NeedsResolve extends boolean, Shape extends object = Model['Shape']> extends RootBuilder<Types, Shape, 'PrismaObject'> {
+export declare class PrismaObjectFieldBuilder<Types extends SchemaTypes, Model extends PrismaModelTypes, NeedsResolve extends boolean, Shape extends object = Model["Shape"]> extends RootBuilder<Types, Shape, "PrismaObject"> {
     model: string;
     prismaFieldMap: FieldMap;
     exposeBoolean: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], "Boolean", Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, "Boolean", Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
@@ -29,43 +29,73 @@ export declare class PrismaObjectFieldBuilder<Types extends SchemaTypes, Model e
     exposeString: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], "String", Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, "String", Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
         description?: string | false | undefined;
     }) | undefined) => FieldRef<import("@pothos/core").FieldNullability<"String"> extends Nullable ? Types["DefaultFieldNullability"] extends true ? ("String" extends infer T ? T extends "String" ? T extends keyof Types["outputShapes"] ? Types["outputShapes"][T] : T extends import("@pothos/core").BaseEnum ? import("@pothos/core").ValuesFromEnum<T> : never : never : never) | null | undefined : "String" extends infer T ? T extends "String" ? T extends keyof Types["outputShapes"] ? Types["outputShapes"][T] : T extends import("@pothos/core").BaseEnum ? import("@pothos/core").ValuesFromEnum<T> : never : never : never : Nullable extends true ? ("String" extends infer T ? T extends "String" ? T extends keyof Types["outputShapes"] ? Types["outputShapes"][T] : T extends import("@pothos/core").BaseEnum ? import("@pothos/core").ValuesFromEnum<T> : never : never : never) | null | undefined : "String" extends infer T ? T extends "String" ? T extends keyof Types["outputShapes"] ? Types["outputShapes"][T] : T extends import("@pothos/core").BaseEnum ? import("@pothos/core").ValuesFromEnum<T> : never : never : never, "PrismaObject">;
-    exposeBooleanList: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], ["Boolean"], Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, ["Boolean"], Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
+    exposeBooleanList: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], [
+        "Boolean"
+    ], Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, [
+        "Boolean"
+    ], Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
         description?: string | false | undefined;
-    }) | undefined) => FieldRef<ShapeFromTypeParam<Types, ["Boolean"], Nullable>, "PrismaObject">;
-    exposeFloatList: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], ["Float"], Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, ["Float"], Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
+    }) | undefined) => FieldRef<ShapeFromTypeParam<Types, [
+        "Boolean"
+    ], Nullable>, "PrismaObject">;
+    exposeFloatList: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], [
+        "Float"
+    ], Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, [
+        "Float"
+    ], Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
         description?: string | false | undefined;
-    }) | undefined) => FieldRef<ShapeFromTypeParam<Types, ["Float"], Nullable>, "PrismaObject">;
-    exposeIntList: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], ["Int"], Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, ["Int"], Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
+    }) | undefined) => FieldRef<ShapeFromTypeParam<Types, [
+        "Float"
+    ], Nullable>, "PrismaObject">;
+    exposeIntList: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], [
+        "Int"
+    ], Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, [
+        "Int"
+    ], Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
         description?: string | false | undefined;
-    }) | undefined) => FieldRef<ShapeFromTypeParam<Types, ["Int"], Nullable>, "PrismaObject">;
-    exposeIDList: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], ["ID"], Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, ["ID"], Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
+    }) | undefined) => FieldRef<ShapeFromTypeParam<Types, [
+        "Int"
+    ], Nullable>, "PrismaObject">;
+    exposeIDList: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], [
+        "ID"
+    ], Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, [
+        "ID"
+    ], Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
         description?: string | false | undefined;
-    }) | undefined) => FieldRef<ShapeFromTypeParam<Types, ["ID"], Nullable>, "PrismaObject">;
-    exposeStringList: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], ["String"], Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, ["String"], Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
+    }) | undefined) => FieldRef<ShapeFromTypeParam<Types, [
+        "ID"
+    ], Nullable>, "PrismaObject">;
+    exposeStringList: <Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], [
+        "String"
+    ], Nullable>>(name?: Name | undefined, options?: (Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, [
+        "String"
+    ], Nullable, {}, ResolveReturnShape>, "type" | "description" | "resolve" | "select"> & {
         description?: string | false | undefined;
-    }) | undefined) => FieldRef<ShapeFromTypeParam<Types, ["String"], Nullable>, "PrismaObject">;
-    withAuth: 'scopeAuth' extends PluginName ? <Scopes extends FieldAuthScopes<Types, Shape, Record<string, unknown>>>(scopes: Scopes) => PothosSchemaTypes.PrismaObjectFieldBuilder<Omit<Types, 'Context'> & {
+    }) | undefined) => FieldRef<ShapeFromTypeParam<Types, [
+        "String"
+    ], Nullable>, "PrismaObject">;
+    withAuth: "scopeAuth" extends PluginName ? <Scopes extends FieldAuthScopes<Types, Shape, Record<string, unknown>>>(scopes: Scopes) => PothosSchemaTypes.PrismaObjectFieldBuilder<Omit<Types, "Context"> & {
         Context: ContextForAuth<Types, Scopes>;
-    }, Model, NeedsResolve, Shape> : '@pothos/plugin-scope-auth is required to use this method';
-    relatedConnection: 'relay' extends PluginName ? <Field extends Model['ListRelations'], Nullable extends boolean, Args extends InputFieldMap, ResolveReturnShape>(field: Field, options: RelatedConnectionOptions<Types, Model, Field, Nullable, Args, NeedsResolve>, ...args: NormalizeArgs<[
+    }, Model, NeedsResolve, Shape> : "@pothos/plugin-scope-auth is required to use this method";
+    relatedConnection: "relay" extends PluginName ? <Field extends Model["ListRelations"], Nullable extends boolean, Args extends InputFieldMap, ResolveReturnShape>(field: Field, options: RelatedConnectionOptions<Types, Model, Field, Nullable, Args, NeedsResolve>, ...args: NormalizeArgs<[
         connectionOptions: PothosSchemaTypes.ConnectionObjectOptions<Types, ObjectRef<Shape>, false, false, ResolveReturnShape>,
         edgeOptions: PothosSchemaTypes.ConnectionEdgeObjectOptions<Types, ObjectRef<Shape>, false, ResolveReturnShape>
-    ], 0>) => FieldRef<ShapeFromConnection<PothosSchemaTypes.ConnectionShapeHelper<Types, Shape, Nullable>>> : '@pothos/plugin-relay is required to use this method';
+    ], 0>) => FieldRef<ShapeFromConnection<PothosSchemaTypes.ConnectionShapeHelper<Types, Shape, Nullable>>> : "@pothos/plugin-relay is required to use this method";
     constructor(name: string, builder: PothosSchemaTypes.SchemaBuilder<Types>, model: string, fieldMap: FieldMap);
-    relation<Field extends Model['RelationName'], Nullable extends boolean, Args extends InputFieldMap, ResolveReturnShape>(name: Field, ...allArgs: NormalizeArgs<[
+    relation<Field extends Model["RelationName"], Nullable extends boolean, Args extends InputFieldMap, ResolveReturnShape>(name: Field, ...allArgs: NormalizeArgs<[
         options: RelatedFieldOptions<Types, Model, Field, Nullable, Args, ResolveReturnShape, NeedsResolve, Shape>
-    ]>): FieldRef<Model['Relations'][Field]['Shape'], 'Object'>;
-    relationCount<Field extends Model['RelationName']>(name: Field, ...allArgs: NormalizeArgs<[
-        options: RelationCountOptions<Types, Shape, NeedsResolve, Model['Relations'][Field]['Types']['Where']>
-    ]>): FieldRef<number, 'Object'>;
-    variant<Variant extends Model['Name'] | PrismaObjectRef<Model>, Args extends InputFieldMap, Nullable>(variant: Variant, ...allArgs: NormalizeArgs<[
+    ]>): FieldRef<Model["Relations"][Field]["Shape"], "Object">;
+    relationCount<Field extends Model["RelationName"]>(name: Field, ...allArgs: NormalizeArgs<[
+        options: RelationCountOptions<Types, Shape, NeedsResolve, Model["Relations"][Field]["Types"]["Where"]>
+    ]>): FieldRef<number, "Object">;
+    variant<Variant extends Model["Name"] | PrismaObjectRef<Model>, Args extends InputFieldMap, Nullable>(variant: Variant, ...allArgs: NormalizeArgs<[
         options: VariantFieldOptions<Types, Model, Variant extends PrismaObjectRef<Model> ? Variant : PrismaObjectRef<Model>, Args, Nullable, Shape>
-    ]>): FieldRef<Model['Shape'], 'Object'>;
-    expose<Type extends TypeParam<Types>, Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model['Shape'], Type, Nullable>>(...args: NormalizeArgs<[
+    ]>): FieldRef<Model["Shape"], "Object">;
+    expose<Type extends TypeParam<Types>, Nullable extends boolean, ResolveReturnShape, Name extends CompatibleTypes<Types, Model["Shape"], Type, Nullable>>(...args: NormalizeArgs<[
         name: Name,
-        options: Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, Type, Nullable, {}, ResolveReturnShape>, 'resolve' | 'select'>
+        options: Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, Type, Nullable, {}, ResolveReturnShape>, "resolve" | "select">
     ]>): FieldRef<ShapeFromTypeParam<Types, Type, Nullable>, "PrismaObject">;
     private createExpose;
 }
 export {};
-//# sourceMappingURL=prisma-field-builder.d.ts.map
+//# sourceMappingURL=prisma-field-builder.d.ts.map

package/esm/schema-builder.d.ts

@@ -0,0 +1,2 @@
+import './global-types.js';
+//# sourceMappingURL=schema-builder.d.ts.map

package/esm/{dts/types.d.ts → types.d.ts}

@@ -1,7 +1,7 @@
 import { FieldNode, GraphQLResolveInfo } from 'graphql';
 import { FieldKind, FieldMap, FieldNullability, FieldOptionsFromKind, InputFieldMap, InputFieldRef, InputFieldsFromShape, InputShapeFromFields, InterfaceParam, ListResolveValue, MaybePromise, Normalize, ObjectRef, OutputShape, OutputType, SchemaTypes, ShapeFromTypeParam, ShapeWithNullability, typeBrandKey, TypeParam } from '@pothos/core';
-import type { PrismaObjectFieldBuilder } from './field-builder';
-import { PrismaObjectRef } from './object-ref';
+import type { PrismaObjectFieldBuilder } from './field-builder.js';
+import { PrismaObjectRef } from './object-ref.js';
 export interface PrismaDelegate {
     findUniqueOrThrow?: (...args: any[]) => Promise<unknown>;
     findUnique: (...args: any[]) => Promise<unknown>;
@@ -27,13 +27,13 @@ export interface PrismaModelTypes {
 }
 declare type ExtractModel<Types extends SchemaTypes, ParentShape> = ParentShape extends {
     [prismaModelName]?: infer Name;
-} ? Types['PrismaTypes'][Name & keyof Types['PrismaTypes']] extends infer Model ? Model extends PrismaModelTypes ? Model : never : never : never;
+} ? Types["PrismaTypes"][Name & keyof Types["PrismaTypes"]] extends infer Model ? Model extends PrismaModelTypes ? Model : never : never : never;
 export declare type PrismaObjectFieldOptions<Types extends SchemaTypes, ParentShape, Type extends TypeParam<Types>, Nullable extends FieldNullability<Type>, Args extends InputFieldMap, Select, ResolveReturnShape> = PothosSchemaTypes.ObjectFieldOptions<Types, unknown extends Select ? ParentShape : ParentShape & ShapeFromSelection<ExtractModel<Types, ParentShape>, {
     select: Select extends (...args: any[]) => infer S ? S : Select;
 }>, Type, Nullable, Args, ResolveReturnShape> & {
-    select?: Select & (ExtractModel<Types, ParentShape>['Select'] | ((args: InputShapeFromFields<Args>, ctx: Types['Context'], nestedSelection: <Selection extends boolean | {}>(selection?: Selection, path?: string[]) => Selection) => ExtractModel<Types, ParentShape>['Select']));
+    select?: Select & (ExtractModel<Types, ParentShape>["Select"] | ((args: InputShapeFromFields<Args>, ctx: Types["Context"], nestedSelection: <Selection extends boolean | {}>(selection?: Selection, path?: string[]) => Selection) => ExtractModel<Types, ParentShape>["Select"]));
 };
-declare type PrismaObjectFieldsShape<Types extends SchemaTypes, Model extends PrismaModelTypes, NeedsResolve extends boolean, Shape extends object, Select> = Model['Select'] extends Select ? (t: PrismaObjectFieldBuilder<Types, Model, NeedsResolve, Shape>) => FieldMap : (t: PrismaSelectionFieldBuilder<Types, Model, Shape>) => FieldMap;
+declare type PrismaObjectFieldsShape<Types extends SchemaTypes, Model extends PrismaModelTypes, NeedsResolve extends boolean, Shape extends object, Select> = Model["Select"] extends Select ? (t: PrismaObjectFieldBuilder<Types, Model, NeedsResolve, Shape>) => FieldMap : (t: PrismaSelectionFieldBuilder<Types, Model, Shape>) => FieldMap;
 declare type PrismaSelectionFieldBuilder<Types extends SchemaTypes, Model extends PrismaModelTypes, Shape extends object> = PrismaObjectFieldBuilder<Types, Model, false, Shape>;
 interface BaseSelection {
     include?: unknown;
@@ -42,7 +42,7 @@ interface BaseSelection {
 export declare type SelectedKeys<T> = {
     [K in keyof T]: T[K] extends false ? never : K;
 }[keyof T];
-export declare type ShapeFromSelection<Model extends PrismaModelTypes, Selection> = Normalize<Selection extends BaseSelection ? unknown extends Selection['select'] ? Model['Shape'] & RelationShapeFromInclude<Model, Selection['include']> : Pick<Model['Shape'], SelectedKeys<Selection['select']>> & RelationShapeFromInclude<Model, Selection['select']> & ('_count' extends keyof Selection['select'] ? ShapeFromCount<Selection['select']['_count']> : {}) : Model['Shape']>;
+export declare type ShapeFromSelection<Model extends PrismaModelTypes, Selection> = Normalize<Selection extends BaseSelection ? unknown extends Selection["select"] ? Model["Shape"] & RelationShapeFromInclude<Model, Selection["include"]> : Pick<Model["Shape"], SelectedKeys<Selection["select"]>> & RelationShapeFromInclude<Model, Selection["select"]> & ("_count" extends keyof Selection["select"] ? ShapeFromCount<Selection["select"]["_count"]> : {}) : Model["Shape"]>;
 export declare type ShapeFromCount<Selection> = Selection extends true ? {
     _count: number;
 } : Selection extends {
@@ -53,21 +53,21 @@ export declare type ShapeFromCount<Selection> = Selection extends true ? {
     };
 } : never;
 declare type RelationShapeFromInclude<Model extends PrismaModelTypes, Include> = Normalize<{
-    [K in SelectedKeys<Include> as K extends Model['RelationName'] ? K : never]: K extends keyof Model['Relations'] ? Model['Relations'][K]['Shape'] extends unknown[] ? ShapeFromSelection<Model['Relations'][K]['Types'], Include[K]>[] : ShapeFromSelection<Model['Relations'][K]['Types'], Include[K]> : unknown;
+    [K in SelectedKeys<Include> as K extends Model["RelationName"] ? K : never]: K extends keyof Model["Relations"] ? Model["Relations"][K]["Shape"] extends unknown[] ? ShapeFromSelection<Model["Relations"][K]["Types"], Include[K]>[] : ShapeFromSelection<Model["Relations"][K]["Types"], Include[K]> : unknown;
 }>;
-export declare type PrismaObjectTypeOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Interfaces extends InterfaceParam<Types>[], FindUnique, Include, Select, Shape extends object> = NameOrVariant & Omit<PothosSchemaTypes.ObjectTypeOptions<Types, Shape> | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>, 'fields' | 'description'> & {
+export declare type PrismaObjectTypeOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Interfaces extends InterfaceParam<Types>[], FindUnique, Include, Select, Shape extends object> = NameOrVariant & Omit<PothosSchemaTypes.ObjectTypeOptions<Types, Shape> | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>, "fields" | "description"> & {
     description?: string | false;
     fields?: PrismaObjectFieldsShape<Types, Model, FindUnique extends null ? true : false, Shape & (FindUnique extends null ? {} : {
-        [prismaModelName]?: Model['Name'];
+        [prismaModelName]?: Model["Name"];
     }), Select>;
 } & ({
-    include?: Include & Model['Include'];
+    include?: Include & Model["Include"];
     select?: never;
-    findUnique?: FindUnique & (((parent: Shape, context: Types['Context']) => Model['WhereUnique']) | null);
+    findUnique?: FindUnique & (((parent: Shape, context: Types["Context"]) => Model["WhereUnique"]) | null);
 } | {
-    select: Model['Select'] & Select;
+    select: Model["Select"] & Select;
     include?: never;
-    findUnique?: (parent: Shape, context: Types['Context']) => Model['WhereUnique'];
+    findUnique?: (parent: Shape, context: Types["Context"]) => Model["WhereUnique"];
 });
 declare type NameOrVariant = {
     name?: never;
@@ -76,111 +76,127 @@ declare type NameOrVariant = {
     name?: string;
     variant?: never;
 };
-export declare type PrismaNodeOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Interfaces extends InterfaceParam<Types>[], Include, Select, Shape extends object, UniqueField> = NameOrVariant & Omit<PothosSchemaTypes.ObjectTypeOptions<Types, Shape> | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>, 'fields' | 'isTypeOf'> & {
-    id: Omit<FieldOptionsFromKind<Types, Shape, 'ID', false, {}, 'Object', OutputShape<Types, 'ID'>, MaybePromise<OutputShape<Types, 'ID'>>>, 'args' | 'nullable' | 'resolve' | 'type'> & ({
+export declare type PrismaNodeOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Interfaces extends InterfaceParam<Types>[], Include, Select, Shape extends object, UniqueField> = NameOrVariant & Omit<PothosSchemaTypes.ObjectTypeOptions<Types, Shape> | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>, "fields" | "isTypeOf"> & {
+    id: Omit<FieldOptionsFromKind<Types, Shape, "ID", false, {}, "Object", OutputShape<Types, "ID">, MaybePromise<OutputShape<Types, "ID">>>, "args" | "nullable" | "resolve" | "type"> & ({
         field?: never;
-        resolve: (parent: Shape, context: Types['Context']) => MaybePromise<OutputShape<Types, 'ID'>>;
+        resolve: (parent: Shape, context: Types["Context"]) => MaybePromise<OutputShape<Types, "ID">>;
     } | {
         resolve?: never;
-        field: UniqueField extends keyof Model['WhereUnique'] ? UniqueField : keyof Model['WhereUnique'];
+        field: UniqueField extends keyof Model["WhereUnique"] ? UniqueField : keyof Model["WhereUnique"];
     });
     fields?: PrismaObjectFieldsShape<Types, Model, false, Shape & {
-        [prismaModelName]?: Model['Name'];
+        [prismaModelName]?: Model["Name"];
     }, Select>;
 } & (UniqueField extends string ? {
-    findUnique?: (id: string, context: Types['Context']) => Model['WhereUnique'];
+    findUnique?: (id: string, context: Types["Context"]) => Model["WhereUnique"];
 } : {
-    findUnique: (id: string, context: Types['Context']) => Model['WhereUnique'];
+    findUnique: (id: string, context: Types["Context"]) => Model["WhereUnique"];
 }) & ({
-    include?: Include & Model['Include'];
+    include?: Include & Model["Include"];
     select?: never;
 } | {
-    select: Model['Select'] & Select;
+    select: Model["Select"] & Select;
     include?: never;
 });
 declare type QueryForField<Types extends SchemaTypes, Args extends InputFieldMap, Include> = Include extends {
     where?: unknown;
-} ? Omit<Include, 'include' | 'select'> | ((args: InputShapeFromFields<Args>, ctx: Types['Context']) => Omit<Include, 'include' | 'select'>) : never;
-declare type QueryFromRelation<Model extends PrismaModelTypes, Field extends keyof Model['Include']> = Model['Include'][Field] extends infer Include ? Include extends {
+} ? Omit<Include, "include" | "select"> | ((args: InputShapeFromFields<Args>, ctx: Types["Context"]) => Omit<Include, "include" | "select">) : never;
+declare type QueryFromRelation<Model extends PrismaModelTypes, Field extends keyof Model["Include"]> = Model["Include"][Field] extends infer Include ? Include extends {
     include?: infer I;
     select?: infer S;
 } ? {
     include?: NonNullable<I>;
     select?: NonNullable<S>;
 } : never : never;
-declare type CursorFromRelation<Model extends PrismaModelTypes, Field extends Model['ListRelations']> = Field extends keyof Model['Include'] ? Model['Include'][Field] extends infer Include ? Include extends {
+declare type CursorFromRelation<Model extends PrismaModelTypes, Field extends Model["ListRelations"]> = Field extends keyof Model["Include"] ? Model["Include"][Field] extends infer Include ? Include extends {
     cursor?: infer T;
 } ? keyof T : never : never : never;
-declare type RefForRelation<Model extends PrismaModelTypes, Field extends keyof Model['Relations']> = Model['Relations'][Field] extends unknown[] ? [ObjectRef<Model['Relations'][Field]>] : ObjectRef<Model['Relations'][Field]>;
-export declare type RelatedFieldOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Field extends keyof Model['Relations'], Nullable extends boolean, Args extends InputFieldMap, ResolveReturnShape, NeedsResolve extends boolean, Shape> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, RefForRelation<Model, Field>, Nullable, Args, ResolveReturnShape>, 'resolve' | 'type' | 'description'> & (NeedsResolve extends false ? {
-    resolve?: (query: QueryFromRelation<Model, Field & keyof Model['Include']>, parent: Shape, args: InputShapeFromFields<Args>, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<ShapeWithNullability<Types, Model['Relations'][Field]['Shape'], Nullable>>;
+declare type RefForRelation<Model extends PrismaModelTypes, Field extends keyof Model["Relations"]> = Model["Relations"][Field] extends unknown[] ? [
+    ObjectRef<Model["Relations"][Field]>
+] : ObjectRef<Model["Relations"][Field]>;
+export declare type RelatedFieldOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Field extends keyof Model["Relations"], Nullable extends boolean, Args extends InputFieldMap, ResolveReturnShape, NeedsResolve extends boolean, Shape> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, RefForRelation<Model, Field>, Nullable, Args, ResolveReturnShape>, "resolve" | "type" | "description"> & (NeedsResolve extends false ? {
+    resolve?: (query: QueryFromRelation<Model, Field & keyof Model["Include"]>, parent: Shape, args: InputShapeFromFields<Args>, context: Types["Context"], info: GraphQLResolveInfo) => MaybePromise<ShapeWithNullability<Types, Model["Relations"][Field]["Shape"], Nullable>>;
 } : {
-    resolve: (query: QueryFromRelation<Model, Field & keyof Model['Include']>, parent: Shape, args: InputShapeFromFields<Args>, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<ShapeWithNullability<Types, Model['Relations'][Field]['Shape'], Nullable>>;
+    resolve: (query: QueryFromRelation<Model, Field & keyof Model["Include"]>, parent: Shape, args: InputShapeFromFields<Args>, context: Types["Context"], info: GraphQLResolveInfo) => MaybePromise<ShapeWithNullability<Types, Model["Relations"][Field]["Shape"], Nullable>>;
 }) & {
     description?: string | false;
-    type?: PrismaObjectRef<Model['Relations'][Field]['Types']>;
-    query?: QueryForField<Types, Args, Model['Include'][Field & keyof Model['Include']]>;
+    type?: PrismaObjectRef<Model["Relations"][Field]["Types"]>;
+    query?: QueryForField<Types, Args, Model["Include"][Field & keyof Model["Include"]]>;
 };
-export declare type VariantFieldOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Variant extends PrismaObjectRef<Model>, Args extends InputFieldMap, isNull, Shape> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, Variant, unknown extends isNull ? false : true, Args, Model['Shape']>, 'resolve' | 'type'> & {
-    isNull?: isNull & ((parent: Shape, args: InputShapeFromFields<Args>, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<boolean>);
+export declare type VariantFieldOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Variant extends PrismaObjectRef<Model>, Args extends InputFieldMap, isNull, Shape> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, Variant, unknown extends isNull ? false : true, Args, Model["Shape"]>, "resolve" | "type"> & {
+    isNull?: isNull & ((parent: Shape, args: InputShapeFromFields<Args>, context: Types["Context"], info: GraphQLResolveInfo) => MaybePromise<boolean>);
 };
-export declare type RelationCountOptions<Types extends SchemaTypes, Shape, NeedsResolve extends boolean, Where> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, 'Int', false, {}, number>, 'resolve' | 'type'> & (NeedsResolve extends false ? {
-    where?: Where | ((args: {}, context: Types['Context']) => Where);
-    resolve?: (parent: Shape, args: {}, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<number>;
+export declare type RelationCountOptions<Types extends SchemaTypes, Shape, NeedsResolve extends boolean, Where> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, "Int", false, {}, number>, "resolve" | "type"> & (NeedsResolve extends false ? {
+    where?: Where | ((args: {}, context: Types["Context"]) => Where);
+    resolve?: (parent: Shape, args: {}, context: Types["Context"], info: GraphQLResolveInfo) => MaybePromise<number>;
 } : {
-    where?: Where | ((args: {}, context: Types['Context']) => Where);
-    resolve: (parent: Shape, args: {}, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<number>;
+    where?: Where | ((args: {}, context: Types["Context"]) => Where);
+    resolve: (parent: Shape, args: {}, context: Types["Context"], info: GraphQLResolveInfo) => MaybePromise<number>;
 });
-export declare type PrismaFieldOptions<Types extends SchemaTypes, ParentShape, Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']] | [PrismaObjectRef<PrismaModelTypes>], Model extends PrismaModelTypes, Param extends TypeParam<Types>, Args extends InputFieldMap, Nullable extends FieldNullability<Param>, ResolveShape, ResolveReturnShape, Kind extends FieldKind = FieldKind> = FieldOptionsFromKind<Types, ParentShape, Param, Nullable, Args, Kind, ResolveShape, ResolveReturnShape> extends infer FieldOptions ? Omit<FieldOptions, 'resolve' | 'type'> & {
+export declare type PrismaFieldOptions<Types extends SchemaTypes, ParentShape, Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types["PrismaTypes"] | [
+    keyof Types["PrismaTypes"]
+] | [
+    PrismaObjectRef<PrismaModelTypes>
+], Model extends PrismaModelTypes, Param extends TypeParam<Types>, Args extends InputFieldMap, Nullable extends FieldNullability<Param>, ResolveShape, ResolveReturnShape, Kind extends FieldKind = FieldKind> = FieldOptionsFromKind<Types, ParentShape, Param, Nullable, Args, Kind, ResolveShape, ResolveReturnShape> extends infer FieldOptions ? Omit<FieldOptions, "resolve" | "type"> & {
     type: Type;
     resolve: FieldOptions extends {
         resolve?: (parent: infer Parent, ...args: any[]) => unknown;
     } ? PrismaFieldResolver<Types, Model, Parent, Param, Args, Nullable, ResolveReturnShape> : PrismaFieldResolver<Types, Model, ParentShape, Param, Args, Nullable, ResolveReturnShape>;
 } : never;
-export declare type PrismaFieldWithInputOptions<Types extends SchemaTypes, ParentShape, Kind extends FieldKind, Args extends Record<string, InputFieldRef<unknown, 'Arg'>>, Fields extends Record<string, InputFieldRef<unknown, 'InputObject'>>, Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']] | [PrismaObjectRef<PrismaModelTypes>], Model extends PrismaModelTypes, Param extends TypeParam<Types>, Nullable extends FieldNullability<Param>, InputName extends string, ResolveShape, ResolveReturnShape, ArgRequired extends boolean> = Omit<PrismaFieldOptions<Types, ParentShape, Type, Model, Param, {
+export declare type PrismaFieldWithInputOptions<Types extends SchemaTypes, ParentShape, Kind extends FieldKind, Args extends Record<string, InputFieldRef<unknown, "Arg">>, Fields extends Record<string, InputFieldRef<unknown, "InputObject">>, Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types["PrismaTypes"] | [
+    keyof Types["PrismaTypes"]
+] | [
+    PrismaObjectRef<PrismaModelTypes>
+], Model extends PrismaModelTypes, Param extends TypeParam<Types>, Nullable extends FieldNullability<Param>, InputName extends string, ResolveShape, ResolveReturnShape, ArgRequired extends boolean> = Omit<PrismaFieldOptions<Types, ParentShape, Type, Model, Param, {
     [K in InputName]: InputFieldRef<InputShapeFromFields<Fields> | (true extends ArgRequired ? never : null | undefined)>;
-} & Args, Nullable, ResolveShape, ResolveReturnShape, Kind>, 'args'> & PothosSchemaTypes.FieldWithInputBaseOptions<Types, {
+} & Args, Nullable, ResolveShape, ResolveReturnShape, Kind>, "args"> & PothosSchemaTypes.FieldWithInputBaseOptions<Types, {
     [K in InputName]: InputFieldRef<InputShapeFromFields<Fields> | (true extends ArgRequired ? never : null | undefined)>;
 } & Args, Fields, InputName, ArgRequired>;
 export declare type PrismaFieldResolver<Types extends SchemaTypes, Model extends PrismaModelTypes, Parent, Param extends TypeParam<Types>, Args extends InputFieldMap, Nullable extends FieldNullability<Param>, ResolveReturnShape> = (query: {
-    include?: Model['Include'];
-    select?: Model['Select'];
-}, parent: Parent, args: InputShapeFromFields<Args>, context: Types['Context'], info: GraphQLResolveInfo) => ShapeFromTypeParam<Types, Param, Nullable> extends infer Shape ? [Shape] extends [[readonly (infer Item)[] | null | undefined]] ? ListResolveValue<Shape, Item, ResolveReturnShape> : MaybePromise<Shape> : never;
-export declare type PrismaConnectionFieldOptions<Types extends SchemaTypes, ParentShape, Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'], Model extends PrismaModelTypes, Param extends OutputType<Types>, Nullable extends boolean, Args extends InputFieldMap, ResolveReturnShape, Kind extends FieldKind> = Omit<PothosSchemaTypes.ConnectionFieldOptions<Types, ParentShape, Param, Nullable, false, false, Args, ResolveReturnShape>, 'resolve' | 'type'> & Omit<FieldOptionsFromKind<Types, ParentShape, Param, Nullable, (InputFieldMap extends Args ? {} : Args) & InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments>, Kind, ParentShape, ResolveReturnShape>, 'args' | 'resolve' | 'type'> & (InputShapeFromFields<Args> & PothosSchemaTypes.DefaultConnectionArguments extends infer ConnectionArgs ? {
+    include?: Model["Include"];
+    select?: Model["Select"];
+}, parent: Parent, args: InputShapeFromFields<Args>, context: Types["Context"], info: GraphQLResolveInfo) => ShapeFromTypeParam<Types, Param, Nullable> extends infer Shape ? [
+    Shape
+] extends [
+    [
+        readonly (infer Item)[] | null | undefined
+    ]
+] ? ListResolveValue<Shape, Item, ResolveReturnShape> : MaybePromise<Shape> : never;
+export declare type PrismaConnectionFieldOptions<Types extends SchemaTypes, ParentShape, Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types["PrismaTypes"], Model extends PrismaModelTypes, Param extends OutputType<Types>, Nullable extends boolean, Args extends InputFieldMap, ResolveReturnShape, Kind extends FieldKind> = Omit<PothosSchemaTypes.ConnectionFieldOptions<Types, ParentShape, Param, Nullable, false, false, Args, ResolveReturnShape>, "resolve" | "type"> & Omit<FieldOptionsFromKind<Types, ParentShape, Param, Nullable, (InputFieldMap extends Args ? {} : Args) & InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments>, Kind, ParentShape, ResolveReturnShape>, "args" | "resolve" | "type"> & (InputShapeFromFields<Args> & PothosSchemaTypes.DefaultConnectionArguments extends infer ConnectionArgs ? {
     type: Type;
-    cursor: string & keyof Model['WhereUnique'];
-    defaultSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
-    maxSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
+    cursor: string & keyof Model["WhereUnique"];
+    defaultSize?: number | ((args: ConnectionArgs, ctx: Types["Context"]) => number);
+    maxSize?: number | ((args: ConnectionArgs, ctx: Types["Context"]) => number);
     resolve: (query: {
-        include?: Model['Include'];
-        cursor?: Model['WhereUnique'];
+        include?: Model["Include"];
+        cursor?: Model["WhereUnique"];
         take: number;
         skip: number;
-    }, parent: ParentShape, args: ConnectionArgs, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<Model['Shape'][]>;
-    totalCount?: (parent: ParentShape, args: ConnectionArgs, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<number>;
+    }, parent: ParentShape, args: ConnectionArgs, context: Types["Context"], info: GraphQLResolveInfo) => MaybePromise<Model["Shape"][]>;
+    totalCount?: (parent: ParentShape, args: ConnectionArgs, context: Types["Context"], info: GraphQLResolveInfo) => MaybePromise<number>;
 } : never);
-export declare type RelatedConnectionOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Field extends Model['ListRelations'], Nullable extends boolean, Args extends InputFieldMap, NeedsResolve extends boolean> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Model['Shape'], ObjectRef<unknown>, Nullable, (InputFieldMap extends Args ? {} : Args) & InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments>, unknown>, 'resolve' | 'type' | 'args' | 'description'> & Omit<PothosSchemaTypes.ConnectionFieldOptions<Types, Model['Shape'], ObjectRef<unknown>, false, false, Nullable, Args, unknown>, 'resolve' | 'type'> & (InputShapeFromFields<Args> & PothosSchemaTypes.DefaultConnectionArguments extends infer ConnectionArgs ? {
+export declare type RelatedConnectionOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Field extends Model["ListRelations"], Nullable extends boolean, Args extends InputFieldMap, NeedsResolve extends boolean> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Model["Shape"], ObjectRef<unknown>, Nullable, (InputFieldMap extends Args ? {} : Args) & InputFieldsFromShape<PothosSchemaTypes.DefaultConnectionArguments>, unknown>, "resolve" | "type" | "args" | "description"> & Omit<PothosSchemaTypes.ConnectionFieldOptions<Types, Model["Shape"], ObjectRef<unknown>, false, false, Nullable, Args, unknown>, "resolve" | "type"> & (InputShapeFromFields<Args> & PothosSchemaTypes.DefaultConnectionArguments extends infer ConnectionArgs ? {
     description?: string | false;
-    query?: QueryForField<Types, Args, Model['Include'][Field & keyof Model['Include']]>;
-    type?: PrismaObjectRef<Model['Relations'][Field]['Types']>;
+    query?: QueryForField<Types, Args, Model["Include"][Field & keyof Model["Include"]]>;
+    type?: PrismaObjectRef<Model["Relations"][Field]["Types"]>;
     cursor: CursorFromRelation<Model, Field>;
-    defaultSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
-    maxSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
+    defaultSize?: number | ((args: ConnectionArgs, ctx: Types["Context"]) => number);
+    maxSize?: number | ((args: ConnectionArgs, ctx: Types["Context"]) => number);
     totalCount?: NeedsResolve extends false ? boolean : false;
 } & (NeedsResolve extends false ? {
     resolve?: (query: {
-        include?: Model['Include'];
-        cursor?: Model['WhereUnique'];
+        include?: Model["Include"];
+        cursor?: Model["WhereUnique"];
         take: number;
         skip: number;
-    }, parent: Model['Shape'], args: ConnectionArgs, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<Model['Relations'][Field & keyof Model['Relations']]['Shape']>;
+    }, parent: Model["Shape"], args: ConnectionArgs, context: Types["Context"], info: GraphQLResolveInfo) => MaybePromise<Model["Relations"][Field & keyof Model["Relations"]]["Shape"]>;
 } : {
     resolve: (query: {
-        include?: Model['Include'];
-        cursor?: Model['WhereUnique'];
+        include?: Model["Include"];
+        cursor?: Model["WhereUnique"];
         take: number;
         skip: number;
-    }, parent: Model['Shape'], args: ConnectionArgs, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<Model['Relations'][Field & keyof Model['Relations']]['Shape']>;
+    }, parent: Model["Shape"], args: ConnectionArgs, context: Types["Context"], info: GraphQLResolveInfo) => MaybePromise<Model["Relations"][Field & keyof Model["Relations"]]["Shape"]>;
 }) : never);
 export declare type WithBrand<T> = T & {
     [typeBrandKey]: string;
@@ -207,6 +223,6 @@ export interface IndirectInclude {
 }
 export declare type ShapeFromConnection<T> = T extends {
     shape: unknown;
-} ? T['shape'] : never;
+} ? T["shape"] : never;
 export {};
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=types.d.ts.map

package/esm/{dts/util → util}/cursors.d.ts

@@ -63,4 +63,4 @@ export declare function getCursorParser<Types extends SchemaTypes>(name: string,
     [x: string]: unknown;
 };
 export {};
-//# sourceMappingURL=cursors.d.ts.map
+//# sourceMappingURL=cursors.d.ts.map

package/esm/{dts/util → util}/datamodel.d.ts

@@ -1,6 +1,6 @@
 import { ObjectRef, SchemaTypes } from '@pothos/core';
-import { PrismaObjectRef } from '../object-ref';
-import { PrismaClient, PrismaDelegate, PrismaModelTypes } from '../types';
+import { PrismaObjectRef } from '../object-ref.js';
+import { PrismaClient, PrismaDelegate, PrismaModelTypes } from '../types.js';
 export declare const refMap: WeakMap<object, Map<string, PrismaObjectRef<PrismaModelTypes, {}>>>;
 export declare const findUniqueMap: WeakMap<object, Map<ObjectRef<unknown, unknown>, ((args: unknown, ctx: {}) => unknown) | null>>;
 export declare const includeForRefMap: WeakMap<object, Map<ObjectRef<unknown, unknown>, Record<string, unknown> | null>>;
@@ -21,4 +21,4 @@ export declare function getModel<Types extends SchemaTypes>(name: string, builde
     documentation?: string | undefined;
 };
 export declare function getDelegateFromModel(client: PrismaClient, model: string): PrismaDelegate;
-//# sourceMappingURL=datamodel.d.ts.map
+//# sourceMappingURL=datamodel.d.ts.map

package/esm/{dts/util → util}/deep-equal.d.ts

@@ -1,2 +1,2 @@
 export declare function deepEqual(left: unknown, right: unknown, ignore?: Set<string>): boolean;
-//# sourceMappingURL=deep-equal.d.ts.map
+//# sourceMappingURL=deep-equal.d.ts.map

package/esm/{dts/util → util}/description.d.ts

@@ -1,4 +1,4 @@
 import { SchemaTypes } from '@pothos/core';
 export declare function getFieldDescription<Types extends SchemaTypes>(model: string, builder: PothosSchemaTypes.SchemaBuilder<Types>, fieldName: string, description?: string | false): string | undefined;
 export declare function getModelDescription<Types extends SchemaTypes>(model: string, builder: PothosSchemaTypes.SchemaBuilder<Types>, description?: string | false): string | undefined;
-//# sourceMappingURL=description.d.ts.map
+//# sourceMappingURL=description.d.ts.map

package/esm/{dts/util → util}/get-client.d.ts

@@ -1,5 +1,5 @@
 import { SchemaTypes } from '@pothos/core';
-import { PrismaClient } from '../types';
+import { PrismaClient } from '../types.js';
 export interface DMMFField {
     type: string;
     kind: string;
@@ -27,7 +27,7 @@ interface DMMF {
         }[];
     };
 }
-export declare function getClient<Types extends SchemaTypes>(builder: PothosSchemaTypes.SchemaBuilder<Types>, context: Types['Context']): PrismaClient;
+export declare function getClient<Types extends SchemaTypes>(builder: PothosSchemaTypes.SchemaBuilder<Types>, context: Types["Context"]): PrismaClient;
 export declare function getDMMF<Types extends SchemaTypes>(builder: PothosSchemaTypes.SchemaBuilder<Types>): DMMF;
 export {};
-//# sourceMappingURL=get-client.d.ts.map
+//# sourceMappingURL=get-client.d.ts.map

package/esm/{dts/util → util}/loader-map.d.ts

@@ -1,6 +1,6 @@
 import { GraphQLResolveInfo } from 'graphql';
-import { LoaderMappings } from '../types';
-export declare function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath: string[]): string;
+import { LoaderMappings } from '../types.js';
+export declare function cacheKey(type: string, path: GraphQLResolveInfo["path"], subPath: string[]): string;
 export declare function setLoaderMappings(ctx: object, info: GraphQLResolveInfo, value: LoaderMappings): void;
-export declare function getLoaderMapping(ctx: object, path: GraphQLResolveInfo['path'], type: string): LoaderMappings | null;
-//# sourceMappingURL=loader-map.d.ts.map
+export declare function getLoaderMapping(ctx: object, path: GraphQLResolveInfo["path"], type: string): LoaderMappings | null;
+//# sourceMappingURL=loader-map.d.ts.map

package/esm/{dts/util → util}/map-query.d.ts

@@ -1,7 +1,7 @@
 import { GraphQLNamedType, GraphQLResolveInfo } from 'graphql';
-import { SelectionMap } from '../types';
-import { SelectionState } from './selections';
-export declare function queryFromInfo<T extends SelectionMap['select'] | undefined = undefined>({ context, info, typeName, select, path, }: {
+import { SelectionMap } from '../types.js';
+import { SelectionState } from './selections.js';
+export declare function queryFromInfo<T extends SelectionMap["select"] | undefined = undefined>({ context, info, typeName, select, path, }: {
     context: object;
     info: GraphQLResolveInfo;
     typeName?: string;
@@ -14,4 +14,4 @@ export declare function queryFromInfo<T extends SelectionMap['select'] | undefin
 };
 export declare function selectionStateFromInfo(context: object, info: GraphQLResolveInfo, typeName?: string): SelectionState;
 export declare function getIndirectType(type: GraphQLNamedType, info: GraphQLResolveInfo): GraphQLNamedType;
-//# sourceMappingURL=map-query.d.ts.map
+//# sourceMappingURL=map-query.d.ts.map

package/esm/{dts/util → util}/relation-map.d.ts

@@ -6,6 +6,7 @@ export interface FieldMap {
 export declare type RelationMap = Map<string, FieldMap>;
 export declare const getRelationMap: import("@pothos/core").ContextCache<RelationMap, {
     datamodel: unknown;
-}, []>;
+}, [
+]>;
 export declare function createRelationMap({ models }: DMMF.Datamodel): RelationMap;
-//# sourceMappingURL=relation-map.d.ts.map
+//# sourceMappingURL=relation-map.d.ts.map

package/esm/{dts/util → util}/selections.d.ts

@@ -1,6 +1,6 @@
-import { LoaderMappings, SelectionMap } from '../types';
-import { FieldMap } from './relation-map';
-export declare type SelectionMode = 'select' | 'include';
+import { LoaderMappings, SelectionMap } from '../types.js';
+import { FieldMap } from './relation-map.js';
+export declare type SelectionMode = "select" | "include";
 export interface SelectionState {
     fieldMap: FieldMap;
     query: object;
@@ -17,4 +17,4 @@ export declare function mergeState(state: SelectionState, newState: SelectionSta
 export declare function createState(fieldMap: FieldMap, mode: SelectionMode, parent?: SelectionState): SelectionState;
 export declare function mergeSelection(state: SelectionState, { select, include, ...query }: SelectionMap): void;
 export declare function selectionToQuery(state: SelectionState): SelectionMap;
-//# sourceMappingURL=selections.d.ts.map
+//# sourceMappingURL=selections.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pothos/plugin-prisma",
-  "version": "3.35.1",
+  "version": "3.35.3",
   "description": "A Pothos plugin for more efficient integration with prisma",
   "main": "./lib/index.js",
   "types": "./dts/index.d.ts",
@@ -52,12 +52,12 @@
     "typescript": ">=4.7.2"
   },
   "devDependencies": {
-    "@pothos/core": "3.22.1",
-    "@pothos/plugin-complexity": "3.11.1",
-    "@pothos/plugin-errors": "3.8.1",
-    "@pothos/plugin-relay": "3.28.1",
-    "@pothos/plugin-simple-objects": "3.6.1",
-    "@pothos/test-utils": "1.4.1",
+    "@pothos/core": "3.22.4",
+    "@pothos/plugin-complexity": "3.11.3",
+    "@pothos/plugin-errors": "3.8.3",
+    "@pothos/plugin-relay": "3.28.3",
+    "@pothos/plugin-simple-objects": "3.6.3",
+    "@pothos/test-utils": "1.4.2",
     "@prisma/client": "^4.4.0",
     "graphql": "16.6.0",
     "graphql-tag": "^2.12.6",
@@ -69,9 +69,9 @@
     "build": "pnpm build:clean && pnpm build:cjs && pnpm build:dts && pnpm build:esm",
     "build:clean": "git clean -dfX esm lib",
     "build:cjs": "swc src -d lib --config-file ../../.swcrc -C module.type=commonjs",
-    "build:esm": "cp -r dts/ esm/ && swc src -d esm --config-file ../../.swcrc -C module.type=es6 && pnpm esm:extensions",
+    "build:esm": "cp -r dts/* esm/ && swc src -d esm --config-file ../../.swcrc -C module.type=es6 && pnpm esm:extensions",
     "build:dts": "tsc",
     "esm:extensions": "TS_NODE_PROJECT=../../tsconfig.json node -r @swc-node/register ../../scripts/esm-transformer.ts",
-    "test": "pnpm vitest --run"
+    "test": "pnpm vitest --run --segfault-retry=3"
   }
 }

package/esm/dts/field-builder.d.ts

@@ -1,2 +0,0 @@
-export * from './prisma-field-builder';
-//# sourceMappingURL=field-builder.d.ts.map

package/esm/dts/generator.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=generator.d.ts.map

package/esm/dts/global-types.d.ts

@@ -1,94 +0,0 @@
-import { FieldKind, FieldNullability, FieldRef, InputFieldMap, InputFieldRef, InterfaceParam, NormalizeArgs, OutputType, PluginName, SchemaTypes, ShapeFromTypeParam, TypeParam } from '@pothos/core';
-import PrismaNodeRef from './node-ref';
-import { prismaModelKey, PrismaObjectRef } from './object-ref';
-import { PrismaObjectFieldBuilder as InternalPrismaObjectFieldBuilder } from './prisma-field-builder';
-import { PrismaClient, PrismaConnectionFieldOptions, PrismaFieldOptions, PrismaFieldWithInputOptions, PrismaModelTypes, PrismaNodeOptions, PrismaObjectFieldOptions, PrismaObjectTypeOptions, ShapeFromConnection, ShapeFromSelection } from './types';
-import type { PrismaPlugin } from '.';
-declare global {
-    export namespace PothosSchemaTypes {
-        interface Plugins<Types extends SchemaTypes> {
-            prisma: PrismaPlugin<Types>;
-        }
-        interface SchemaBuilderOptions<Types extends SchemaTypes> {
-            prisma: {
-                filterConnectionTotalCount?: boolean;
-                client: PrismaClient;
-                exposeDescriptions?: boolean | {
-                    models?: boolean;
-                    fields?: boolean;
-                };
-            } | {
-                filterConnectionTotalCount?: boolean;
-                client: (ctx: Types['Context']) => PrismaClient;
-                dmmf: {
-                    datamodel: unknown;
-                };
-                exposeDescriptions?: boolean | {
-                    models?: boolean;
-                    fields?: boolean;
-                };
-            };
-        }
-        interface UserSchemaTypes {
-            PrismaTypes: {};
-        }
-        interface ExtendDefaultTypes<PartialTypes extends Partial<UserSchemaTypes>> {
-            PrismaTypes: PartialTypes['PrismaTypes'] & {};
-        }
-        interface PothosKindToGraphQLType {
-            PrismaObject: 'Object';
-        }
-        interface FieldOptionsByKind<Types extends SchemaTypes, ParentShape, Type extends TypeParam<Types>, Nullable extends FieldNullability<Type>, Args extends InputFieldMap, ResolveShape, ResolveReturnShape> {
-            PrismaObject: PrismaObjectFieldOptions<Types, ParentShape, Type, Nullable, Args, ResolveShape, ResolveReturnShape>;
-        }
-        interface SchemaBuilder<Types extends SchemaTypes> {
-            prismaObject: <Name extends keyof Types['PrismaTypes'], Interfaces extends InterfaceParam<Types>[], FindUnique, Model extends PrismaModelTypes & Types['PrismaTypes'][Name], Include = unknown, Select = unknown>(name: Name, options: PrismaObjectTypeOptions<Types, Model, Interfaces, FindUnique, Include, Select, ShapeFromSelection<Model, {
-                select: Select;
-                include: Include;
-            }>>) => PrismaObjectRef<Model, ShapeFromSelection<Model, {
-                select: Select;
-                include: Include;
-            }>>;
-            prismaNode: 'relay' extends PluginName ? <Name extends keyof Types['PrismaTypes'], Interfaces extends InterfaceParam<Types>[] = [], Include = unknown, Select = unknown, UniqueField = unknown>(name: Name, options: PrismaNodeOptions<Types, Types['PrismaTypes'][Name] & PrismaModelTypes, Interfaces, Include, Select, ShapeFromSelection<PrismaModelTypes & Types['PrismaTypes'][Name], {
-                select: Select;
-                include: Include;
-            }>, UniqueField>) => PrismaNodeRef<Types['PrismaTypes'][Name] & PrismaModelTypes, ShapeFromSelection<PrismaModelTypes & Types['PrismaTypes'][Name], {
-                select: Select;
-                include: Include;
-            }>> : '@pothos/plugin-relay is required to use this method';
-        }
-        interface RootFieldBuilder<Types extends SchemaTypes, ParentShape, Kind extends FieldKind = FieldKind> {
-            prismaField: <Args extends InputFieldMap, TypeParam extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']] | [PrismaObjectRef<PrismaModelTypes>], Nullable extends FieldNullability<Type>, ResolveShape, ResolveReturnShape, Type extends TypeParam extends [unknown] ? [ObjectRef<Model['Shape']>] : ObjectRef<Model['Shape']>, Model extends PrismaModelTypes = PrismaModelTypes & (TypeParam extends [keyof Types['PrismaTypes']] ? Types['PrismaTypes'][TypeParam[0]] : TypeParam extends [PrismaObjectRef<PrismaModelTypes>] ? TypeParam[0][typeof prismaModelKey] : TypeParam extends PrismaObjectRef<PrismaModelTypes> ? TypeParam[typeof prismaModelKey] : TypeParam extends keyof Types['PrismaTypes'] ? Types['PrismaTypes'][TypeParam] : never)>(options: PrismaFieldOptions<Types, ParentShape, TypeParam, Model, Type, Args, Nullable, ResolveShape, ResolveReturnShape, Kind>) => FieldRef<ShapeFromTypeParam<Types, Type, Nullable>>;
-            prismaConnection: 'relay' extends PluginName ? <Type extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'], Nullable extends boolean, ResolveReturnShape, Args extends InputFieldMap = {}, Model extends PrismaModelTypes = Type extends PrismaObjectRef<infer T> ? T : PrismaModelTypes & Types['PrismaTypes'][Type & keyof Types['PrismaTypes']]>(options: PrismaConnectionFieldOptions<Types, ParentShape, Type, Model, ObjectRef<Model['Shape']>, Nullable, Args, ResolveReturnShape, Kind>, ...args: NormalizeArgs<[
-                connectionOptions: ConnectionObjectOptions<Types, ObjectRef<Model['Shape']>, false, false, ResolveReturnShape>,
-                edgeOptions: ConnectionEdgeObjectOptions<Types, ObjectRef<Model['Shape']>, false, ResolveReturnShape>
-            ], 0>) => FieldRef<ShapeFromConnection<ConnectionShapeHelper<Types, Model['Shape'], Nullable>>> : '@pothos/plugin-relay is required to use this method';
-            prismaFieldWithInput: 'prisma' extends PluginName ? <Fields extends Record<string, InputFieldRef<unknown, 'InputObject'>>, TypeParam extends PrismaObjectRef<PrismaModelTypes> | keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']] | [PrismaObjectRef<PrismaModelTypes>], Type extends TypeParam extends [unknown] ? [ObjectRef<Model['Shape']>] : ObjectRef<Model['Shape']>, ResolveShape, ResolveReturnShape, ArgRequired extends boolean, Args extends Record<string, InputFieldRef<unknown, 'Arg'>> = {}, Nullable extends FieldNullability<Type> = Types['DefaultFieldNullability'], InputName extends string = 'input', Model extends PrismaModelTypes = PrismaModelTypes & (TypeParam extends [keyof Types['PrismaTypes']] ? Types['PrismaTypes'][TypeParam[0]] : TypeParam extends [PrismaObjectRef<PrismaModelTypes>] ? TypeParam[0][typeof prismaModelKey] : TypeParam extends PrismaObjectRef<PrismaModelTypes> ? TypeParam[typeof prismaModelKey] : TypeParam extends keyof Types['PrismaTypes'] ? Types['PrismaTypes'][TypeParam] : never)>(options: PrismaFieldWithInputOptions<Types, ParentShape, Kind, Args, Fields, TypeParam, Model, Type, Nullable, InputName, ResolveShape, ResolveReturnShape, boolean extends ArgRequired ? (Types & {
-                WithInputArgRequired: boolean;
-            })['WithInputArgRequired'] : ArgRequired>) => FieldRef<ShapeFromTypeParam<Types, Type, Nullable>> : '@pothos/plugin-prisma is required to use this method';
-        }
-        interface ConnectionFieldOptions<Types extends SchemaTypes, ParentShape, Type extends OutputType<Types>, Nullable extends boolean, EdgeNullability extends FieldNullability<[unknown]>, NodeNullability extends boolean, Args extends InputFieldMap, ResolveReturnShape> {
-        }
-        interface ConnectionObjectOptions<Types extends SchemaTypes, Type extends OutputType<Types>, EdgeNullability extends FieldNullability<[unknown]>, NodeNullability extends boolean, Resolved> {
-        }
-        interface ConnectionEdgeObjectOptions<Types extends SchemaTypes, Type extends OutputType<Types>, NodeNullability extends boolean, Resolved> {
-        }
-        interface DefaultConnectionArguments {
-            first?: number | null | undefined;
-            last?: number | null | undefined;
-            before?: string | null | undefined;
-            after?: string | null | undefined;
-        }
-        interface ConnectionShapeHelper<Types extends SchemaTypes, T, Nullable> {
-        }
-        interface ScopeAuthFieldAuthScopes<Types extends SchemaTypes, Parent, Args extends {} = {}> {
-        }
-        interface ScopeAuthContextForAuth<Types extends SchemaTypes, Scopes extends {}> {
-        }
-        interface PrismaObjectFieldBuilder<Types extends SchemaTypes, Model extends PrismaModelTypes, NeedsResolve extends boolean, Shape extends object = Model['Shape']> extends InternalPrismaObjectFieldBuilder<Types, Model, NeedsResolve, Shape>, RootFieldBuilder<Types, Shape, 'PrismaObject'> {
-        }
-        interface FieldWithInputBaseOptions<Types extends SchemaTypes, Args extends Record<string, InputFieldRef<unknown, 'Arg'>>, Fields extends Record<string, InputFieldRef<unknown, 'InputObject'>>, InputName extends string, ArgRequired extends boolean> {
-        }
-    }
-}
-//# sourceMappingURL=global-types.d.ts.map

package/esm/dts/node-ref.d.ts

@@ -1,5 +0,0 @@
-import { PrismaObjectRef } from './object-ref';
-import type { PrismaModelTypes } from './types';
-export default class PrismaNodeRef<Model extends PrismaModelTypes, T> extends PrismaObjectRef<Model, T> {
-}
-//# sourceMappingURL=node-ref.d.ts.map

package/esm/dts/schema-builder.d.ts

@@ -1,2 +0,0 @@
-import './global-types';
-//# sourceMappingURL=schema-builder.d.ts.map