@pkgverse/prismock 2.0.0-beta.1

package/dist/lib/client.d.ts

@@ -0,0 +1,19 @@
+import { type PrismaClient } from '@prisma/client';
+import * as runtime from '@prisma/client/runtime/library';
+import { Delegate } from './delegate';
+import { Data } from './prismock';
+type GetData = () => Data;
+type SetData = (data: Data) => void;
+interface PrismockData {
+    getData: GetData;
+    setData: SetData;
+    reset: () => void;
+}
+export type PrismockClientType<T = PrismaClient> = T & PrismockData;
+export declare function generateClient<T = PrismaClient>(delegates: Record<string, Delegate>, getData: GetData, setData: SetData): PrismockClientType<T>;
+type PrismaModule = {
+    dmmf: runtime.BaseDMMF;
+};
+export declare function createPrismock(instance: PrismaModule): typeof PrismaClient & PrismockData;
+export declare const PrismockClient: typeof PrismaClient & PrismockData;
+export {};

package/dist/lib/delegate.d.ts

@@ -0,0 +1,42 @@
+import { DMMF } from '@prisma/generator-helper';
+import { CreateArgs, CreateManyArgs, FindArgs, GroupByArgs, UpsertArgs } from './types';
+import { DeleteArgs, UpdateArgs } from './operations';
+import { Data, Delegates, Properties } from './prismock';
+export type Item = Record<string, unknown>;
+export type Delegate = {
+    create: (args: CreateArgs) => Promise<Item>;
+    createMany: (args: CreateManyArgs) => Promise<{
+        count: number;
+    }>;
+    delete: (args: DeleteArgs) => Promise<Item | null>;
+    deleteMany: (args: DeleteArgs) => Promise<{
+        count: number;
+    }>;
+    update: (args: UpdateArgs) => Promise<Item | null>;
+    updateMany: (args: UpdateArgs) => Promise<{
+        count: number;
+    }>;
+    upsert: (args: UpsertArgs) => Promise<Item>;
+    findMany: (args?: FindArgs) => Promise<Item[]>;
+    findUnique: (args: FindArgs) => Promise<Item>;
+    findFirst: (args: FindArgs) => Promise<Item>;
+    findUniqueOrThrow: (args: FindArgs) => Promise<Item>;
+    findFirstOrThrow: (args: FindArgs) => Promise<Item>;
+    groupBy: (args: GroupByArgs) => Promise<any[]>;
+    count: (args: FindArgs) => Promise<number>;
+    model: DMMF.Model;
+    getProperties: () => DelegateProperties;
+    getItems: () => Item[];
+    onChange: (items: Item[]) => void;
+};
+export type DelegateProperties = {
+    increment: Record<string, number>;
+};
+export type DelegateContext = {
+    models: DMMF.Model[];
+    model: DMMF.Model;
+    name: string;
+    data: Data;
+    properties: Record<string, DelegateProperties>;
+};
+export declare function generateDelegate(model: DMMF.Model, data: Data, name: string, properties: Properties, delegates: Delegates, onChange: (items: Item[]) => void): Delegate;

package/dist/lib/extensions/index.d.ts

@@ -0,0 +1,8 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { applyModelExtensions } from './model';
+import { applyQueryExtensions } from './query';
+import { applyResultExtensions } from './result';
+import type { ExtendsHook, DefaultArgs } from '@prisma/client/runtime/library';
+export { applyModelExtensions, applyQueryExtensions, applyResultExtensions };
+export type ExtensionsDefinition = Parameters<ExtendsHook<"define", Prisma.TypeMapCb, DefaultArgs>>[0];
+export declare function applyExtensions(client: PrismaClient, extensions: ExtensionsDefinition): PrismaClient<Prisma.PrismaClientOptions, never, DefaultArgs>;

package/dist/lib/extensions/model.d.ts

@@ -0,0 +1,5 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import type { DefaultArgs, ExtendsHook } from '@prisma/client/runtime/library';
+type ExtensionsDefinition = Parameters<ExtendsHook<'define', Prisma.TypeMapCb, DefaultArgs>>[0];
+export declare function applyModelExtensions(client: PrismaClient, extensions: ExtensionsDefinition): PrismaClient;
+export {};

package/dist/lib/extensions/query.d.ts

@@ -0,0 +1,4 @@
+import type { Prisma } from "@prisma/client";
+import type { ExtendsHook, DefaultArgs } from "@prisma/client/runtime/library";
+import type { PrismaClient } from "@prisma/client";
+export declare function applyQueryExtensions(client: PrismaClient, extensions: Parameters<ExtendsHook<"define", Prisma.TypeMapCb, DefaultArgs>>[0]): PrismaClient;

package/dist/lib/extensions/result.d.ts

@@ -0,0 +1,3 @@
+import { Prisma, PrismaClient } from "@prisma/client";
+import { type DefaultArgs, type ExtendsHook } from "@prisma/client/runtime/library";
+export declare function applyResultExtensions(client: PrismaClient, extensions: Parameters<ExtendsHook<"define", Prisma.TypeMapCb, DefaultArgs>>[0]): PrismaClient;

package/dist/lib/helpers.d.ts

@@ -0,0 +1,11 @@
+import { Item } from './delegate';
+export declare function camelize(str: string): string;
+export declare function shallowCompare(a: Item, b: Item): boolean;
+export declare function pick(obj: Record<string, unknown>, keys: string[]): {};
+export declare function omit(obj: Record<string, unknown>, keys: string[]): {};
+export declare function uuid(): string;
+export declare function removeUndefined(o?: Record<string, unknown>): Item | undefined;
+export declare function pipe<T>(...functions: Array<(arg: T) => T>): (value: T) => T;
+export declare function compose<T>(...functions: Array<(arg: T) => T>): (value: T) => T;
+export declare function unique<T>(value: T[]): T[];
+export declare function ensureArray<T>(value: T | T[]): T[];

package/dist/lib/operations/aggregate.d.ts

@@ -0,0 +1,11 @@
+import { Item } from '../delegate';
+import { AggregateArgs } from '../types';
+type AggregateResult = {
+    _avg?: Record<string, number>;
+    _count?: number | Record<string, number>;
+    _max?: Record<string, number>;
+    _min?: Record<string, number>;
+    _sum?: Record<string, number>;
+};
+export declare function aggregate(args: AggregateArgs, items: Item[]): AggregateResult;
+export {};

package/dist/lib/operations/create.d.ts

@@ -0,0 +1,34 @@
+import { DMMF } from '@prisma/generator-helper';
+import { Delegate, DelegateProperties, Item } from '../delegate';
+import { Delegates } from '../prismock';
+import { CreateArgs } from '../types';
+export declare const isAutoIncrement: (field: import("@prisma/generator-helper").ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    type: string;
+    dbName?: string | null | undefined;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
+        name: string;
+        args: any[];
+    }> | DMMF.FieldDefaultScalar | undefined;
+    relationFromFields?: string[] | undefined;
+    relationToFields?: string[] | undefined;
+    relationOnDelete?: string | undefined;
+    relationName?: string | undefined;
+    documentation?: string | undefined;
+}>) => boolean;
+export declare function calculateDefaultFieldValue(field: DMMF.Field, properties: DelegateProperties): unknown;
+export declare function createDefaultValues(fields: DMMF.Field[], properties: DelegateProperties): Record<string, unknown>;
+export declare function connectOrCreate(delegate: Delegate, delegates: Delegates): (item: Item) => Item;
+export declare function nestedCreate(current: Delegate, delegates: Delegates): (item: Item) => {
+    [x: string]: unknown;
+};
+export declare function create(item: Item, options: Omit<CreateArgs, 'data'>, delegate: Delegate, delegates: Delegates, onChange: (items: Item[]) => void): Item;

package/dist/lib/operations/delete.d.ts

@@ -0,0 +1,13 @@
+import { Delegates } from '../prismock';
+import { Item, Delegate } from '../delegate';
+import { FindWhereArgs, SelectArgs } from '../types';
+export type DeleteArgs = {
+    select?: SelectArgs | null;
+    include?: Record<string, boolean> | null;
+    where?: FindWhereArgs;
+};
+export type DeletionMap = {
+    toDelete: Item[];
+    withoutDeleted: Item[];
+};
+export declare function deleteMany(args: DeleteArgs, current: Delegate, delegates: Delegates, onChange: (items: Item[]) => void): Item[];

package/dist/lib/operations/find/find.d.ts

@@ -0,0 +1,155 @@
+import { DMMF } from '@prisma/generator-helper';
+import { FindArgs, GroupByFieldArg, Order, OrderedValue } from '../../types';
+import { Delegate, DelegateProperties, Item } from '../../delegate';
+import { Delegates } from '../../prismock';
+export declare function findNextIncrement(properties: DelegateProperties, fieldName: string): number;
+export declare function findOne(args: FindArgs, current: Delegate, delegates: Delegates): Item | null;
+export declare function where(whereArgs: FindArgs['where'], current: Delegate, delegates: Delegates): (item: Record<string, unknown>) => boolean;
+export declare function calculateOrder(a: Item, b: Item, orderedProperties: Record<string, OrderedValue>, current: Delegate, delegates: Delegates): number;
+export declare function calculateRelationOrder(a: Item, b: Item, orderedProperty: string, sortOrder: Order, current: Delegate, delegates: Delegates): number;
+export declare function order(args: FindArgs, delegate: Delegate, delegates: Delegates): (items: Item[]) => Item[];
+export declare function paginate(skip?: number, take?: number): (items: Item[]) => Item[];
+export declare function includes(args: FindArgs, current: Delegate, delegates: Delegates): (item: Item) => Item;
+export declare function select(selectArgs: FindArgs['select']): (item: Item) => Item;
+export declare const getJoinField: (field: import("@prisma/generator-helper").ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    type: string;
+    dbName?: string | null | undefined;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
+        name: string;
+        args: any[];
+    }> | DMMF.FieldDefaultScalar | undefined;
+    relationFromFields?: string[] | undefined;
+    relationToFields?: string[] | undefined;
+    relationOnDelete?: string | undefined;
+    relationName?: string | undefined;
+    documentation?: string | undefined;
+}>, delegates: Delegates) => import("@prisma/generator-helper").ReadonlyDeep<import("@prisma/generator-helper").ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    type: string;
+    dbName?: string | null | undefined;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
+        name: string;
+        args: any[];
+    }> | DMMF.FieldDefaultScalar | undefined;
+    relationFromFields?: string[] | undefined;
+    relationToFields?: string[] | undefined;
+    relationOnDelete?: string | undefined;
+    relationName?: string | undefined;
+    documentation?: string | undefined;
+}>> | undefined;
+export declare const getDelegateFromField: (field: import("@prisma/generator-helper").ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    type: string;
+    dbName?: string | null | undefined;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
+        name: string;
+        args: any[];
+    }> | DMMF.FieldDefaultScalar | undefined;
+    relationFromFields?: string[] | undefined;
+    relationToFields?: string[] | undefined;
+    relationOnDelete?: string | undefined;
+    relationName?: string | undefined;
+    documentation?: string | undefined;
+}>, delegates: Delegates) => Delegate;
+export declare const getFieldRelationshipWhere: (item: Item, field: import("@prisma/generator-helper").ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    type: string;
+    dbName?: string | null | undefined;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
+        name: string;
+        args: any[];
+    }> | DMMF.FieldDefaultScalar | undefined;
+    relationFromFields?: string[] | undefined;
+    relationToFields?: string[] | undefined;
+    relationOnDelete?: string | undefined;
+    relationName?: string | undefined;
+    documentation?: string | undefined;
+}>, delegates: Delegates) => Record<string, GroupByFieldArg>;
+export declare const getFieldFromRelationshipWhere: (item: Item, field: import("@prisma/generator-helper").ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    type: string;
+    dbName?: string | null | undefined;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
+        name: string;
+        args: any[];
+    }> | DMMF.FieldDefaultScalar | undefined;
+    relationFromFields?: string[] | undefined;
+    relationToFields?: string[] | undefined;
+    relationOnDelete?: string | undefined;
+    relationName?: string | undefined;
+    documentation?: string | undefined;
+}>) => {
+    [x: string]: GroupByFieldArg;
+};
+export declare const getFieldToRelationshipWhere: (item: Item, field: import("@prisma/generator-helper").ReadonlyDeep<{
+    kind: DMMF.FieldKind;
+    name: string;
+    isRequired: boolean;
+    isList: boolean;
+    isUnique: boolean;
+    isId: boolean;
+    isReadOnly: boolean;
+    isGenerated?: boolean | undefined;
+    isUpdatedAt?: boolean | undefined;
+    type: string;
+    dbName?: string | null | undefined;
+    hasDefaultValue: boolean;
+    default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
+        name: string;
+        args: any[];
+    }> | DMMF.FieldDefaultScalar | undefined;
+    relationFromFields?: string[] | undefined;
+    relationToFields?: string[] | undefined;
+    relationOnDelete?: string | undefined;
+    relationName?: string | undefined;
+    documentation?: string | undefined;
+}>) => {
+    [x: string]: GroupByFieldArg;
+};
+export declare function findMany(args: FindArgs, current: Delegate, delegates: Delegates): Item[];

package/dist/lib/operations/find/index.d.ts

@@ -0,0 +1 @@
+export * from './find';

package/dist/lib/operations/find/match.d.ts

@@ -0,0 +1,4 @@
+import { Delegate, Item } from '../../delegate';
+import { Delegates } from '../../prismock';
+import { FindWhereArgs } from '../../types';
+export declare const matchMultiple: (item: Item, where: FindWhereArgs, current: Delegate, delegates: Delegates) => boolean;

package/dist/lib/operations/groupBy/groupBy.d.ts

@@ -0,0 +1,10 @@
+import { Delegate } from '../../delegate';
+import { Delegates } from '../../prismock';
+import { GroupByArgs } from '../../types';
+export declare function groupBy(args: GroupByArgs, current: Delegate, delegates: Delegates): {
+    _avg?: Record<string, number> | undefined;
+    _count?: number | Record<string, number> | undefined;
+    _max?: Record<string, number> | undefined;
+    _min?: Record<string, number> | undefined;
+    _sum?: Record<string, number> | undefined;
+}[];

package/dist/lib/operations/groupBy/index.d.ts

@@ -0,0 +1 @@
+export * from './groupBy';

package/dist/lib/operations/index.d.ts

@@ -0,0 +1,6 @@
+export * from './aggregate';
+export * from './find';
+export * from './groupBy';
+export * from './create';
+export * from './delete';
+export * from './update';

package/dist/lib/operations/update.d.ts

@@ -0,0 +1,14 @@
+import { Delegate, Item } from '../delegate';
+import { Delegates } from '../prismock';
+import { FindWhereArgs, SelectArgs } from '../types';
+export type UpdateArgs = {
+    select?: SelectArgs | null;
+    include?: Record<string, boolean> | null;
+    data: Item;
+    where: FindWhereArgs;
+};
+export type UpdateMap = {
+    toUpdate: Item[];
+    updated: Item[];
+};
+export declare function updateMany(args: UpdateArgs, current: Delegate, delegates: Delegates, onChange: (items: Item[]) => void): Item[];

package/dist/lib/prismock.d.ts

@@ -0,0 +1,290 @@
+import { PrismaClient } from '@prisma/client';
+import { DMMF } from '@prisma/generator-helper';
+import { Generator } from '@prisma/internals/dist/Generator';
+import { Delegate, DelegateProperties, Item } from './delegate';
+import { PrismockClientType } from './client';
+type Options = {
+    schemaPath?: string;
+};
+type OptionsSync = {
+    models: DMMF.Model[];
+};
+export type Data = Record<string, Item[]>;
+export type Properties = Record<string, DelegateProperties>;
+export type Delegates = Record<string, Delegate>;
+export declare function generateDMMF(schemaPath?: string): Promise<import("@prisma/generator-helper").ReadonlyDeep<{
+    datamodel: import("@prisma/generator-helper").ReadonlyDeep<{
+        models: import("@prisma/generator-helper").ReadonlyDeep<{
+            name: string;
+            dbName: string | null;
+            fields: import("@prisma/generator-helper").ReadonlyDeep<{
+                kind: DMMF.FieldKind;
+                name: string;
+                isRequired: boolean;
+                isList: boolean;
+                isUnique: boolean;
+                isId: boolean;
+                isReadOnly: boolean;
+                isGenerated?: boolean | undefined;
+                isUpdatedAt?: boolean | undefined;
+                type: string;
+                dbName?: string | null | undefined;
+                hasDefaultValue: boolean;
+                default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
+                    name: string;
+                    args: any[];
+                }> | DMMF.FieldDefaultScalar | undefined;
+                relationFromFields?: string[] | undefined;
+                relationToFields?: string[] | undefined;
+                relationOnDelete?: string | undefined;
+                relationName?: string | undefined;
+                documentation?: string | undefined;
+            }>[];
+            uniqueFields: string[][];
+            uniqueIndexes: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                fields: string[];
+            }>[];
+            documentation?: string | undefined;
+            primaryKey: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string | null;
+                fields: string[];
+            }> | null;
+            isGenerated?: boolean | undefined;
+        }>[];
+        enums: import("@prisma/generator-helper").ReadonlyDeep<{
+            name: string;
+            values: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                dbName: string | null;
+            }>[];
+            dbName?: string | null | undefined;
+            documentation?: string | undefined;
+        }>[];
+        types: import("@prisma/generator-helper").ReadonlyDeep<{
+            name: string;
+            dbName: string | null;
+            fields: import("@prisma/generator-helper").ReadonlyDeep<{
+                kind: DMMF.FieldKind;
+                name: string;
+                isRequired: boolean;
+                isList: boolean;
+                isUnique: boolean;
+                isId: boolean;
+                isReadOnly: boolean;
+                isGenerated?: boolean | undefined;
+                isUpdatedAt?: boolean | undefined;
+                type: string;
+                dbName?: string | null | undefined;
+                hasDefaultValue: boolean;
+                default?: DMMF.FieldDefaultScalar[] | import("@prisma/generator-helper").ReadonlyDeep<{
+                    name: string;
+                    args: any[];
+                }> | DMMF.FieldDefaultScalar | undefined;
+                relationFromFields?: string[] | undefined;
+                relationToFields?: string[] | undefined;
+                relationOnDelete?: string | undefined;
+                relationName?: string | undefined;
+                documentation?: string | undefined;
+            }>[];
+            uniqueFields: string[][];
+            uniqueIndexes: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                fields: string[];
+            }>[];
+            documentation?: string | undefined;
+            primaryKey: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string | null;
+                fields: string[];
+            }> | null;
+            isGenerated?: boolean | undefined;
+        }>[];
+        indexes: import("@prisma/generator-helper").ReadonlyDeep<{
+            model: string;
+            type: DMMF.IndexType;
+            isDefinedOnField: boolean;
+            name?: string | undefined;
+            dbName?: string | undefined;
+            algorithm?: string | undefined;
+            clustered?: boolean | undefined;
+            fields: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                sortOrder?: DMMF.SortOrder | undefined;
+                length?: number | undefined;
+                operatorClass?: string | undefined;
+            }>[];
+        }>[];
+    }>;
+    schema: import("@prisma/generator-helper").ReadonlyDeep<{
+        rootQueryType?: string | undefined;
+        rootMutationType?: string | undefined;
+        inputObjectTypes: {
+            model?: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                constraints: {
+                    maxNumFields: number | null;
+                    minNumFields: number | null;
+                    fields?: string[] | undefined;
+                };
+                meta?: {
+                    source?: string | undefined;
+                } | undefined;
+                fields: import("@prisma/generator-helper").ReadonlyDeep<{
+                    name: string;
+                    comment?: string | undefined;
+                    isNullable: boolean;
+                    isRequired: boolean;
+                    inputTypes: DMMF.InputTypeRef[];
+                    deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
+                        sinceVersion: string;
+                        reason: string;
+                        plannedRemovalVersion?: string | undefined;
+                    }> | undefined;
+                }>[];
+            }>[] | undefined;
+            prisma: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                constraints: {
+                    maxNumFields: number | null;
+                    minNumFields: number | null;
+                    fields?: string[] | undefined;
+                };
+                meta?: {
+                    source?: string | undefined;
+                } | undefined;
+                fields: import("@prisma/generator-helper").ReadonlyDeep<{
+                    name: string;
+                    comment?: string | undefined;
+                    isNullable: boolean;
+                    isRequired: boolean;
+                    inputTypes: DMMF.InputTypeRef[];
+                    deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
+                        sinceVersion: string;
+                        reason: string;
+                        plannedRemovalVersion?: string | undefined;
+                    }> | undefined;
+                }>[];
+            }>[];
+        };
+        outputObjectTypes: {
+            model: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                fields: import("@prisma/generator-helper").ReadonlyDeep<{
+                    name: string;
+                    isNullable?: boolean | undefined;
+                    outputType: DMMF.OutputTypeRef;
+                    args: import("@prisma/generator-helper").ReadonlyDeep<{
+                        name: string;
+                        comment?: string | undefined;
+                        isNullable: boolean;
+                        isRequired: boolean;
+                        inputTypes: DMMF.InputTypeRef[];
+                        deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
+                            sinceVersion: string;
+                            reason: string;
+                            plannedRemovalVersion?: string | undefined;
+                        }> | undefined;
+                    }>[];
+                    deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
+                        sinceVersion: string;
+                        reason: string;
+                        plannedRemovalVersion?: string | undefined;
+                    }> | undefined;
+                    documentation?: string | undefined;
+                }>[];
+            }>[];
+            prisma: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                fields: import("@prisma/generator-helper").ReadonlyDeep<{
+                    name: string;
+                    isNullable?: boolean | undefined;
+                    outputType: DMMF.OutputTypeRef;
+                    args: import("@prisma/generator-helper").ReadonlyDeep<{
+                        name: string;
+                        comment?: string | undefined;
+                        isNullable: boolean;
+                        isRequired: boolean;
+                        inputTypes: DMMF.InputTypeRef[];
+                        deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
+                            sinceVersion: string;
+                            reason: string;
+                            plannedRemovalVersion?: string | undefined;
+                        }> | undefined;
+                    }>[];
+                    deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
+                        sinceVersion: string;
+                        reason: string;
+                        plannedRemovalVersion?: string | undefined;
+                    }> | undefined;
+                    documentation?: string | undefined;
+                }>[];
+            }>[];
+        };
+        enumTypes: {
+            model?: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                values: string[];
+            }>[] | undefined;
+            prisma: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                values: string[];
+            }>[];
+        };
+        fieldRefTypes: {
+            prisma?: import("@prisma/generator-helper").ReadonlyDeep<{
+                name: string;
+                allowTypes: DMMF.FieldRefAllowType[];
+                fields: import("@prisma/generator-helper").ReadonlyDeep<{
+                    name: string;
+                    comment?: string | undefined;
+                    isNullable: boolean;
+                    isRequired: boolean;
+                    inputTypes: DMMF.InputTypeRef[];
+                    deprecation?: import("@prisma/generator-helper").ReadonlyDeep<{
+                        sinceVersion: string;
+                        reason: string;
+                        plannedRemovalVersion?: string | undefined;
+                    }> | undefined;
+                }>[];
+            }>[] | undefined;
+        };
+    }>;
+    mappings: import("@prisma/generator-helper").ReadonlyDeep<{
+        modelOperations: import("@prisma/generator-helper").ReadonlyDeep<{
+            model: string;
+            plural: string;
+            findUnique?: string | null | undefined;
+            findUniqueOrThrow?: string | null | undefined;
+            findFirst?: string | null | undefined;
+            findFirstOrThrow?: string | null | undefined;
+            findMany?: string | null | undefined;
+            create?: string | null | undefined;
+            createMany?: string | null | undefined;
+            createManyAndReturn?: string | null | undefined;
+            update?: string | null | undefined;
+            updateMany?: string | null | undefined;
+            upsert?: string | null | undefined;
+            delete?: string | null | undefined;
+            deleteMany?: string | null | undefined;
+            aggregate?: string | null | undefined;
+            groupBy?: string | null | undefined;
+            count?: string | null | undefined;
+            findRaw?: string | null | undefined;
+            aggregateRaw?: string | null | undefined;
+        }>[];
+        otherOperations: {
+            read: string[];
+            write: string[];
+        };
+    }>;
+}>>;
+export declare function fetchGenerator(schemaPath?: string): Promise<Generator>;
+export declare function getProvider(generator: Generator): import("@prisma/generator-helper").ActiveConnectorType | undefined;
+export declare function generatePrismock<T = PrismaClient>(options?: Options): Promise<PrismockClientType<T>>;
+export declare function generatePrismockSync<T = PrismockClientType>(options: OptionsSync): PrismockClientType<T>;
+export declare function generateDelegates(options: OptionsSync): {
+    delegates: Delegates;
+    getData: () => Data;
+    setData: (d: Data) => void;
+};
+export {};