import { type ArgumentRef, type FieldKind, type FieldMap, type FieldNullability, type FieldOptionsFromKind, type InferredFieldOptionKeys, type InferredFieldOptionsByKind, type InputFieldMap, type InputFieldsFromShape, type InputShapeFromFields, type InterfaceParam, type ListResolveValue, type MaybePromise, type Merge, type Normalize, type ObjectRef, type OutputShape, type OutputType, type SchemaTypes, type ShapeFromTypeParam, type ShapeWithNullability, type TypeParam, typeBrandKey } from '@pothos/core';
import type { FieldNode, GraphQLResolveInfo } from 'graphql';
import type { PrismaInterfaceRef, PrismaRef } from './interface-ref';
import type { PrismaObjectFieldBuilder } from './prisma-field-builder';
export interface PrismaDelegate {
    findUniqueOrThrow?: (...args: any[]) => Promise<unknown>;
    findUnique: (...args: any[]) => Promise<unknown>;
}
export declare const prismaModelName: unique symbol;
export interface PrismaClient {
    $connect: () => Promise<void>;
}
export interface PrismaModelTypes {
    Name: string;
    Shape: {};
    Include: unknown;
    Select: unknown;
    OrderBy: unknown;
    Where: {};
    WhereUnique: {};
    Create: {};
    Update: {};
    ListRelations: string;
    RelationName: string;
    Relations: Record<string, {
        Shape: unknown;
        Name: string;
        Nullable: boolean;
    }>;
}
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;
export type PrismaObjectFieldOptions<Types extends SchemaTypes, ParentShape, Type extends TypeParam<Types>, Nullable extends FieldNullability<Type>, Args extends InputFieldMap, Select, ResolveReturnShape, Shape = unknown extends Select ? ParentShape : ParentShape & ShapeFromSelection<Types, ExtractModel<Types, ParentShape>, {
    select: Select extends (...args: any[]) => infer S ? S : Select;
}>> = PothosSchemaTypes.ObjectFieldOptions<Types, Shape, Type, Nullable, Args, ResolveReturnShape> & InferredFieldOptionsByKind<Types, Types['InferredFieldOptionsKind'], Shape, Type, Nullable, Args, ResolveReturnShape> & {
    select?: Select & (ExtractModel<Types, ParentShape>['Select'] | ((args: InputShapeFromFields<Args>, ctx: Types['Context'], nestedSelection: <Selection extends boolean | {}>(selection?: Selection, path?: string[], type?: string) => Selection) => ExtractModel<Types, ParentShape>['Select']));
};
type PrismaObjectFieldsShape<Types extends SchemaTypes, Model extends PrismaModelTypes, Shape extends object, Select> = Model['Select'] extends Select ? (t: PrismaObjectFieldBuilder<Types, Model, Shape>) => FieldMap : (t: PrismaSelectionFieldBuilder<Types, Model, Shape>) => FieldMap;
type PrismaSelectionFieldBuilder<Types extends SchemaTypes, Model extends PrismaModelTypes, Shape extends object> = PrismaObjectFieldBuilder<Types, Model, Shape>;
interface BaseSelection {
    include?: unknown;
    select?: unknown;
}
export type SelectedKeys<T> = {
    [K in keyof T]: T[K] extends false ? never : K;
}[keyof T];
export type ShapeFromSelection<Types extends SchemaTypes, Model extends PrismaModelTypes, Selection> = Normalize<Selection extends BaseSelection ? unknown extends Selection['select'] ? Model['Shape'] & RelationShapeFromInclude<Types, Model, Selection['include']> : Pick<Model['Shape'], SelectedKeys<Selection['select']>> & RelationShapeFromInclude<Types, Model, Selection['select']> & ('_count' extends keyof Selection['select'] ? ShapeFromCount<Selection['select']['_count']> : {}) : Model['Shape']>;
export type ShapeFromCount<Selection> = Selection extends true ? {
    _count: number;
} : Selection extends {
    select: infer Counts;
} ? {
    _count: {
        [K in keyof Counts]: number;
    };
} : never;
export type TypesForRelation<Types extends SchemaTypes, Model extends PrismaModelTypes, Relation extends keyof Model['Relations']> = Model['Relations'][Relation]['Name'] extends infer Name ? Name extends keyof Types['PrismaTypes'] ? PrismaModelTypes & Types['PrismaTypes'][Name] : never : never;
type RelationShapeFromInclude<Types extends SchemaTypes, 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<Types, TypesForRelation<Types, Model, K>, Include[K]>[] : Model['Relations'][K]['Nullable'] extends true ? ShapeFromSelection<Types, TypesForRelation<Types, Model, K>, Include[K]> | null : ShapeFromSelection<Types, TypesForRelation<Types, Model, K>, Include[K]> : unknown;
}>;
export type PrismaObjectRefOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Include, Select, Shape extends object> = NameOrVariant & ({
    include?: Include & Model['Include'];
    select?: never;
    findUnique?: ((parent: Shape, context: Types['Context']) => Model['WhereUnique']) | null;
} | {
    select: Model['Select'] & Select;
    include?: never;
    findUnique?: (parent: Shape, context: Types['Context']) => Model['WhereUnique'];
});
export type PrismaObjectImplementationOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Interfaces extends InterfaceParam<Types>[], Select, Shape extends object> = Omit<PothosSchemaTypes.ObjectTypeOptions<Types, Shape> | PothosSchemaTypes.ObjectTypeWithInterfaceOptions<Types, Shape, Interfaces>, 'description' | 'fields'> & {
    description?: string | false;
    fields?: PrismaObjectFieldsShape<Types, Model, Shape & {
        [prismaModelName]?: Model['Name'];
    }, Select>;
};
export type PrismaObjectTypeOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Interfaces extends InterfaceParam<Types>[], Include, Select, Shape extends object> = PrismaObjectImplementationOptions<Types, Model, Interfaces, Select, Shape> & PrismaObjectRefOptions<Types, Model, Include, Select, Shape>;
export type PrismaInterfaceRefOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Include, Select, Shape extends object> = NameOrVariant & ({
    include?: Include & Model['Include'];
    select?: never;
    findUnique?: ((parent: Shape, context: Types['Context']) => Model['WhereUnique']) | null;
} | {
    select: Model['Select'] & Select;
    include?: never;
    findUnique?: (parent: Shape, context: Types['Context']) => Model['WhereUnique'];
});
export type PrismaInterfaceImplementationOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Interfaces extends InterfaceParam<Types>[], Select, Shape extends object> = Omit<PothosSchemaTypes.InterfaceTypeOptions<Types, Shape, Interfaces>, 'description' | 'fields'> & {
    description?: string | false;
    fields?: PrismaObjectFieldsShape<Types, Model, Shape & {
        [prismaModelName]?: Model['Name'];
    }, Select>;
};
export type PrismaInterfaceTypeOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Interfaces extends InterfaceParam<Types>[], Include, Select, Shape extends object> = PrismaInterfaceImplementationOptions<Types, Model, Interfaces, Select, Shape> & PrismaInterfaceRefOptions<Types, Model, Include, Select, Shape>;
type NameOrVariant = {
    name?: never;
    variant?: string;
} | {
    name?: string;
    variant?: never;
};
export 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'> & (UniqueField extends string ? {
    findUnique?: (id: string, context: Types['Context']) => Model['WhereUnique'];
} : {
    findUnique: (id: string, context: Types['Context']) => Model['WhereUnique'];
}) & {
    id: Omit<FieldOptionsFromKind<Types, Shape, 'ID', false, {}, 'Object', OutputShape<Types, 'ID'>, MaybePromise<OutputShape<Types, 'ID'>>>, 'args' | 'nullable' | 'type' | InferredFieldOptionKeys> & ({
        field?: never;
        resolve: (parent: Shape, context: Types['Context']) => MaybePromise<OutputShape<Types, 'ID'>>;
    } | {
        resolve?: never;
        field: UniqueField extends UniqueFieldsFromWhereUnique<Model['WhereUnique']> ? UniqueField : UniqueFieldsFromWhereUnique<Model['WhereUnique']>;
    });
    fields?: PrismaObjectFieldsShape<Types, Model, Shape & {
        [prismaModelName]?: Model['Name'];
    }, Select>;
} & {
    nullable?: boolean;
} & ({
    include?: Include & Model['Include'];
    select?: never;
} | {
    select: Model['Select'] & Select;
    include?: never;
});
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;
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;
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;
} ? UniqueFieldsFromWhereUnique<T> : never : never : never;
type RefForRelation<Types extends SchemaTypes, Model extends PrismaModelTypes, Field extends keyof Model['Relations']> = Model['Relations'][Field] extends unknown[] ? [ObjectRef<Types, Model['Relations'][Field]>] : ObjectRef<Types, Model['Relations'][Field]>;
export type RelatedFieldOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Field extends keyof Model['Relations'], Nullable extends boolean, Args extends InputFieldMap, ResolveReturnShape, Shape> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, RefForRelation<Types, Model, Field>, Nullable, Args, ResolveReturnShape>, 'description' | 'type' | InferredFieldOptionKeys> & {
    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?: PrismaRef<any, TypesForRelation<Types, Model, Field>>;
    query?: QueryForField<Types, Args, Model['Include'][Field & keyof Model['Include']]>;
    onNull?: 'error' | ((parent: Shape, args: InputShapeFromFields<Args>, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<Error | ShapeWithNullability<Types, Model['Relations'][Field]['Shape'], Nullable>>);
} & ({
    field: boolean extends Nullable ? Types['DefaultFieldNullability'] : Nullable;
    relation: Model['Relations'][Field]['Nullable'];
} extends {
    field: false;
    relation: true;
} ? {
    onNull: {};
} : {});
export type VariantFieldOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Variant extends PrismaRef<any, Model>, Args extends InputFieldMap, isNull, Shape> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, Variant, unknown extends isNull ? false : true, Args, Model['Shape']>, InferredFieldOptionKeys | 'type'> & {
    isNull?: isNull & ((parent: Shape, args: InputShapeFromFields<Args>, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<boolean>);
};
export type RelationCountOptions<Types extends SchemaTypes, Shape, Where, Args extends InputFieldMap> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Shape, 'Int', false, Args, number>, 'type' | InferredFieldOptionKeys> & {
    resolve?: (parent: Shape, args: InputShapeFromFields<Args>, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<number>;
    where?: Where | ((args: InputShapeFromFields<Args>, context: Types['Context']) => Where);
};
export type PrismaFieldOptions<Types extends SchemaTypes, ParentShape, Type extends PrismaRef<any, PrismaModelTypes> | keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']] | [PrismaRef<any, 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, InferredFieldOptionKeys | '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 type PrismaFieldWithInputOptions<Types extends SchemaTypes, ParentShape, Kind extends FieldKind, Args extends InputFieldMap, Fields extends InputFieldMap, Type extends PrismaRef<any, PrismaModelTypes> | keyof Types['PrismaTypes'] | [keyof Types['PrismaTypes']] | [PrismaRef<any, 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, Args & {
    [K in InputName]: ArgumentRef<Types, InputShapeFromFields<Fields> | (true extends ArgRequired ? never : null | undefined)>;
}, Nullable, ResolveShape, ResolveReturnShape, Kind>, 'args'> & PothosSchemaTypes.FieldWithInputBaseOptions<Types, Args & {
    [K in InputName]: ArgumentRef<Types, InputShapeFromFields<Fields> | (true extends ArgRequired ? never : null | undefined)>;
}, Fields, InputName, ArgRequired>;
export 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 type PrismaConnectionFieldOptions<Types extends SchemaTypes, ParentShape, Type extends PrismaInterfaceRef<any, PrismaModelTypes> | PrismaRef<any, PrismaModelTypes> | keyof Types['PrismaTypes'], Model extends PrismaModelTypes, Param extends OutputType<Types>, Nullable extends boolean, Args extends InputFieldMap, ResolveReturnShape, Kind extends FieldKind> = Omit<FieldOptionsFromKind<Types, ParentShape, Param, Nullable, InputFieldsFromShape<Types, PothosSchemaTypes.DefaultConnectionArguments, 'Arg'> & (InputFieldMap extends Args ? {} : Args), Kind, ParentShape, ResolveReturnShape>, 'args' | InferredFieldOptionKeys | 'type'> & Omit<PothosSchemaTypes.ConnectionFieldOptions<Types, ParentShape, Param, Nullable, false, false, Args, ResolveReturnShape>, InferredFieldOptionKeys | 'type'> & (InputShapeFromFields<Args> & PothosSchemaTypes.DefaultConnectionArguments extends infer ConnectionArgs ? {
    type: Type;
    cursor: UniqueFieldsFromWhereUnique<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'];
        take: number;
        skip: number;
    }, parent: ParentShape, args: ConnectionArgs, 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;
    totalCount?: (parent: ParentShape, args: ConnectionArgs, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<number>;
} : never);
export type RelatedConnectionOptions<Types extends SchemaTypes, Model extends PrismaModelTypes, Field extends Model['ListRelations'], Nullable extends boolean, Args extends InputFieldMap, Type = unknown> = Omit<PothosSchemaTypes.ObjectFieldOptions<Types, Model['Shape'], ObjectRef<Types, unknown>, Nullable, InputFieldsFromShape<Types, PothosSchemaTypes.DefaultConnectionArguments, 'InputObject'> & (InputFieldMap extends Args ? {} : Args), unknown>, 'args' | 'description' | InferredFieldOptionKeys | 'type'> & Omit<PothosSchemaTypes.ConnectionFieldOptions<Types, Model['Shape'], ObjectRef<Types, unknown>, false, false, Nullable, Args, unknown>, InferredFieldOptionKeys | 'type'> & (InputShapeFromFields<Args> & PothosSchemaTypes.DefaultConnectionArguments extends infer ConnectionArgs ? {
    resolve?: (query: {
        include?: Model['Include'];
        cursor?: Model['WhereUnique'];
        take: number;
        skip: number;
    }, parent: Model['Shape'], args: ConnectionArgs, context: Types['Context'], info: GraphQLResolveInfo) => MaybePromise<ShapeFromTypeParam<Types, [
        ObjectRef<Types, Model['Relations'][Field & keyof Model['Relations']]['Shape']>
    ], Nullable>>;
} & {
    description?: string | false;
    query?: QueryForField<Types, Args, Model['Include'][Field & keyof Model['Include']]>;
    type?: Type & PrismaRef<any, TypesForRelation<Types, Model, Field>>;
    cursor: CursorFromRelation<Model, Field>;
    defaultSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
    maxSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
    totalCount?: boolean;
} : never);
export type WithBrand<T> = T & {
    [typeBrandKey]: string;
};
export type IncludeMap = Record<string, SelectionMap | boolean>;
export interface SelectionMap {
    select?: Record<string, SelectionMap | boolean>;
    include?: Record<string, SelectionMap | boolean>;
    where?: object;
}
export type FieldSelection = Record<string, SelectionMap | boolean> | ((args: object, context: object, mergeNestedSelection: (selection: SelectionMap | boolean | ((args: object, context: object) => SelectionMap), path?: IndirectInclude | string[], type?: string) => SelectionMap | boolean, resolveSelection: (path: string[]) => FieldNode | null) => SelectionMap);
export type LoaderMappings = Record<string, {
    field: string;
    type: string;
    mappings: LoaderMappings;
    indirectPath: string[];
}>;
export interface IndirectInclude {
    getType: () => string;
    path?: {
        type?: string;
        name: string;
    }[];
    paths?: {
        type?: string;
        name: string;
    }[][];
}
export type ShapeFromConnection<T> = T extends {
    shape: unknown;
} ? T['shape'] : never;
export type PrismaConnectionShape<Types extends SchemaTypes, T, Parent, Args extends InputFieldMap> = Merge<ShapeFromConnection<PothosSchemaTypes.ConnectionShapeHelper<Types, T, false>> extends infer Shape ? Shape & {
    parent: Parent;
    args: InputShapeFromFields<Args> & PothosSchemaTypes.DefaultConnectionArguments;
} : never> extends infer C ? [C] extends [
    {
        edges: infer Edges;
    }
] ? Merge<Omit<C, 'edges'> & {
    edges: Edges extends Iterable<MaybePromise<infer Edge> | null | undefined> ? Merge<Edge & {
        connection: C;
    }>[] : never;
}> : C : never;
export type UniqueFieldsExtendedWhereUnique<T> = NonNullable<T extends infer O ? {
    [K in keyof O]: undefined extends O[K] ? never : K;
}[keyof O] : never>;
export type UniqueFieldsFromWhereUnique<T> = string & (UniqueFieldsExtendedWhereUnique<T> extends infer K ? [K] extends [never] ? keyof T : K : never);
type Simplify<T> = {
    [K in keyof T]: T[K];
} & {};
type InferField<T, N extends string> = T extends {
    [K in N]?: infer U | null;
} ? U : never;
type IsNullable<T> = null extends T ? true : undefined extends T ? true : false;
type CapitalizeFirst<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
type InferModelShape<Model> = Simplify<InferField<Model, 'scalars'> & InferComposites<InferField<Model, 'composites'>>>;
type InferRelations<Model> = {
    [K in keyof Model]: {
        Shape: Model[K] extends any[] ? InferModelShape<Model[K][0]>[] : InferModelShape<Model[K]>;
        Name: InferField<InferItemOfArray<Model[K]>, 'name'>;
        Nullable: IsNullable<Model[K]>;
    };
};
type InferRelationList<Model> = {
    [K in keyof Model as Model[K] extends any[] ? K : never]: K;
};
type MakeNullable<T, IsNullable extends boolean> = IsNullable extends true ? T | null : T;
type InferItemOfArray<T> = T extends Array<infer U> ? U : T;
type InferComposites<Model> = {
    [K in keyof Model]: Model[K] extends any[] ? Simplify<InferField<Model[K][0], 'scalars'> & InferComposites<InferField<Model[K][0], 'composites'>>>[] : 'composites' extends keyof Exclude<Model[K], null> ? MakeNullable<Simplify<InferField<Model[K], 'scalars'> & InferComposites<InferField<Model[K], 'composites'>>>, IsNullable<Model[K]>> : InferField<Model[K], 'scalars'>;
};
type ExtractModelKeys<T> = {
    [K in keyof T]: K extends `$${string}` ? never : K;
}[keyof T];
type PrismaArgs<T, F extends string> = T extends {
    [K: symbol]: {
        types: {
            operations: {
                [K in F]: {
                    args: unknown;
                };
            };
        };
    };
} ? T[symbol]['types']['operations'][F]['args'] : unknown;
type PrismaPayload<T> = T extends {
    [K: symbol]: {
        types: {
            payload: unknown;
        };
    };
} ? T[symbol]['types']['payload'] : unknown;
/**
 * Infer PrismaTypes from a PrismaClient
 * @example
 * `type PrismaTypes = PrismaTypesFromClient<typeof prisma>`
 **/
export type PrismaTypesFromClient<ClientType, PrismaUtils extends boolean = false> = {
    [K in ExtractModelKeys<ClientType> as CapitalizeFirst<K & string>]: PrismaModelTypes & {
        Name: CapitalizeFirst<K & string>;
        Shape: InferModelShape<PrismaPayload<ClientType[K]>>;
        Include: InferField<PrismaArgs<ClientType[K], 'findUnique'>, 'include'>;
        Select: InferField<PrismaArgs<ClientType[K], 'findUnique'>, 'select'>;
        OrderBy: InferItemOfArray<InferField<PrismaArgs<ClientType[K], 'findFirst'>, 'orderBy'>>;
        WhereUnique: InferField<PrismaArgs<ClientType[K], 'findUnique'>, 'where'>;
        Where: InferField<PrismaArgs<ClientType[K], 'findFirst'>, 'where'>;
        ListRelations: keyof InferRelationList<InferField<PrismaPayload<ClientType[K]>, 'objects'>>;
        RelationName: keyof InferField<PrismaPayload<ClientType[K]>, 'objects'>;
        Relations: InferRelations<InferField<PrismaPayload<ClientType[K]>, 'objects'>>;
        Create: PrismaUtils extends true ? InferField<PrismaArgs<ClientType[K], 'create'>, 'data'> : {};
        Update: PrismaUtils extends true ? InferField<PrismaArgs<ClientType[K], 'update'>, 'data'> : {};
    };
};
interface DMMFField {
    type: string;
    kind: string;
    name: string;
    isRequired: boolean;
    isList: boolean;
    hasDefaultValue: boolean;
    isUnique: boolean;
    isId: boolean;
    documentation?: string;
    relationName?: string;
    relationFromFields?: readonly string[];
    isUpdatedAt?: boolean;
}
export interface PothosPrismaDatamodel {
    datamodel: {
        models: Record<string, {
            fields: readonly DMMFField[];
            primaryKey: {
                name: string | null;
                fields: readonly string[];
            } | null;
            uniqueIndexes: {
                name: string | null;
                fields: readonly string[];
            }[];
            documentation?: string;
        }>;
    };
}
export {};
//# sourceMappingURL=types.d.ts.map