@naisys/erp 3.0.0-beta.3

package/dist/generated/prisma/internal/prismaNamespace.d.ts

@@ -0,0 +1,2722 @@
+import * as runtime from "@prisma/client/runtime/client";
+import type * as Prisma from "../models.js";
+import { type PrismaClient } from "./class.js";
+export type * from '../models.js';
+export type DMMF = typeof runtime.DMMF;
+export type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T>;
+/**
+ * Prisma Errors
+ */
+export declare const PrismaClientKnownRequestError: typeof runtime.PrismaClientKnownRequestError;
+export type PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError;
+export declare const PrismaClientUnknownRequestError: typeof runtime.PrismaClientUnknownRequestError;
+export type PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError;
+export declare const PrismaClientRustPanicError: typeof runtime.PrismaClientRustPanicError;
+export type PrismaClientRustPanicError = runtime.PrismaClientRustPanicError;
+export declare const PrismaClientInitializationError: typeof runtime.PrismaClientInitializationError;
+export type PrismaClientInitializationError = runtime.PrismaClientInitializationError;
+export declare const PrismaClientValidationError: typeof runtime.PrismaClientValidationError;
+export type PrismaClientValidationError = runtime.PrismaClientValidationError;
+/**
+ * Re-export of sql-template-tag
+ */
+export declare const sql: typeof runtime.sqltag;
+export declare const empty: runtime.Sql;
+export declare const join: typeof runtime.join;
+export declare const raw: typeof runtime.raw;
+export declare const Sql: typeof runtime.Sql;
+export type Sql = runtime.Sql;
+/**
+ * Decimal.js
+ */
+export declare const Decimal: typeof runtime.Decimal;
+export type Decimal = runtime.Decimal;
+export type DecimalJsLike = runtime.DecimalJsLike;
+/**
+* Extensions
+*/
+export type Extension = runtime.Types.Extensions.UserArgs;
+export declare const getExtensionContext: typeof runtime.Extensions.getExtensionContext;
+export type Args<T, F extends runtime.Operation> = runtime.Types.Public.Args<T, F>;
+export type Payload<T, F extends runtime.Operation = never> = runtime.Types.Public.Payload<T, F>;
+export type Result<T, A, F extends runtime.Operation> = runtime.Types.Public.Result<T, A, F>;
+export type Exact<A, W> = runtime.Types.Public.Exact<A, W>;
+export type PrismaVersion = {
+    client: string;
+    engine: string;
+};
+/**
+ * Prisma Client JS version: 7.5.0
+ * Query Engine version: 280c870be64f457428992c43c1f6d557fab6e29e
+ */
+export declare const prismaVersion: PrismaVersion;
+/**
+ * Utility Types
+ */
+export type Bytes = runtime.Bytes;
+export type JsonObject = runtime.JsonObject;
+export type JsonArray = runtime.JsonArray;
+export type JsonValue = runtime.JsonValue;
+export type InputJsonObject = runtime.InputJsonObject;
+export type InputJsonArray = runtime.InputJsonArray;
+export type InputJsonValue = runtime.InputJsonValue;
+export declare const NullTypes: {
+    DbNull: (new (secret: never) => typeof runtime.DbNull);
+    JsonNull: (new (secret: never) => typeof runtime.JsonNull);
+    AnyNull: (new (secret: never) => typeof runtime.AnyNull);
+};
+/**
+ * Helper for filtering JSON entries that have `null` on the database (empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export declare const DbNull: runtime.DbNullClass;
+/**
+ * Helper for filtering JSON entries that have JSON `null` values (not empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export declare const JsonNull: runtime.JsonNullClass;
+/**
+ * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull`
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export declare const AnyNull: runtime.AnyNullClass;
+type SelectAndInclude = {
+    select: any;
+    include: any;
+};
+type SelectAndOmit = {
+    select: any;
+    omit: any;
+};
+/**
+ * From T, pick a set of properties whose keys are in the union K
+ */
+type Prisma__Pick<T, K extends keyof T> = {
+    [P in K]: T[P];
+};
+export type Enumerable<T> = T | Array<T>;
+/**
+ * Subset
+ * @desc From `T` pick properties that exist in `U`. Simple version of Intersection
+ */
+export type Subset<T, U> = {
+    [key in keyof T]: key extends keyof U ? T[key] : never;
+};
+/**
+ * SelectSubset
+ * @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
+ * Additionally, it validates, if both select and include are present. If the case, it errors.
+ */
+export type SelectSubset<T, U> = {
+    [key in keyof T]: key extends keyof U ? T[key] : never;
+} & (T extends SelectAndInclude ? 'Please either choose `select` or `include`.' : T extends SelectAndOmit ? 'Please either choose `select` or `omit`.' : {});
+/**
+ * Subset + Intersection
+ * @desc From `T` pick properties that exist in `U` and intersect `K`
+ */
+export type SubsetIntersection<T, U, K> = {
+    [key in keyof T]: key extends keyof U ? T[key] : never;
+} & K;
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+/**
+ * XOR is needed to have a real mutually exclusive union type
+ * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
+ */
+export type XOR<T, U> = T extends object ? U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : U : T;
+/**
+ * Is T a Record?
+ */
+type IsObject<T extends any> = T extends Array<any> ? False : T extends Date ? False : T extends Uint8Array ? False : T extends BigInt ? False : T extends object ? True : False;
+/**
+ * If it's T[], return T
+ */
+export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T;
+/**
+ * From ts-toolbelt
+ */
+type __Either<O extends object, K extends Key> = Omit<O, K> & {
+    [P in K]: Prisma__Pick<O, P & keyof O>;
+}[K];
+type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>;
+type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>;
+type _Either<O extends object, K extends Key, strict extends Boolean> = {
+    1: EitherStrict<O, K>;
+    0: EitherLoose<O, K>;
+}[strict];
+export type Either<O extends object, K extends Key, strict extends Boolean = 1> = O extends unknown ? _Either<O, K, strict> : never;
+export type Union = any;
+export type PatchUndefined<O extends object, O1 extends object> = {
+    [K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K];
+} & {};
+/** Helper Types for "Merge" **/
+export type IntersectOf<U extends Union> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type Overwrite<O extends object, O1 extends object> = {
+    [K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
+} & {};
+type _Merge<U extends object> = IntersectOf<Overwrite<U, {
+    [K in keyof U]-?: At<U, K>;
+}>>;
+type Key = string | number | symbol;
+type AtStrict<O extends object, K extends Key> = O[K & keyof O];
+type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
+export type At<O extends object, K extends Key, strict extends Boolean = 1> = {
+    1: AtStrict<O, K>;
+    0: AtLoose<O, K>;
+}[strict];
+export type ComputeRaw<A extends any> = A extends Function ? A : {
+    [K in keyof A]: A[K];
+} & {};
+export type OptionalFlat<O> = {
+    [K in keyof O]?: O[K];
+} & {};
+type _Record<K extends keyof any, T> = {
+    [P in K]: T;
+};
+type NoExpand<T> = T extends unknown ? T : never;
+export type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ? (K extends keyof O ? {
+    [P in K]: O[P];
+} & O : O) | {
+    [P in keyof O as P extends K ? P : never]-?: O[P];
+} & O : never>;
+type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;
+export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
+/** End Helper Types for "Merge" **/
+export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
+export type Boolean = True | False;
+export type True = 1;
+export type False = 0;
+export type Not<B extends Boolean> = {
+    0: 1;
+    1: 0;
+}[B];
+export type Extends<A1 extends any, A2 extends any> = [A1] extends [never] ? 0 : A1 extends A2 ? 1 : 0;
+export type Has<U extends Union, U1 extends Union> = Not<Extends<Exclude<U1, U>, U1>>;
+export type Or<B1 extends Boolean, B2 extends Boolean> = {
+    0: {
+        0: 0;
+        1: 1;
+    };
+    1: {
+        0: 1;
+        1: 1;
+    };
+}[B1][B2];
+export type Keys<U extends Union> = U extends unknown ? keyof U : never;
+export type GetScalarType<T, O> = O extends object ? {
+    [P in keyof T]: P extends keyof O ? O[P] : never;
+} : never;
+type FieldPaths<T, U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>> = IsObject<T> extends True ? U : T;
+export type GetHavingFields<T> = {
+    [K in keyof T]: Or<Or<Extends<'OR', K>, Extends<'AND', K>>, Extends<'NOT', K>> extends True ? T[K] extends infer TK ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never> : never : {} extends FieldPaths<T[K]> ? never : K;
+}[keyof T];
+/**
+ * Convert tuple to union
+ */
+type _TupleToUnion<T> = T extends (infer E)[] ? E : never;
+type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>;
+export type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T;
+/**
+ * Like `Pick`, but additionally can also accept an array of keys
+ */
+export type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>;
+/**
+ * Exclude all keys with underscores
+ */
+export type ExcludeUnderscoreKeys<T extends string> = T extends `_${string}` ? never : T;
+export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>;
+type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>;
+export declare const ModelName: {
+    readonly Order: "Order";
+    readonly OrderRevision: "OrderRevision";
+    readonly Operation: "Operation";
+    readonly OperationFieldRef: "OperationFieldRef";
+    readonly OperationDependency: "OperationDependency";
+    readonly WorkCenter: "WorkCenter";
+    readonly WorkCenterUser: "WorkCenterUser";
+    readonly FieldSet: "FieldSet";
+    readonly FieldRecord: "FieldRecord";
+    readonly Field: "Field";
+    readonly Step: "Step";
+    readonly OrderRun: "OrderRun";
+    readonly OperationRun: "OperationRun";
+    readonly StepRun: "StepRun";
+    readonly FieldValue: "FieldValue";
+    readonly Item: "Item";
+    readonly ItemInstance: "ItemInstance";
+    readonly User: "User";
+    readonly UserPermission: "UserPermission";
+    readonly Session: "Session";
+    readonly SchemaVersion: "SchemaVersion";
+    readonly LaborTicket: "LaborTicket";
+    readonly AuditLog: "AuditLog";
+    readonly Attachment: "Attachment";
+    readonly FieldAttachment: "FieldAttachment";
+    readonly OperationRunComment: "OperationRunComment";
+};
+export type ModelName = (typeof ModelName)[keyof typeof ModelName];
+export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.Fn<{
+    extArgs: runtime.Types.Extensions.InternalArgs;
+}, runtime.Types.Utils.Record<string, any>> {
+    returns: TypeMap<this['params']['extArgs'], GlobalOmitOptions>;
+}
+export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
+    globalOmitOptions: {
+        omit: GlobalOmitOptions;
+    };
+    meta: {
+        modelProps: "order" | "orderRevision" | "operation" | "operationFieldRef" | "operationDependency" | "workCenter" | "workCenterUser" | "fieldSet" | "fieldRecord" | "field" | "step" | "orderRun" | "operationRun" | "stepRun" | "fieldValue" | "item" | "itemInstance" | "user" | "userPermission" | "session" | "schemaVersion" | "laborTicket" | "auditLog" | "attachment" | "fieldAttachment" | "operationRunComment";
+        txIsolationLevel: TransactionIsolationLevel;
+    };
+    model: {
+        Order: {
+            payload: Prisma.$OrderPayload<ExtArgs>;
+            fields: Prisma.OrderFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OrderFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OrderFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OrderFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OrderFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                findMany: {
+                    args: Prisma.OrderFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>[];
+                };
+                create: {
+                    args: Prisma.OrderCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                createMany: {
+                    args: Prisma.OrderCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OrderCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>[];
+                };
+                delete: {
+                    args: Prisma.OrderDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                update: {
+                    args: Prisma.OrderUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OrderDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OrderUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OrderUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OrderUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OrderAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOrder>;
+                };
+                groupBy: {
+                    args: Prisma.OrderGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OrderCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OrderRevision: {
+            payload: Prisma.$OrderRevisionPayload<ExtArgs>;
+            fields: Prisma.OrderRevisionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OrderRevisionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OrderRevisionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OrderRevisionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OrderRevisionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload>;
+                };
+                findMany: {
+                    args: Prisma.OrderRevisionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload>[];
+                };
+                create: {
+                    args: Prisma.OrderRevisionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload>;
+                };
+                createMany: {
+                    args: Prisma.OrderRevisionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OrderRevisionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload>[];
+                };
+                delete: {
+                    args: Prisma.OrderRevisionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload>;
+                };
+                update: {
+                    args: Prisma.OrderRevisionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OrderRevisionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OrderRevisionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OrderRevisionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OrderRevisionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRevisionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OrderRevisionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOrderRevision>;
+                };
+                groupBy: {
+                    args: Prisma.OrderRevisionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderRevisionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OrderRevisionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderRevisionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Operation: {
+            payload: Prisma.$OperationPayload<ExtArgs>;
+            fields: Prisma.OperationFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OperationFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OperationFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OperationFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OperationFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload>;
+                };
+                findMany: {
+                    args: Prisma.OperationFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload>[];
+                };
+                create: {
+                    args: Prisma.OperationCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload>;
+                };
+                createMany: {
+                    args: Prisma.OperationCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OperationCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload>[];
+                };
+                delete: {
+                    args: Prisma.OperationDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload>;
+                };
+                update: {
+                    args: Prisma.OperationUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OperationDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OperationUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OperationUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OperationUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OperationAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOperation>;
+                };
+                groupBy: {
+                    args: Prisma.OperationGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OperationGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OperationCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OperationCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OperationFieldRef: {
+            payload: Prisma.$OperationFieldRefPayload<ExtArgs>;
+            fields: Prisma.OperationFieldRefFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OperationFieldRefFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OperationFieldRefFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OperationFieldRefFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OperationFieldRefFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload>;
+                };
+                findMany: {
+                    args: Prisma.OperationFieldRefFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload>[];
+                };
+                create: {
+                    args: Prisma.OperationFieldRefCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload>;
+                };
+                createMany: {
+                    args: Prisma.OperationFieldRefCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OperationFieldRefCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload>[];
+                };
+                delete: {
+                    args: Prisma.OperationFieldRefDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload>;
+                };
+                update: {
+                    args: Prisma.OperationFieldRefUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OperationFieldRefDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OperationFieldRefUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OperationFieldRefUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OperationFieldRefUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationFieldRefPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OperationFieldRefAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOperationFieldRef>;
+                };
+                groupBy: {
+                    args: Prisma.OperationFieldRefGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OperationFieldRefGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OperationFieldRefCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OperationFieldRefCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OperationDependency: {
+            payload: Prisma.$OperationDependencyPayload<ExtArgs>;
+            fields: Prisma.OperationDependencyFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OperationDependencyFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OperationDependencyFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OperationDependencyFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OperationDependencyFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload>;
+                };
+                findMany: {
+                    args: Prisma.OperationDependencyFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload>[];
+                };
+                create: {
+                    args: Prisma.OperationDependencyCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload>;
+                };
+                createMany: {
+                    args: Prisma.OperationDependencyCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OperationDependencyCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload>[];
+                };
+                delete: {
+                    args: Prisma.OperationDependencyDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload>;
+                };
+                update: {
+                    args: Prisma.OperationDependencyUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OperationDependencyDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OperationDependencyUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OperationDependencyUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OperationDependencyUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationDependencyPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OperationDependencyAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOperationDependency>;
+                };
+                groupBy: {
+                    args: Prisma.OperationDependencyGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OperationDependencyGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OperationDependencyCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OperationDependencyCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WorkCenter: {
+            payload: Prisma.$WorkCenterPayload<ExtArgs>;
+            fields: Prisma.WorkCenterFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorkCenterFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorkCenterFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorkCenterFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorkCenterFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload>;
+                };
+                findMany: {
+                    args: Prisma.WorkCenterFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload>[];
+                };
+                create: {
+                    args: Prisma.WorkCenterCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload>;
+                };
+                createMany: {
+                    args: Prisma.WorkCenterCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WorkCenterCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload>[];
+                };
+                delete: {
+                    args: Prisma.WorkCenterDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload>;
+                };
+                update: {
+                    args: Prisma.WorkCenterUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorkCenterDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorkCenterUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WorkCenterUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WorkCenterUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorkCenterAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorkCenter>;
+                };
+                groupBy: {
+                    args: Prisma.WorkCenterGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkCenterGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorkCenterCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkCenterCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WorkCenterUser: {
+            payload: Prisma.$WorkCenterUserPayload<ExtArgs>;
+            fields: Prisma.WorkCenterUserFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WorkCenterUserFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WorkCenterUserFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WorkCenterUserFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WorkCenterUserFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload>;
+                };
+                findMany: {
+                    args: Prisma.WorkCenterUserFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload>[];
+                };
+                create: {
+                    args: Prisma.WorkCenterUserCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload>;
+                };
+                createMany: {
+                    args: Prisma.WorkCenterUserCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WorkCenterUserCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload>[];
+                };
+                delete: {
+                    args: Prisma.WorkCenterUserDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload>;
+                };
+                update: {
+                    args: Prisma.WorkCenterUserUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WorkCenterUserDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WorkCenterUserUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WorkCenterUserUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WorkCenterUserUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WorkCenterUserPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WorkCenterUserAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWorkCenterUser>;
+                };
+                groupBy: {
+                    args: Prisma.WorkCenterUserGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkCenterUserGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WorkCenterUserCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WorkCenterUserCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FieldSet: {
+            payload: Prisma.$FieldSetPayload<ExtArgs>;
+            fields: Prisma.FieldSetFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FieldSetFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FieldSetFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FieldSetFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FieldSetFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload>;
+                };
+                findMany: {
+                    args: Prisma.FieldSetFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload>[];
+                };
+                create: {
+                    args: Prisma.FieldSetCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload>;
+                };
+                createMany: {
+                    args: Prisma.FieldSetCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FieldSetCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload>[];
+                };
+                delete: {
+                    args: Prisma.FieldSetDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload>;
+                };
+                update: {
+                    args: Prisma.FieldSetUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FieldSetDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FieldSetUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FieldSetUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FieldSetUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldSetPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FieldSetAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFieldSet>;
+                };
+                groupBy: {
+                    args: Prisma.FieldSetGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FieldSetGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FieldSetCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FieldSetCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FieldRecord: {
+            payload: Prisma.$FieldRecordPayload<ExtArgs>;
+            fields: Prisma.FieldRecordFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FieldRecordFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FieldRecordFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FieldRecordFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FieldRecordFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload>;
+                };
+                findMany: {
+                    args: Prisma.FieldRecordFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload>[];
+                };
+                create: {
+                    args: Prisma.FieldRecordCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload>;
+                };
+                createMany: {
+                    args: Prisma.FieldRecordCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FieldRecordCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload>[];
+                };
+                delete: {
+                    args: Prisma.FieldRecordDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload>;
+                };
+                update: {
+                    args: Prisma.FieldRecordUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FieldRecordDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FieldRecordUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FieldRecordUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FieldRecordUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldRecordPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FieldRecordAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFieldRecord>;
+                };
+                groupBy: {
+                    args: Prisma.FieldRecordGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FieldRecordGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FieldRecordCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FieldRecordCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Field: {
+            payload: Prisma.$FieldPayload<ExtArgs>;
+            fields: Prisma.FieldFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FieldFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FieldFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FieldFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FieldFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload>;
+                };
+                findMany: {
+                    args: Prisma.FieldFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload>[];
+                };
+                create: {
+                    args: Prisma.FieldCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload>;
+                };
+                createMany: {
+                    args: Prisma.FieldCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FieldCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload>[];
+                };
+                delete: {
+                    args: Prisma.FieldDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload>;
+                };
+                update: {
+                    args: Prisma.FieldUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FieldDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FieldUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FieldUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FieldUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FieldAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateField>;
+                };
+                groupBy: {
+                    args: Prisma.FieldGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FieldGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FieldCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FieldCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Step: {
+            payload: Prisma.$StepPayload<ExtArgs>;
+            fields: Prisma.StepFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.StepFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.StepFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload>;
+                };
+                findFirst: {
+                    args: Prisma.StepFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.StepFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload>;
+                };
+                findMany: {
+                    args: Prisma.StepFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload>[];
+                };
+                create: {
+                    args: Prisma.StepCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload>;
+                };
+                createMany: {
+                    args: Prisma.StepCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.StepCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload>[];
+                };
+                delete: {
+                    args: Prisma.StepDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload>;
+                };
+                update: {
+                    args: Prisma.StepUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.StepDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.StepUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.StepUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload>[];
+                };
+                upsert: {
+                    args: Prisma.StepUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepPayload>;
+                };
+                aggregate: {
+                    args: Prisma.StepAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateStep>;
+                };
+                groupBy: {
+                    args: Prisma.StepGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StepGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.StepCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StepCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OrderRun: {
+            payload: Prisma.$OrderRunPayload<ExtArgs>;
+            fields: Prisma.OrderRunFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OrderRunFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OrderRunFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OrderRunFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OrderRunFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload>;
+                };
+                findMany: {
+                    args: Prisma.OrderRunFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload>[];
+                };
+                create: {
+                    args: Prisma.OrderRunCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload>;
+                };
+                createMany: {
+                    args: Prisma.OrderRunCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OrderRunCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload>[];
+                };
+                delete: {
+                    args: Prisma.OrderRunDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload>;
+                };
+                update: {
+                    args: Prisma.OrderRunUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OrderRunDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OrderRunUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OrderRunUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OrderRunUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderRunPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OrderRunAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOrderRun>;
+                };
+                groupBy: {
+                    args: Prisma.OrderRunGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderRunGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OrderRunCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderRunCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OperationRun: {
+            payload: Prisma.$OperationRunPayload<ExtArgs>;
+            fields: Prisma.OperationRunFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OperationRunFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OperationRunFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OperationRunFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OperationRunFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload>;
+                };
+                findMany: {
+                    args: Prisma.OperationRunFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload>[];
+                };
+                create: {
+                    args: Prisma.OperationRunCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload>;
+                };
+                createMany: {
+                    args: Prisma.OperationRunCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OperationRunCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload>[];
+                };
+                delete: {
+                    args: Prisma.OperationRunDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload>;
+                };
+                update: {
+                    args: Prisma.OperationRunUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OperationRunDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OperationRunUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OperationRunUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OperationRunUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OperationRunAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOperationRun>;
+                };
+                groupBy: {
+                    args: Prisma.OperationRunGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OperationRunGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OperationRunCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OperationRunCountAggregateOutputType> | number;
+                };
+            };
+        };
+        StepRun: {
+            payload: Prisma.$StepRunPayload<ExtArgs>;
+            fields: Prisma.StepRunFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.StepRunFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.StepRunFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload>;
+                };
+                findFirst: {
+                    args: Prisma.StepRunFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.StepRunFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload>;
+                };
+                findMany: {
+                    args: Prisma.StepRunFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload>[];
+                };
+                create: {
+                    args: Prisma.StepRunCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload>;
+                };
+                createMany: {
+                    args: Prisma.StepRunCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.StepRunCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload>[];
+                };
+                delete: {
+                    args: Prisma.StepRunDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload>;
+                };
+                update: {
+                    args: Prisma.StepRunUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.StepRunDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.StepRunUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.StepRunUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload>[];
+                };
+                upsert: {
+                    args: Prisma.StepRunUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StepRunPayload>;
+                };
+                aggregate: {
+                    args: Prisma.StepRunAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateStepRun>;
+                };
+                groupBy: {
+                    args: Prisma.StepRunGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StepRunGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.StepRunCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StepRunCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FieldValue: {
+            payload: Prisma.$FieldValuePayload<ExtArgs>;
+            fields: Prisma.FieldValueFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FieldValueFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FieldValueFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload>;
+                };
+                findFirst: {
+                    args: Prisma.FieldValueFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FieldValueFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload>;
+                };
+                findMany: {
+                    args: Prisma.FieldValueFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload>[];
+                };
+                create: {
+                    args: Prisma.FieldValueCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload>;
+                };
+                createMany: {
+                    args: Prisma.FieldValueCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FieldValueCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload>[];
+                };
+                delete: {
+                    args: Prisma.FieldValueDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload>;
+                };
+                update: {
+                    args: Prisma.FieldValueUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FieldValueDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FieldValueUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FieldValueUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload>[];
+                };
+                upsert: {
+                    args: Prisma.FieldValueUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldValuePayload>;
+                };
+                aggregate: {
+                    args: Prisma.FieldValueAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFieldValue>;
+                };
+                groupBy: {
+                    args: Prisma.FieldValueGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FieldValueGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FieldValueCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FieldValueCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Item: {
+            payload: Prisma.$ItemPayload<ExtArgs>;
+            fields: Prisma.ItemFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ItemFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ItemFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ItemFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ItemFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload>;
+                };
+                findMany: {
+                    args: Prisma.ItemFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload>[];
+                };
+                create: {
+                    args: Prisma.ItemCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload>;
+                };
+                createMany: {
+                    args: Prisma.ItemCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ItemCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload>[];
+                };
+                delete: {
+                    args: Prisma.ItemDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload>;
+                };
+                update: {
+                    args: Prisma.ItemUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ItemDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ItemUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ItemUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ItemUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ItemAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateItem>;
+                };
+                groupBy: {
+                    args: Prisma.ItemGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ItemGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ItemCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ItemCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ItemInstance: {
+            payload: Prisma.$ItemInstancePayload<ExtArgs>;
+            fields: Prisma.ItemInstanceFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ItemInstanceFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ItemInstanceFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload>;
+                };
+                findFirst: {
+                    args: Prisma.ItemInstanceFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ItemInstanceFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload>;
+                };
+                findMany: {
+                    args: Prisma.ItemInstanceFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload>[];
+                };
+                create: {
+                    args: Prisma.ItemInstanceCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload>;
+                };
+                createMany: {
+                    args: Prisma.ItemInstanceCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ItemInstanceCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload>[];
+                };
+                delete: {
+                    args: Prisma.ItemInstanceDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload>;
+                };
+                update: {
+                    args: Prisma.ItemInstanceUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ItemInstanceDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ItemInstanceUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ItemInstanceUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload>[];
+                };
+                upsert: {
+                    args: Prisma.ItemInstanceUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ItemInstancePayload>;
+                };
+                aggregate: {
+                    args: Prisma.ItemInstanceAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateItemInstance>;
+                };
+                groupBy: {
+                    args: Prisma.ItemInstanceGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ItemInstanceGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ItemInstanceCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ItemInstanceCountAggregateOutputType> | number;
+                };
+            };
+        };
+        User: {
+            payload: Prisma.$UserPayload<ExtArgs>;
+            fields: Prisma.UserFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.UserFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                findFirst: {
+                    args: Prisma.UserFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                findMany: {
+                    args: Prisma.UserFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[];
+                };
+                create: {
+                    args: Prisma.UserCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                createMany: {
+                    args: Prisma.UserCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[];
+                };
+                delete: {
+                    args: Prisma.UserDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                update: {
+                    args: Prisma.UserUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.UserDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.UserUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>[];
+                };
+                upsert: {
+                    args: Prisma.UserUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPayload>;
+                };
+                aggregate: {
+                    args: Prisma.UserAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateUser>;
+                };
+                groupBy: {
+                    args: Prisma.UserGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.UserGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.UserCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.UserCountAggregateOutputType> | number;
+                };
+            };
+        };
+        UserPermission: {
+            payload: Prisma.$UserPermissionPayload<ExtArgs>;
+            fields: Prisma.UserPermissionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.UserPermissionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.UserPermissionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.UserPermissionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.UserPermissionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload>;
+                };
+                findMany: {
+                    args: Prisma.UserPermissionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload>[];
+                };
+                create: {
+                    args: Prisma.UserPermissionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload>;
+                };
+                createMany: {
+                    args: Prisma.UserPermissionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.UserPermissionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload>[];
+                };
+                delete: {
+                    args: Prisma.UserPermissionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload>;
+                };
+                update: {
+                    args: Prisma.UserPermissionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.UserPermissionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.UserPermissionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.UserPermissionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.UserPermissionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$UserPermissionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.UserPermissionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateUserPermission>;
+                };
+                groupBy: {
+                    args: Prisma.UserPermissionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.UserPermissionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.UserPermissionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.UserPermissionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Session: {
+            payload: Prisma.$SessionPayload<ExtArgs>;
+            fields: Prisma.SessionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SessionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SessionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.SessionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SessionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                findMany: {
+                    args: Prisma.SessionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[];
+                };
+                create: {
+                    args: Prisma.SessionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                createMany: {
+                    args: Prisma.SessionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SessionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[];
+                };
+                delete: {
+                    args: Prisma.SessionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                update: {
+                    args: Prisma.SessionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SessionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SessionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SessionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.SessionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SessionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.SessionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSession>;
+                };
+                groupBy: {
+                    args: Prisma.SessionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SessionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SessionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SessionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        SchemaVersion: {
+            payload: Prisma.$SchemaVersionPayload<ExtArgs>;
+            fields: Prisma.SchemaVersionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SchemaVersionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SchemaVersionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.SchemaVersionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SchemaVersionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload>;
+                };
+                findMany: {
+                    args: Prisma.SchemaVersionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload>[];
+                };
+                create: {
+                    args: Prisma.SchemaVersionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload>;
+                };
+                createMany: {
+                    args: Prisma.SchemaVersionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SchemaVersionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload>[];
+                };
+                delete: {
+                    args: Prisma.SchemaVersionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload>;
+                };
+                update: {
+                    args: Prisma.SchemaVersionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SchemaVersionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SchemaVersionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SchemaVersionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.SchemaVersionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchemaVersionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.SchemaVersionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSchemaVersion>;
+                };
+                groupBy: {
+                    args: Prisma.SchemaVersionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SchemaVersionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SchemaVersionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SchemaVersionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        LaborTicket: {
+            payload: Prisma.$LaborTicketPayload<ExtArgs>;
+            fields: Prisma.LaborTicketFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.LaborTicketFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.LaborTicketFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload>;
+                };
+                findFirst: {
+                    args: Prisma.LaborTicketFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.LaborTicketFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload>;
+                };
+                findMany: {
+                    args: Prisma.LaborTicketFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload>[];
+                };
+                create: {
+                    args: Prisma.LaborTicketCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload>;
+                };
+                createMany: {
+                    args: Prisma.LaborTicketCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.LaborTicketCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload>[];
+                };
+                delete: {
+                    args: Prisma.LaborTicketDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload>;
+                };
+                update: {
+                    args: Prisma.LaborTicketUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.LaborTicketDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.LaborTicketUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.LaborTicketUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload>[];
+                };
+                upsert: {
+                    args: Prisma.LaborTicketUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$LaborTicketPayload>;
+                };
+                aggregate: {
+                    args: Prisma.LaborTicketAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateLaborTicket>;
+                };
+                groupBy: {
+                    args: Prisma.LaborTicketGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.LaborTicketGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.LaborTicketCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.LaborTicketCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AuditLog: {
+            payload: Prisma.$AuditLogPayload<ExtArgs>;
+            fields: Prisma.AuditLogFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AuditLogFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AuditLogFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AuditLogFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AuditLogFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                findMany: {
+                    args: Prisma.AuditLogFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>[];
+                };
+                create: {
+                    args: Prisma.AuditLogCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                createMany: {
+                    args: Prisma.AuditLogCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AuditLogCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>[];
+                };
+                delete: {
+                    args: Prisma.AuditLogDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                update: {
+                    args: Prisma.AuditLogUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AuditLogDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AuditLogUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AuditLogUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AuditLogUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuditLogPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AuditLogAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAuditLog>;
+                };
+                groupBy: {
+                    args: Prisma.AuditLogGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuditLogGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AuditLogCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuditLogCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Attachment: {
+            payload: Prisma.$AttachmentPayload<ExtArgs>;
+            fields: Prisma.AttachmentFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AttachmentFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AttachmentFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AttachmentFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AttachmentFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload>;
+                };
+                findMany: {
+                    args: Prisma.AttachmentFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload>[];
+                };
+                create: {
+                    args: Prisma.AttachmentCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload>;
+                };
+                createMany: {
+                    args: Prisma.AttachmentCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AttachmentCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload>[];
+                };
+                delete: {
+                    args: Prisma.AttachmentDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload>;
+                };
+                update: {
+                    args: Prisma.AttachmentUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AttachmentDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AttachmentUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AttachmentUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AttachmentUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AttachmentPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AttachmentAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAttachment>;
+                };
+                groupBy: {
+                    args: Prisma.AttachmentGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AttachmentGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AttachmentCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AttachmentCountAggregateOutputType> | number;
+                };
+            };
+        };
+        FieldAttachment: {
+            payload: Prisma.$FieldAttachmentPayload<ExtArgs>;
+            fields: Prisma.FieldAttachmentFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.FieldAttachmentFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.FieldAttachmentFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload>;
+                };
+                findFirst: {
+                    args: Prisma.FieldAttachmentFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.FieldAttachmentFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload>;
+                };
+                findMany: {
+                    args: Prisma.FieldAttachmentFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload>[];
+                };
+                create: {
+                    args: Prisma.FieldAttachmentCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload>;
+                };
+                createMany: {
+                    args: Prisma.FieldAttachmentCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.FieldAttachmentCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload>[];
+                };
+                delete: {
+                    args: Prisma.FieldAttachmentDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload>;
+                };
+                update: {
+                    args: Prisma.FieldAttachmentUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.FieldAttachmentDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.FieldAttachmentUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.FieldAttachmentUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload>[];
+                };
+                upsert: {
+                    args: Prisma.FieldAttachmentUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$FieldAttachmentPayload>;
+                };
+                aggregate: {
+                    args: Prisma.FieldAttachmentAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateFieldAttachment>;
+                };
+                groupBy: {
+                    args: Prisma.FieldAttachmentGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FieldAttachmentGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.FieldAttachmentCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.FieldAttachmentCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OperationRunComment: {
+            payload: Prisma.$OperationRunCommentPayload<ExtArgs>;
+            fields: Prisma.OperationRunCommentFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OperationRunCommentFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OperationRunCommentFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OperationRunCommentFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OperationRunCommentFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload>;
+                };
+                findMany: {
+                    args: Prisma.OperationRunCommentFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload>[];
+                };
+                create: {
+                    args: Prisma.OperationRunCommentCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload>;
+                };
+                createMany: {
+                    args: Prisma.OperationRunCommentCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OperationRunCommentCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload>[];
+                };
+                delete: {
+                    args: Prisma.OperationRunCommentDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload>;
+                };
+                update: {
+                    args: Prisma.OperationRunCommentUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OperationRunCommentDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OperationRunCommentUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OperationRunCommentUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OperationRunCommentUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OperationRunCommentPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OperationRunCommentAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOperationRunComment>;
+                };
+                groupBy: {
+                    args: Prisma.OperationRunCommentGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OperationRunCommentGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OperationRunCommentCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OperationRunCommentCountAggregateOutputType> | number;
+                };
+            };
+        };
+    };
+} & {
+    other: {
+        payload: any;
+        operations: {
+            $executeRaw: {
+                args: [query: TemplateStringsArray | Sql, ...values: any[]];
+                result: any;
+            };
+            $executeRawUnsafe: {
+                args: [query: string, ...values: any[]];
+                result: any;
+            };
+            $queryRaw: {
+                args: [query: TemplateStringsArray | Sql, ...values: any[]];
+                result: any;
+            };
+            $queryRawUnsafe: {
+                args: [query: string, ...values: any[]];
+                result: any;
+            };
+        };
+    };
+};
+/**
+ * Enums
+ */
+export declare const TransactionIsolationLevel: {
+    readonly Serializable: "Serializable";
+};
+export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel];
+export declare const OrderScalarFieldEnum: {
+    readonly id: "id";
+    readonly key: "key";
+    readonly description: "description";
+    readonly status: "status";
+    readonly itemId: "itemId";
+    readonly createdById: "createdById";
+    readonly createdAt: "createdAt";
+    readonly updatedById: "updatedById";
+    readonly updatedAt: "updatedAt";
+};
+export type OrderScalarFieldEnum = (typeof OrderScalarFieldEnum)[keyof typeof OrderScalarFieldEnum];
+export declare const OrderRevisionScalarFieldEnum: {
+    readonly id: "id";
+    readonly orderId: "orderId";
+    readonly revNo: "revNo";
+    readonly status: "status";
+    readonly description: "description";
+    readonly changeSummary: "changeSummary";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type OrderRevisionScalarFieldEnum = (typeof OrderRevisionScalarFieldEnum)[keyof typeof OrderRevisionScalarFieldEnum];
+export declare const OperationScalarFieldEnum: {
+    readonly id: "id";
+    readonly orderRevId: "orderRevId";
+    readonly workCenterId: "workCenterId";
+    readonly seqNo: "seqNo";
+    readonly title: "title";
+    readonly description: "description";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type OperationScalarFieldEnum = (typeof OperationScalarFieldEnum)[keyof typeof OperationScalarFieldEnum];
+export declare const OperationFieldRefScalarFieldEnum: {
+    readonly id: "id";
+    readonly operationId: "operationId";
+    readonly seqNo: "seqNo";
+    readonly title: "title";
+    readonly sourceStepId: "sourceStepId";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+};
+export type OperationFieldRefScalarFieldEnum = (typeof OperationFieldRefScalarFieldEnum)[keyof typeof OperationFieldRefScalarFieldEnum];
+export declare const OperationDependencyScalarFieldEnum: {
+    readonly id: "id";
+    readonly successorId: "successorId";
+    readonly predecessorId: "predecessorId";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+};
+export type OperationDependencyScalarFieldEnum = (typeof OperationDependencyScalarFieldEnum)[keyof typeof OperationDependencyScalarFieldEnum];
+export declare const WorkCenterScalarFieldEnum: {
+    readonly id: "id";
+    readonly key: "key";
+    readonly description: "description";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type WorkCenterScalarFieldEnum = (typeof WorkCenterScalarFieldEnum)[keyof typeof WorkCenterScalarFieldEnum];
+export declare const WorkCenterUserScalarFieldEnum: {
+    readonly workCenterId: "workCenterId";
+    readonly userId: "userId";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+};
+export type WorkCenterUserScalarFieldEnum = (typeof WorkCenterUserScalarFieldEnum)[keyof typeof WorkCenterUserScalarFieldEnum];
+export declare const FieldSetScalarFieldEnum: {
+    readonly id: "id";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+};
+export type FieldSetScalarFieldEnum = (typeof FieldSetScalarFieldEnum)[keyof typeof FieldSetScalarFieldEnum];
+export declare const FieldRecordScalarFieldEnum: {
+    readonly id: "id";
+    readonly fieldSetId: "fieldSetId";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+};
+export type FieldRecordScalarFieldEnum = (typeof FieldRecordScalarFieldEnum)[keyof typeof FieldRecordScalarFieldEnum];
+export declare const FieldScalarFieldEnum: {
+    readonly id: "id";
+    readonly fieldSetId: "fieldSetId";
+    readonly seqNo: "seqNo";
+    readonly label: "label";
+    readonly type: "type";
+    readonly isArray: "isArray";
+    readonly required: "required";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type FieldScalarFieldEnum = (typeof FieldScalarFieldEnum)[keyof typeof FieldScalarFieldEnum];
+export declare const StepScalarFieldEnum: {
+    readonly id: "id";
+    readonly operationId: "operationId";
+    readonly fieldSetId: "fieldSetId";
+    readonly seqNo: "seqNo";
+    readonly title: "title";
+    readonly instructions: "instructions";
+    readonly multiSet: "multiSet";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type StepScalarFieldEnum = (typeof StepScalarFieldEnum)[keyof typeof StepScalarFieldEnum];
+export declare const OrderRunScalarFieldEnum: {
+    readonly id: "id";
+    readonly runNo: "runNo";
+    readonly orderId: "orderId";
+    readonly orderRevId: "orderRevId";
+    readonly status: "status";
+    readonly priority: "priority";
+    readonly cost: "cost";
+    readonly dueAt: "dueAt";
+    readonly releaseNote: "releaseNote";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type OrderRunScalarFieldEnum = (typeof OrderRunScalarFieldEnum)[keyof typeof OrderRunScalarFieldEnum];
+export declare const OperationRunScalarFieldEnum: {
+    readonly id: "id";
+    readonly orderRunId: "orderRunId";
+    readonly operationId: "operationId";
+    readonly status: "status";
+    readonly assignedToId: "assignedToId";
+    readonly cost: "cost";
+    readonly statusNote: "statusNote";
+    readonly completedAt: "completedAt";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type OperationRunScalarFieldEnum = (typeof OperationRunScalarFieldEnum)[keyof typeof OperationRunScalarFieldEnum];
+export declare const StepRunScalarFieldEnum: {
+    readonly id: "id";
+    readonly operationRunId: "operationRunId";
+    readonly stepId: "stepId";
+    readonly fieldRecordId: "fieldRecordId";
+    readonly completed: "completed";
+    readonly statusNote: "statusNote";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type StepRunScalarFieldEnum = (typeof StepRunScalarFieldEnum)[keyof typeof StepRunScalarFieldEnum];
+export declare const FieldValueScalarFieldEnum: {
+    readonly id: "id";
+    readonly fieldRecordId: "fieldRecordId";
+    readonly fieldId: "fieldId";
+    readonly setIndex: "setIndex";
+    readonly value: "value";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type FieldValueScalarFieldEnum = (typeof FieldValueScalarFieldEnum)[keyof typeof FieldValueScalarFieldEnum];
+export declare const ItemScalarFieldEnum: {
+    readonly id: "id";
+    readonly key: "key";
+    readonly description: "description";
+    readonly fieldSetId: "fieldSetId";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type ItemScalarFieldEnum = (typeof ItemScalarFieldEnum)[keyof typeof ItemScalarFieldEnum];
+export declare const ItemInstanceScalarFieldEnum: {
+    readonly id: "id";
+    readonly itemId: "itemId";
+    readonly orderRunId: "orderRunId";
+    readonly fieldRecordId: "fieldRecordId";
+    readonly key: "key";
+    readonly quantity: "quantity";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type ItemInstanceScalarFieldEnum = (typeof ItemInstanceScalarFieldEnum)[keyof typeof ItemInstanceScalarFieldEnum];
+export declare const UserScalarFieldEnum: {
+    readonly id: "id";
+    readonly uuid: "uuid";
+    readonly username: "username";
+    readonly passwordHash: "passwordHash";
+    readonly apiKey: "apiKey";
+    readonly isAgent: "isAgent";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly deletedAt: "deletedAt";
+};
+export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum];
+export declare const UserPermissionScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly permission: "permission";
+    readonly grantedAt: "grantedAt";
+    readonly grantedBy: "grantedBy";
+};
+export type UserPermissionScalarFieldEnum = (typeof UserPermissionScalarFieldEnum)[keyof typeof UserPermissionScalarFieldEnum];
+export declare const SessionScalarFieldEnum: {
+    readonly id: "id";
+    readonly userId: "userId";
+    readonly tokenHash: "tokenHash";
+    readonly expiresAt: "expiresAt";
+    readonly createdAt: "createdAt";
+};
+export type SessionScalarFieldEnum = (typeof SessionScalarFieldEnum)[keyof typeof SessionScalarFieldEnum];
+export declare const SchemaVersionScalarFieldEnum: {
+    readonly id: "id";
+    readonly version: "version";
+    readonly updated: "updated";
+};
+export type SchemaVersionScalarFieldEnum = (typeof SchemaVersionScalarFieldEnum)[keyof typeof SchemaVersionScalarFieldEnum];
+export declare const LaborTicketScalarFieldEnum: {
+    readonly id: "id";
+    readonly operationRunId: "operationRunId";
+    readonly userId: "userId";
+    readonly runId: "runId";
+    readonly clockIn: "clockIn";
+    readonly clockOut: "clockOut";
+    readonly cost: "cost";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+    readonly updatedAt: "updatedAt";
+    readonly updatedById: "updatedById";
+};
+export type LaborTicketScalarFieldEnum = (typeof LaborTicketScalarFieldEnum)[keyof typeof LaborTicketScalarFieldEnum];
+export declare const AuditLogScalarFieldEnum: {
+    readonly id: "id";
+    readonly entityType: "entityType";
+    readonly entityId: "entityId";
+    readonly action: "action";
+    readonly field: "field";
+    readonly oldValue: "oldValue";
+    readonly newValue: "newValue";
+    readonly userId: "userId";
+    readonly createdAt: "createdAt";
+};
+export type AuditLogScalarFieldEnum = (typeof AuditLogScalarFieldEnum)[keyof typeof AuditLogScalarFieldEnum];
+export declare const AttachmentScalarFieldEnum: {
+    readonly id: "id";
+    readonly publicId: "publicId";
+    readonly filepath: "filepath";
+    readonly filename: "filename";
+    readonly fileSize: "fileSize";
+    readonly fileHash: "fileHash";
+    readonly uploadedById: "uploadedById";
+    readonly createdAt: "createdAt";
+};
+export type AttachmentScalarFieldEnum = (typeof AttachmentScalarFieldEnum)[keyof typeof AttachmentScalarFieldEnum];
+export declare const FieldAttachmentScalarFieldEnum: {
+    readonly fieldValueId: "fieldValueId";
+    readonly attachmentId: "attachmentId";
+    readonly createdAt: "createdAt";
+};
+export type FieldAttachmentScalarFieldEnum = (typeof FieldAttachmentScalarFieldEnum)[keyof typeof FieldAttachmentScalarFieldEnum];
+export declare const OperationRunCommentScalarFieldEnum: {
+    readonly id: "id";
+    readonly operationRunId: "operationRunId";
+    readonly type: "type";
+    readonly body: "body";
+    readonly createdAt: "createdAt";
+    readonly createdById: "createdById";
+};
+export type OperationRunCommentScalarFieldEnum = (typeof OperationRunCommentScalarFieldEnum)[keyof typeof OperationRunCommentScalarFieldEnum];
+export declare const SortOrder: {
+    readonly asc: "asc";
+    readonly desc: "desc";
+};
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
+export declare const NullsOrder: {
+    readonly first: "first";
+    readonly last: "last";
+};
+export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder];
+/**
+ * Field references
+ */
+/**
+ * Reference to a field of type 'Int'
+ */
+export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>;
+/**
+ * Reference to a field of type 'String'
+ */
+export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>;
+/**
+ * Reference to a field of type 'OrderStatus'
+ */
+export type EnumOrderStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'OrderStatus'>;
+/**
+ * Reference to a field of type 'DateTime'
+ */
+export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>;
+/**
+ * Reference to a field of type 'RevisionStatus'
+ */
+export type EnumRevisionStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RevisionStatus'>;
+/**
+ * Reference to a field of type 'FieldType'
+ */
+export type EnumFieldTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'FieldType'>;
+/**
+ * Reference to a field of type 'Boolean'
+ */
+export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>;
+/**
+ * Reference to a field of type 'OrderRunStatus'
+ */
+export type EnumOrderRunStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'OrderRunStatus'>;
+/**
+ * Reference to a field of type 'OrderRunPriority'
+ */
+export type EnumOrderRunPriorityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'OrderRunPriority'>;
+/**
+ * Reference to a field of type 'Float'
+ */
+export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>;
+/**
+ * Reference to a field of type 'OperationRunStatus'
+ */
+export type EnumOperationRunStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'OperationRunStatus'>;
+/**
+ * Reference to a field of type 'ErpPermission'
+ */
+export type EnumErpPermissionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ErpPermission'>;
+/**
+ * Reference to a field of type 'OperationRunCommentType'
+ */
+export type EnumOperationRunCommentTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'OperationRunCommentType'>;
+/**
+ * Batch Payload for updateMany & deleteMany & createMany
+ */
+export type BatchPayload = {
+    count: number;
+};
+export declare const defineExtension: runtime.Types.Extensions.ExtendsHook<"define", TypeMapCb, runtime.Types.Extensions.DefaultArgs>;
+export type DefaultPrismaClient = PrismaClient;
+export type ErrorFormat = 'pretty' | 'colorless' | 'minimal';
+export type PrismaClientOptions = ({
+    /**
+     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-pg`.
+     */
+    adapter: runtime.SqlDriverAdapterFactory;
+    accelerateUrl?: never;
+} | {
+    /**
+     * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
+     */
+    accelerateUrl: string;
+    adapter?: never;
+}) & {
+    /**
+     * @default "colorless"
+     */
+    errorFormat?: ErrorFormat;
+    /**
+     * @example
+     * ```
+     * // Shorthand for `emit: 'stdout'`
+     * log: ['query', 'info', 'warn', 'error']
+     *
+     * // Emit as events only
+     * log: [
+     *   { emit: 'event', level: 'query' },
+     *   { emit: 'event', level: 'info' },
+     *   { emit: 'event', level: 'warn' }
+     *   { emit: 'event', level: 'error' }
+     * ]
+     *
+     * / Emit as events and log to stdout
+     * og: [
+     *  { emit: 'stdout', level: 'query' },
+     *  { emit: 'stdout', level: 'info' },
+     *  { emit: 'stdout', level: 'warn' }
+     *  { emit: 'stdout', level: 'error' }
+     *
+     * ```
+     * Read more in our [docs](https://pris.ly/d/logging).
+     */
+    log?: (LogLevel | LogDefinition)[];
+    /**
+     * The default values for transactionOptions
+     * maxWait ?= 2000
+     * timeout ?= 5000
+     */
+    transactionOptions?: {
+        maxWait?: number;
+        timeout?: number;
+        isolationLevel?: TransactionIsolationLevel;
+    };
+    /**
+     * Global configuration for omitting model fields by default.
+     *
+     * @example
+     * ```
+     * const prisma = new PrismaClient({
+     *   omit: {
+     *     user: {
+     *       password: true
+     *     }
+     *   }
+     * })
+     * ```
+     */
+    omit?: GlobalOmitConfig;
+    /**
+     * SQL commenter plugins that add metadata to SQL queries as comments.
+     * Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
+     *
+     * @example
+     * ```
+     * const prisma = new PrismaClient({
+     *   adapter,
+     *   comments: [
+     *     traceContext(),
+     *     queryInsights(),
+     *   ],
+     * })
+     * ```
+     */
+    comments?: runtime.SqlCommenterPlugin[];
+};
+export type GlobalOmitConfig = {
+    order?: Prisma.OrderOmit;
+    orderRevision?: Prisma.OrderRevisionOmit;
+    operation?: Prisma.OperationOmit;
+    operationFieldRef?: Prisma.OperationFieldRefOmit;
+    operationDependency?: Prisma.OperationDependencyOmit;
+    workCenter?: Prisma.WorkCenterOmit;
+    workCenterUser?: Prisma.WorkCenterUserOmit;
+    fieldSet?: Prisma.FieldSetOmit;
+    fieldRecord?: Prisma.FieldRecordOmit;
+    field?: Prisma.FieldOmit;
+    step?: Prisma.StepOmit;
+    orderRun?: Prisma.OrderRunOmit;
+    operationRun?: Prisma.OperationRunOmit;
+    stepRun?: Prisma.StepRunOmit;
+    fieldValue?: Prisma.FieldValueOmit;
+    item?: Prisma.ItemOmit;
+    itemInstance?: Prisma.ItemInstanceOmit;
+    user?: Prisma.UserOmit;
+    userPermission?: Prisma.UserPermissionOmit;
+    session?: Prisma.SessionOmit;
+    schemaVersion?: Prisma.SchemaVersionOmit;
+    laborTicket?: Prisma.LaborTicketOmit;
+    auditLog?: Prisma.AuditLogOmit;
+    attachment?: Prisma.AttachmentOmit;
+    fieldAttachment?: Prisma.FieldAttachmentOmit;
+    operationRunComment?: Prisma.OperationRunCommentOmit;
+};
+export type LogLevel = 'info' | 'query' | 'warn' | 'error';
+export type LogDefinition = {
+    level: LogLevel;
+    emit: 'stdout' | 'event';
+};
+export type CheckIsLogLevel<T> = T extends LogLevel ? T : never;
+export type GetLogType<T> = CheckIsLogLevel<T extends LogDefinition ? T['level'] : T>;
+export type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition> ? GetLogType<T[number]> : never;
+export type QueryEvent = {
+    timestamp: Date;
+    query: string;
+    params: string;
+    duration: number;
+    target: string;
+};
+export type LogEvent = {
+    timestamp: Date;
+    message: string;
+    target: string;
+};
+export type PrismaAction = 'findUnique' | 'findUniqueOrThrow' | 'findMany' | 'findFirst' | 'findFirstOrThrow' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'executeRaw' | 'queryRaw' | 'aggregate' | 'count' | 'runCommandRaw' | 'findRaw' | 'groupBy';
+/**
+ * `PrismaClient` proxy available in interactive transactions.
+ */
+export type TransactionClient = Omit<DefaultPrismaClient, runtime.ITXClientDenyList>;
+//# sourceMappingURL=prismaNamespace.d.ts.map