@wardby/cli 0.1.0 → 0.2.1

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

@@ -0,0 +1,3325 @@
+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.10.0
+ * Query Engine version: 0edf323efd1d98336f3f0a68684b56f689b900d3
+ */
+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;
+};
+/**
+ * Resolved type of the argument passed to the `PrismaClient` constructor.
+ *
+ * When called without a narrower options type (the common case), this resolves
+ * to `PrismaClientOptions` directly, which produces a clear TypeScript error
+ * message (`not assignable to parameter of type 'PrismaClientOptions'`) when
+ * the argument is missing or incomplete. When the user supplies a narrower
+ * options type (e.g. via a literal), it falls back to `Subset` to keep
+ * filtering out unknown properties.
+ */
+export type PrismaClientConstructorArgs<Options extends PrismaClientOptions> = [
+    PrismaClientOptions
+] extends [Options] ? PrismaClientOptions : Subset<Options, PrismaClientOptions>;
+/**
+ * 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)) & object : 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 Agent: "Agent";
+    readonly AgentSubAgent: "AgentSubAgent";
+    readonly BudgetGroup: "BudgetGroup";
+    readonly Tool: "Tool";
+    readonly AgentTool: "AgentTool";
+    readonly Datastore: "Datastore";
+    readonly AgentDatastore: "AgentDatastore";
+    readonly DatastoreEntry: "DatastoreEntry";
+    readonly AgentMemory: "AgentMemory";
+    readonly Run: "Run";
+    readonly CodingAgentProfile: "CodingAgentProfile";
+    readonly CodingRun: "CodingRun";
+    readonly CodingProxySession: "CodingProxySession";
+    readonly CodingProxyRequest: "CodingProxyRequest";
+    readonly SchedulerLease: "SchedulerLease";
+    readonly Principal: "Principal";
+    readonly Task: "Task";
+    readonly Secret: "Secret";
+    readonly AgentSecret: "AgentSecret";
+    readonly SecretElicitationOutcome: "SecretElicitationOutcome";
+    readonly Webhook: "Webhook";
+    readonly OAuthClient: "OAuthClient";
+    readonly OAuthGrant: "OAuthGrant";
+    readonly AuthUser: "AuthUser";
+    readonly AuthLoginKey: "AuthLoginKey";
+    readonly AuthSession: "AuthSession";
+    readonly AuthFormChallenge: "AuthFormChallenge";
+    readonly OAuthAuthorizationRequest: "OAuthAuthorizationRequest";
+    readonly OAuthAuthorizationCode: "OAuthAuthorizationCode";
+    readonly OAuthFamily: "OAuthFamily";
+    readonly AuthRateLimit: "AuthRateLimit";
+};
+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: "agent" | "agentSubAgent" | "budgetGroup" | "tool" | "agentTool" | "datastore" | "agentDatastore" | "datastoreEntry" | "agentMemory" | "run" | "codingAgentProfile" | "codingRun" | "codingProxySession" | "codingProxyRequest" | "schedulerLease" | "principal" | "task" | "secret" | "agentSecret" | "secretElicitationOutcome" | "webhook" | "oAuthClient" | "oAuthGrant" | "authUser" | "authLoginKey" | "authSession" | "authFormChallenge" | "oAuthAuthorizationRequest" | "oAuthAuthorizationCode" | "oAuthFamily" | "authRateLimit";
+        txIsolationLevel: TransactionIsolationLevel;
+    };
+    model: {
+        Agent: {
+            payload: Prisma.$AgentPayload<ExtArgs>;
+            fields: Prisma.AgentFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AgentFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AgentFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AgentFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AgentFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload>;
+                };
+                findMany: {
+                    args: Prisma.AgentFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload>[];
+                };
+                create: {
+                    args: Prisma.AgentCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload>;
+                };
+                createMany: {
+                    args: Prisma.AgentCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AgentCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload>[];
+                };
+                delete: {
+                    args: Prisma.AgentDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload>;
+                };
+                update: {
+                    args: Prisma.AgentUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AgentDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AgentUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AgentUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AgentUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AgentAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAgent>;
+                };
+                groupBy: {
+                    args: Prisma.AgentGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AgentCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AgentSubAgent: {
+            payload: Prisma.$AgentSubAgentPayload<ExtArgs>;
+            fields: Prisma.AgentSubAgentFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AgentSubAgentFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AgentSubAgentFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AgentSubAgentFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AgentSubAgentFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload>;
+                };
+                findMany: {
+                    args: Prisma.AgentSubAgentFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload>[];
+                };
+                create: {
+                    args: Prisma.AgentSubAgentCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload>;
+                };
+                createMany: {
+                    args: Prisma.AgentSubAgentCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AgentSubAgentCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload>[];
+                };
+                delete: {
+                    args: Prisma.AgentSubAgentDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload>;
+                };
+                update: {
+                    args: Prisma.AgentSubAgentUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AgentSubAgentDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AgentSubAgentUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AgentSubAgentUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AgentSubAgentUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSubAgentPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AgentSubAgentAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAgentSubAgent>;
+                };
+                groupBy: {
+                    args: Prisma.AgentSubAgentGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentSubAgentGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AgentSubAgentCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentSubAgentCountAggregateOutputType> | number;
+                };
+            };
+        };
+        BudgetGroup: {
+            payload: Prisma.$BudgetGroupPayload<ExtArgs>;
+            fields: Prisma.BudgetGroupFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.BudgetGroupFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.BudgetGroupFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload>;
+                };
+                findFirst: {
+                    args: Prisma.BudgetGroupFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.BudgetGroupFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload>;
+                };
+                findMany: {
+                    args: Prisma.BudgetGroupFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload>[];
+                };
+                create: {
+                    args: Prisma.BudgetGroupCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload>;
+                };
+                createMany: {
+                    args: Prisma.BudgetGroupCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.BudgetGroupCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload>[];
+                };
+                delete: {
+                    args: Prisma.BudgetGroupDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload>;
+                };
+                update: {
+                    args: Prisma.BudgetGroupUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.BudgetGroupDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.BudgetGroupUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.BudgetGroupUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload>[];
+                };
+                upsert: {
+                    args: Prisma.BudgetGroupUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BudgetGroupPayload>;
+                };
+                aggregate: {
+                    args: Prisma.BudgetGroupAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateBudgetGroup>;
+                };
+                groupBy: {
+                    args: Prisma.BudgetGroupGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.BudgetGroupGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.BudgetGroupCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.BudgetGroupCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Tool: {
+            payload: Prisma.$ToolPayload<ExtArgs>;
+            fields: Prisma.ToolFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ToolFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ToolFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ToolFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ToolFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload>;
+                };
+                findMany: {
+                    args: Prisma.ToolFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload>[];
+                };
+                create: {
+                    args: Prisma.ToolCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload>;
+                };
+                createMany: {
+                    args: Prisma.ToolCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ToolCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload>[];
+                };
+                delete: {
+                    args: Prisma.ToolDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload>;
+                };
+                update: {
+                    args: Prisma.ToolUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ToolDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ToolUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ToolUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ToolUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ToolPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ToolAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateTool>;
+                };
+                groupBy: {
+                    args: Prisma.ToolGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ToolGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ToolCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ToolCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AgentTool: {
+            payload: Prisma.$AgentToolPayload<ExtArgs>;
+            fields: Prisma.AgentToolFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AgentToolFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AgentToolFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AgentToolFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AgentToolFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload>;
+                };
+                findMany: {
+                    args: Prisma.AgentToolFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload>[];
+                };
+                create: {
+                    args: Prisma.AgentToolCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload>;
+                };
+                createMany: {
+                    args: Prisma.AgentToolCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AgentToolCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload>[];
+                };
+                delete: {
+                    args: Prisma.AgentToolDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload>;
+                };
+                update: {
+                    args: Prisma.AgentToolUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AgentToolDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AgentToolUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AgentToolUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AgentToolUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentToolPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AgentToolAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAgentTool>;
+                };
+                groupBy: {
+                    args: Prisma.AgentToolGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentToolGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AgentToolCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentToolCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Datastore: {
+            payload: Prisma.$DatastorePayload<ExtArgs>;
+            fields: Prisma.DatastoreFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.DatastoreFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.DatastoreFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload>;
+                };
+                findFirst: {
+                    args: Prisma.DatastoreFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.DatastoreFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload>;
+                };
+                findMany: {
+                    args: Prisma.DatastoreFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload>[];
+                };
+                create: {
+                    args: Prisma.DatastoreCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload>;
+                };
+                createMany: {
+                    args: Prisma.DatastoreCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.DatastoreCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload>[];
+                };
+                delete: {
+                    args: Prisma.DatastoreDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload>;
+                };
+                update: {
+                    args: Prisma.DatastoreUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.DatastoreDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.DatastoreUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.DatastoreUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload>[];
+                };
+                upsert: {
+                    args: Prisma.DatastoreUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastorePayload>;
+                };
+                aggregate: {
+                    args: Prisma.DatastoreAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateDatastore>;
+                };
+                groupBy: {
+                    args: Prisma.DatastoreGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.DatastoreGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.DatastoreCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.DatastoreCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AgentDatastore: {
+            payload: Prisma.$AgentDatastorePayload<ExtArgs>;
+            fields: Prisma.AgentDatastoreFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AgentDatastoreFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AgentDatastoreFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload>;
+                };
+                findFirst: {
+                    args: Prisma.AgentDatastoreFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AgentDatastoreFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload>;
+                };
+                findMany: {
+                    args: Prisma.AgentDatastoreFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload>[];
+                };
+                create: {
+                    args: Prisma.AgentDatastoreCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload>;
+                };
+                createMany: {
+                    args: Prisma.AgentDatastoreCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AgentDatastoreCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload>[];
+                };
+                delete: {
+                    args: Prisma.AgentDatastoreDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload>;
+                };
+                update: {
+                    args: Prisma.AgentDatastoreUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AgentDatastoreDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AgentDatastoreUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AgentDatastoreUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload>[];
+                };
+                upsert: {
+                    args: Prisma.AgentDatastoreUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentDatastorePayload>;
+                };
+                aggregate: {
+                    args: Prisma.AgentDatastoreAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAgentDatastore>;
+                };
+                groupBy: {
+                    args: Prisma.AgentDatastoreGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentDatastoreGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AgentDatastoreCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentDatastoreCountAggregateOutputType> | number;
+                };
+            };
+        };
+        DatastoreEntry: {
+            payload: Prisma.$DatastoreEntryPayload<ExtArgs>;
+            fields: Prisma.DatastoreEntryFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.DatastoreEntryFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.DatastoreEntryFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload>;
+                };
+                findFirst: {
+                    args: Prisma.DatastoreEntryFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.DatastoreEntryFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload>;
+                };
+                findMany: {
+                    args: Prisma.DatastoreEntryFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload>[];
+                };
+                create: {
+                    args: Prisma.DatastoreEntryCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload>;
+                };
+                createMany: {
+                    args: Prisma.DatastoreEntryCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.DatastoreEntryCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload>[];
+                };
+                delete: {
+                    args: Prisma.DatastoreEntryDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload>;
+                };
+                update: {
+                    args: Prisma.DatastoreEntryUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.DatastoreEntryDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.DatastoreEntryUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.DatastoreEntryUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload>[];
+                };
+                upsert: {
+                    args: Prisma.DatastoreEntryUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$DatastoreEntryPayload>;
+                };
+                aggregate: {
+                    args: Prisma.DatastoreEntryAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateDatastoreEntry>;
+                };
+                groupBy: {
+                    args: Prisma.DatastoreEntryGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.DatastoreEntryGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.DatastoreEntryCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.DatastoreEntryCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AgentMemory: {
+            payload: Prisma.$AgentMemoryPayload<ExtArgs>;
+            fields: Prisma.AgentMemoryFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AgentMemoryFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AgentMemoryFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AgentMemoryFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AgentMemoryFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload>;
+                };
+                findMany: {
+                    args: Prisma.AgentMemoryFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload>[];
+                };
+                create: {
+                    args: Prisma.AgentMemoryCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload>;
+                };
+                createMany: {
+                    args: Prisma.AgentMemoryCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AgentMemoryCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload>[];
+                };
+                delete: {
+                    args: Prisma.AgentMemoryDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload>;
+                };
+                update: {
+                    args: Prisma.AgentMemoryUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AgentMemoryDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AgentMemoryUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AgentMemoryUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AgentMemoryUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentMemoryPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AgentMemoryAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAgentMemory>;
+                };
+                groupBy: {
+                    args: Prisma.AgentMemoryGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentMemoryGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AgentMemoryCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentMemoryCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Run: {
+            payload: Prisma.$RunPayload<ExtArgs>;
+            fields: Prisma.RunFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.RunFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.RunFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload>;
+                };
+                findFirst: {
+                    args: Prisma.RunFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.RunFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload>;
+                };
+                findMany: {
+                    args: Prisma.RunFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload>[];
+                };
+                create: {
+                    args: Prisma.RunCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload>;
+                };
+                createMany: {
+                    args: Prisma.RunCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.RunCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload>[];
+                };
+                delete: {
+                    args: Prisma.RunDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload>;
+                };
+                update: {
+                    args: Prisma.RunUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.RunDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.RunUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.RunUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload>[];
+                };
+                upsert: {
+                    args: Prisma.RunUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$RunPayload>;
+                };
+                aggregate: {
+                    args: Prisma.RunAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateRun>;
+                };
+                groupBy: {
+                    args: Prisma.RunGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.RunGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.RunCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.RunCountAggregateOutputType> | number;
+                };
+            };
+        };
+        CodingAgentProfile: {
+            payload: Prisma.$CodingAgentProfilePayload<ExtArgs>;
+            fields: Prisma.CodingAgentProfileFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CodingAgentProfileFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CodingAgentProfileFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload>;
+                };
+                findFirst: {
+                    args: Prisma.CodingAgentProfileFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CodingAgentProfileFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload>;
+                };
+                findMany: {
+                    args: Prisma.CodingAgentProfileFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload>[];
+                };
+                create: {
+                    args: Prisma.CodingAgentProfileCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload>;
+                };
+                createMany: {
+                    args: Prisma.CodingAgentProfileCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CodingAgentProfileCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload>[];
+                };
+                delete: {
+                    args: Prisma.CodingAgentProfileDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload>;
+                };
+                update: {
+                    args: Prisma.CodingAgentProfileUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CodingAgentProfileDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CodingAgentProfileUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CodingAgentProfileUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload>[];
+                };
+                upsert: {
+                    args: Prisma.CodingAgentProfileUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingAgentProfilePayload>;
+                };
+                aggregate: {
+                    args: Prisma.CodingAgentProfileAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCodingAgentProfile>;
+                };
+                groupBy: {
+                    args: Prisma.CodingAgentProfileGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CodingAgentProfileGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CodingAgentProfileCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CodingAgentProfileCountAggregateOutputType> | number;
+                };
+            };
+        };
+        CodingRun: {
+            payload: Prisma.$CodingRunPayload<ExtArgs>;
+            fields: Prisma.CodingRunFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CodingRunFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CodingRunFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CodingRunFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CodingRunFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload>;
+                };
+                findMany: {
+                    args: Prisma.CodingRunFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload>[];
+                };
+                create: {
+                    args: Prisma.CodingRunCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload>;
+                };
+                createMany: {
+                    args: Prisma.CodingRunCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CodingRunCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload>[];
+                };
+                delete: {
+                    args: Prisma.CodingRunDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload>;
+                };
+                update: {
+                    args: Prisma.CodingRunUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CodingRunDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CodingRunUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CodingRunUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CodingRunUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingRunPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CodingRunAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCodingRun>;
+                };
+                groupBy: {
+                    args: Prisma.CodingRunGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CodingRunGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CodingRunCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CodingRunCountAggregateOutputType> | number;
+                };
+            };
+        };
+        CodingProxySession: {
+            payload: Prisma.$CodingProxySessionPayload<ExtArgs>;
+            fields: Prisma.CodingProxySessionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CodingProxySessionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CodingProxySessionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CodingProxySessionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CodingProxySessionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload>;
+                };
+                findMany: {
+                    args: Prisma.CodingProxySessionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload>[];
+                };
+                create: {
+                    args: Prisma.CodingProxySessionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload>;
+                };
+                createMany: {
+                    args: Prisma.CodingProxySessionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CodingProxySessionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload>[];
+                };
+                delete: {
+                    args: Prisma.CodingProxySessionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload>;
+                };
+                update: {
+                    args: Prisma.CodingProxySessionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CodingProxySessionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CodingProxySessionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CodingProxySessionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CodingProxySessionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxySessionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CodingProxySessionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCodingProxySession>;
+                };
+                groupBy: {
+                    args: Prisma.CodingProxySessionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CodingProxySessionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CodingProxySessionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CodingProxySessionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        CodingProxyRequest: {
+            payload: Prisma.$CodingProxyRequestPayload<ExtArgs>;
+            fields: Prisma.CodingProxyRequestFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CodingProxyRequestFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CodingProxyRequestFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CodingProxyRequestFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CodingProxyRequestFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload>;
+                };
+                findMany: {
+                    args: Prisma.CodingProxyRequestFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload>[];
+                };
+                create: {
+                    args: Prisma.CodingProxyRequestCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload>;
+                };
+                createMany: {
+                    args: Prisma.CodingProxyRequestCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CodingProxyRequestCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload>[];
+                };
+                delete: {
+                    args: Prisma.CodingProxyRequestDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload>;
+                };
+                update: {
+                    args: Prisma.CodingProxyRequestUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CodingProxyRequestDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CodingProxyRequestUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CodingProxyRequestUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CodingProxyRequestUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CodingProxyRequestPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CodingProxyRequestAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCodingProxyRequest>;
+                };
+                groupBy: {
+                    args: Prisma.CodingProxyRequestGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CodingProxyRequestGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CodingProxyRequestCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CodingProxyRequestCountAggregateOutputType> | number;
+                };
+            };
+        };
+        SchedulerLease: {
+            payload: Prisma.$SchedulerLeasePayload<ExtArgs>;
+            fields: Prisma.SchedulerLeaseFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SchedulerLeaseFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SchedulerLeaseFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload>;
+                };
+                findFirst: {
+                    args: Prisma.SchedulerLeaseFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SchedulerLeaseFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload>;
+                };
+                findMany: {
+                    args: Prisma.SchedulerLeaseFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload>[];
+                };
+                create: {
+                    args: Prisma.SchedulerLeaseCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload>;
+                };
+                createMany: {
+                    args: Prisma.SchedulerLeaseCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SchedulerLeaseCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload>[];
+                };
+                delete: {
+                    args: Prisma.SchedulerLeaseDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload>;
+                };
+                update: {
+                    args: Prisma.SchedulerLeaseUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SchedulerLeaseDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SchedulerLeaseUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SchedulerLeaseUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload>[];
+                };
+                upsert: {
+                    args: Prisma.SchedulerLeaseUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SchedulerLeasePayload>;
+                };
+                aggregate: {
+                    args: Prisma.SchedulerLeaseAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSchedulerLease>;
+                };
+                groupBy: {
+                    args: Prisma.SchedulerLeaseGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SchedulerLeaseGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SchedulerLeaseCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SchedulerLeaseCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Principal: {
+            payload: Prisma.$PrincipalPayload<ExtArgs>;
+            fields: Prisma.PrincipalFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.PrincipalFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.PrincipalFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload>;
+                };
+                findFirst: {
+                    args: Prisma.PrincipalFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.PrincipalFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload>;
+                };
+                findMany: {
+                    args: Prisma.PrincipalFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload>[];
+                };
+                create: {
+                    args: Prisma.PrincipalCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload>;
+                };
+                createMany: {
+                    args: Prisma.PrincipalCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.PrincipalCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload>[];
+                };
+                delete: {
+                    args: Prisma.PrincipalDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload>;
+                };
+                update: {
+                    args: Prisma.PrincipalUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.PrincipalDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.PrincipalUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.PrincipalUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload>[];
+                };
+                upsert: {
+                    args: Prisma.PrincipalUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PrincipalPayload>;
+                };
+                aggregate: {
+                    args: Prisma.PrincipalAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregatePrincipal>;
+                };
+                groupBy: {
+                    args: Prisma.PrincipalGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PrincipalGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.PrincipalCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PrincipalCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Task: {
+            payload: Prisma.$TaskPayload<ExtArgs>;
+            fields: Prisma.TaskFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.TaskFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.TaskFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload>;
+                };
+                findFirst: {
+                    args: Prisma.TaskFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.TaskFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload>;
+                };
+                findMany: {
+                    args: Prisma.TaskFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload>[];
+                };
+                create: {
+                    args: Prisma.TaskCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload>;
+                };
+                createMany: {
+                    args: Prisma.TaskCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.TaskCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload>[];
+                };
+                delete: {
+                    args: Prisma.TaskDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload>;
+                };
+                update: {
+                    args: Prisma.TaskUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.TaskDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.TaskUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.TaskUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload>[];
+                };
+                upsert: {
+                    args: Prisma.TaskUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$TaskPayload>;
+                };
+                aggregate: {
+                    args: Prisma.TaskAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateTask>;
+                };
+                groupBy: {
+                    args: Prisma.TaskGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.TaskGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.TaskCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.TaskCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Secret: {
+            payload: Prisma.$SecretPayload<ExtArgs>;
+            fields: Prisma.SecretFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SecretFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SecretFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload>;
+                };
+                findFirst: {
+                    args: Prisma.SecretFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SecretFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload>;
+                };
+                findMany: {
+                    args: Prisma.SecretFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload>[];
+                };
+                create: {
+                    args: Prisma.SecretCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload>;
+                };
+                createMany: {
+                    args: Prisma.SecretCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SecretCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload>[];
+                };
+                delete: {
+                    args: Prisma.SecretDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload>;
+                };
+                update: {
+                    args: Prisma.SecretUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SecretDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SecretUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SecretUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload>[];
+                };
+                upsert: {
+                    args: Prisma.SecretUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretPayload>;
+                };
+                aggregate: {
+                    args: Prisma.SecretAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSecret>;
+                };
+                groupBy: {
+                    args: Prisma.SecretGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SecretGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SecretCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SecretCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AgentSecret: {
+            payload: Prisma.$AgentSecretPayload<ExtArgs>;
+            fields: Prisma.AgentSecretFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AgentSecretFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AgentSecretFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AgentSecretFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AgentSecretFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload>;
+                };
+                findMany: {
+                    args: Prisma.AgentSecretFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload>[];
+                };
+                create: {
+                    args: Prisma.AgentSecretCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload>;
+                };
+                createMany: {
+                    args: Prisma.AgentSecretCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AgentSecretCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload>[];
+                };
+                delete: {
+                    args: Prisma.AgentSecretDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload>;
+                };
+                update: {
+                    args: Prisma.AgentSecretUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AgentSecretDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AgentSecretUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AgentSecretUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AgentSecretUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AgentSecretPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AgentSecretAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAgentSecret>;
+                };
+                groupBy: {
+                    args: Prisma.AgentSecretGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentSecretGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AgentSecretCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AgentSecretCountAggregateOutputType> | number;
+                };
+            };
+        };
+        SecretElicitationOutcome: {
+            payload: Prisma.$SecretElicitationOutcomePayload<ExtArgs>;
+            fields: Prisma.SecretElicitationOutcomeFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.SecretElicitationOutcomeFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.SecretElicitationOutcomeFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload>;
+                };
+                findFirst: {
+                    args: Prisma.SecretElicitationOutcomeFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.SecretElicitationOutcomeFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload>;
+                };
+                findMany: {
+                    args: Prisma.SecretElicitationOutcomeFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload>[];
+                };
+                create: {
+                    args: Prisma.SecretElicitationOutcomeCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload>;
+                };
+                createMany: {
+                    args: Prisma.SecretElicitationOutcomeCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.SecretElicitationOutcomeCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload>[];
+                };
+                delete: {
+                    args: Prisma.SecretElicitationOutcomeDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload>;
+                };
+                update: {
+                    args: Prisma.SecretElicitationOutcomeUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.SecretElicitationOutcomeDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.SecretElicitationOutcomeUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.SecretElicitationOutcomeUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload>[];
+                };
+                upsert: {
+                    args: Prisma.SecretElicitationOutcomeUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$SecretElicitationOutcomePayload>;
+                };
+                aggregate: {
+                    args: Prisma.SecretElicitationOutcomeAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateSecretElicitationOutcome>;
+                };
+                groupBy: {
+                    args: Prisma.SecretElicitationOutcomeGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SecretElicitationOutcomeGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.SecretElicitationOutcomeCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.SecretElicitationOutcomeCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Webhook: {
+            payload: Prisma.$WebhookPayload<ExtArgs>;
+            fields: Prisma.WebhookFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WebhookFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WebhookFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WebhookFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WebhookFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload>;
+                };
+                findMany: {
+                    args: Prisma.WebhookFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload>[];
+                };
+                create: {
+                    args: Prisma.WebhookCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload>;
+                };
+                createMany: {
+                    args: Prisma.WebhookCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WebhookCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload>[];
+                };
+                delete: {
+                    args: Prisma.WebhookDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload>;
+                };
+                update: {
+                    args: Prisma.WebhookUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WebhookDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WebhookUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WebhookUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WebhookUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WebhookPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WebhookAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWebhook>;
+                };
+                groupBy: {
+                    args: Prisma.WebhookGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WebhookGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WebhookCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WebhookCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OAuthClient: {
+            payload: Prisma.$OAuthClientPayload<ExtArgs>;
+            fields: Prisma.OAuthClientFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OAuthClientFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OAuthClientFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OAuthClientFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OAuthClientFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload>;
+                };
+                findMany: {
+                    args: Prisma.OAuthClientFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload>[];
+                };
+                create: {
+                    args: Prisma.OAuthClientCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload>;
+                };
+                createMany: {
+                    args: Prisma.OAuthClientCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OAuthClientCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload>[];
+                };
+                delete: {
+                    args: Prisma.OAuthClientDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload>;
+                };
+                update: {
+                    args: Prisma.OAuthClientUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OAuthClientDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OAuthClientUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OAuthClientUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OAuthClientUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthClientPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OAuthClientAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOAuthClient>;
+                };
+                groupBy: {
+                    args: Prisma.OAuthClientGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthClientGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OAuthClientCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthClientCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OAuthGrant: {
+            payload: Prisma.$OAuthGrantPayload<ExtArgs>;
+            fields: Prisma.OAuthGrantFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OAuthGrantFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OAuthGrantFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OAuthGrantFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OAuthGrantFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload>;
+                };
+                findMany: {
+                    args: Prisma.OAuthGrantFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload>[];
+                };
+                create: {
+                    args: Prisma.OAuthGrantCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload>;
+                };
+                createMany: {
+                    args: Prisma.OAuthGrantCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OAuthGrantCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload>[];
+                };
+                delete: {
+                    args: Prisma.OAuthGrantDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload>;
+                };
+                update: {
+                    args: Prisma.OAuthGrantUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OAuthGrantDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OAuthGrantUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OAuthGrantUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OAuthGrantUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthGrantPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OAuthGrantAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOAuthGrant>;
+                };
+                groupBy: {
+                    args: Prisma.OAuthGrantGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthGrantGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OAuthGrantCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthGrantCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AuthUser: {
+            payload: Prisma.$AuthUserPayload<ExtArgs>;
+            fields: Prisma.AuthUserFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AuthUserFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AuthUserFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AuthUserFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AuthUserFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload>;
+                };
+                findMany: {
+                    args: Prisma.AuthUserFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload>[];
+                };
+                create: {
+                    args: Prisma.AuthUserCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload>;
+                };
+                createMany: {
+                    args: Prisma.AuthUserCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AuthUserCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload>[];
+                };
+                delete: {
+                    args: Prisma.AuthUserDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload>;
+                };
+                update: {
+                    args: Prisma.AuthUserUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AuthUserDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AuthUserUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AuthUserUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AuthUserUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthUserPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AuthUserAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAuthUser>;
+                };
+                groupBy: {
+                    args: Prisma.AuthUserGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuthUserGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AuthUserCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuthUserCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AuthLoginKey: {
+            payload: Prisma.$AuthLoginKeyPayload<ExtArgs>;
+            fields: Prisma.AuthLoginKeyFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AuthLoginKeyFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AuthLoginKeyFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AuthLoginKeyFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AuthLoginKeyFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload>;
+                };
+                findMany: {
+                    args: Prisma.AuthLoginKeyFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload>[];
+                };
+                create: {
+                    args: Prisma.AuthLoginKeyCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload>;
+                };
+                createMany: {
+                    args: Prisma.AuthLoginKeyCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AuthLoginKeyCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload>[];
+                };
+                delete: {
+                    args: Prisma.AuthLoginKeyDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload>;
+                };
+                update: {
+                    args: Prisma.AuthLoginKeyUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AuthLoginKeyDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AuthLoginKeyUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AuthLoginKeyUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AuthLoginKeyUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthLoginKeyPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AuthLoginKeyAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAuthLoginKey>;
+                };
+                groupBy: {
+                    args: Prisma.AuthLoginKeyGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuthLoginKeyGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AuthLoginKeyCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuthLoginKeyCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AuthSession: {
+            payload: Prisma.$AuthSessionPayload<ExtArgs>;
+            fields: Prisma.AuthSessionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AuthSessionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AuthSessionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AuthSessionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AuthSessionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload>;
+                };
+                findMany: {
+                    args: Prisma.AuthSessionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload>[];
+                };
+                create: {
+                    args: Prisma.AuthSessionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload>;
+                };
+                createMany: {
+                    args: Prisma.AuthSessionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AuthSessionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload>[];
+                };
+                delete: {
+                    args: Prisma.AuthSessionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload>;
+                };
+                update: {
+                    args: Prisma.AuthSessionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AuthSessionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AuthSessionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AuthSessionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AuthSessionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthSessionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AuthSessionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAuthSession>;
+                };
+                groupBy: {
+                    args: Prisma.AuthSessionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuthSessionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AuthSessionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuthSessionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AuthFormChallenge: {
+            payload: Prisma.$AuthFormChallengePayload<ExtArgs>;
+            fields: Prisma.AuthFormChallengeFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AuthFormChallengeFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AuthFormChallengeFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload>;
+                };
+                findFirst: {
+                    args: Prisma.AuthFormChallengeFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AuthFormChallengeFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload>;
+                };
+                findMany: {
+                    args: Prisma.AuthFormChallengeFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload>[];
+                };
+                create: {
+                    args: Prisma.AuthFormChallengeCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload>;
+                };
+                createMany: {
+                    args: Prisma.AuthFormChallengeCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AuthFormChallengeCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload>[];
+                };
+                delete: {
+                    args: Prisma.AuthFormChallengeDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload>;
+                };
+                update: {
+                    args: Prisma.AuthFormChallengeUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AuthFormChallengeDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AuthFormChallengeUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AuthFormChallengeUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload>[];
+                };
+                upsert: {
+                    args: Prisma.AuthFormChallengeUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthFormChallengePayload>;
+                };
+                aggregate: {
+                    args: Prisma.AuthFormChallengeAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAuthFormChallenge>;
+                };
+                groupBy: {
+                    args: Prisma.AuthFormChallengeGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuthFormChallengeGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AuthFormChallengeCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuthFormChallengeCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OAuthAuthorizationRequest: {
+            payload: Prisma.$OAuthAuthorizationRequestPayload<ExtArgs>;
+            fields: Prisma.OAuthAuthorizationRequestFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OAuthAuthorizationRequestFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OAuthAuthorizationRequestFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OAuthAuthorizationRequestFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OAuthAuthorizationRequestFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload>;
+                };
+                findMany: {
+                    args: Prisma.OAuthAuthorizationRequestFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload>[];
+                };
+                create: {
+                    args: Prisma.OAuthAuthorizationRequestCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload>;
+                };
+                createMany: {
+                    args: Prisma.OAuthAuthorizationRequestCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OAuthAuthorizationRequestCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload>[];
+                };
+                delete: {
+                    args: Prisma.OAuthAuthorizationRequestDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload>;
+                };
+                update: {
+                    args: Prisma.OAuthAuthorizationRequestUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OAuthAuthorizationRequestDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OAuthAuthorizationRequestUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OAuthAuthorizationRequestUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OAuthAuthorizationRequestUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationRequestPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OAuthAuthorizationRequestAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOAuthAuthorizationRequest>;
+                };
+                groupBy: {
+                    args: Prisma.OAuthAuthorizationRequestGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthAuthorizationRequestGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OAuthAuthorizationRequestCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthAuthorizationRequestCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OAuthAuthorizationCode: {
+            payload: Prisma.$OAuthAuthorizationCodePayload<ExtArgs>;
+            fields: Prisma.OAuthAuthorizationCodeFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OAuthAuthorizationCodeFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OAuthAuthorizationCodeFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload>;
+                };
+                findFirst: {
+                    args: Prisma.OAuthAuthorizationCodeFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OAuthAuthorizationCodeFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload>;
+                };
+                findMany: {
+                    args: Prisma.OAuthAuthorizationCodeFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload>[];
+                };
+                create: {
+                    args: Prisma.OAuthAuthorizationCodeCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload>;
+                };
+                createMany: {
+                    args: Prisma.OAuthAuthorizationCodeCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OAuthAuthorizationCodeCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload>[];
+                };
+                delete: {
+                    args: Prisma.OAuthAuthorizationCodeDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload>;
+                };
+                update: {
+                    args: Prisma.OAuthAuthorizationCodeUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OAuthAuthorizationCodeDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OAuthAuthorizationCodeUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OAuthAuthorizationCodeUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload>[];
+                };
+                upsert: {
+                    args: Prisma.OAuthAuthorizationCodeUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthAuthorizationCodePayload>;
+                };
+                aggregate: {
+                    args: Prisma.OAuthAuthorizationCodeAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOAuthAuthorizationCode>;
+                };
+                groupBy: {
+                    args: Prisma.OAuthAuthorizationCodeGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthAuthorizationCodeGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OAuthAuthorizationCodeCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthAuthorizationCodeCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OAuthFamily: {
+            payload: Prisma.$OAuthFamilyPayload<ExtArgs>;
+            fields: Prisma.OAuthFamilyFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OAuthFamilyFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OAuthFamilyFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OAuthFamilyFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OAuthFamilyFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload>;
+                };
+                findMany: {
+                    args: Prisma.OAuthFamilyFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload>[];
+                };
+                create: {
+                    args: Prisma.OAuthFamilyCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload>;
+                };
+                createMany: {
+                    args: Prisma.OAuthFamilyCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OAuthFamilyCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload>[];
+                };
+                delete: {
+                    args: Prisma.OAuthFamilyDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload>;
+                };
+                update: {
+                    args: Prisma.OAuthFamilyUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OAuthFamilyDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OAuthFamilyUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OAuthFamilyUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OAuthFamilyUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OAuthFamilyPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OAuthFamilyAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOAuthFamily>;
+                };
+                groupBy: {
+                    args: Prisma.OAuthFamilyGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthFamilyGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OAuthFamilyCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OAuthFamilyCountAggregateOutputType> | number;
+                };
+            };
+        };
+        AuthRateLimit: {
+            payload: Prisma.$AuthRateLimitPayload<ExtArgs>;
+            fields: Prisma.AuthRateLimitFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.AuthRateLimitFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.AuthRateLimitFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload>;
+                };
+                findFirst: {
+                    args: Prisma.AuthRateLimitFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.AuthRateLimitFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload>;
+                };
+                findMany: {
+                    args: Prisma.AuthRateLimitFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload>[];
+                };
+                create: {
+                    args: Prisma.AuthRateLimitCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload>;
+                };
+                createMany: {
+                    args: Prisma.AuthRateLimitCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.AuthRateLimitCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload>[];
+                };
+                delete: {
+                    args: Prisma.AuthRateLimitDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload>;
+                };
+                update: {
+                    args: Prisma.AuthRateLimitUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.AuthRateLimitDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.AuthRateLimitUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.AuthRateLimitUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload>[];
+                };
+                upsert: {
+                    args: Prisma.AuthRateLimitUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$AuthRateLimitPayload>;
+                };
+                aggregate: {
+                    args: Prisma.AuthRateLimitAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateAuthRateLimit>;
+                };
+                groupBy: {
+                    args: Prisma.AuthRateLimitGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuthRateLimitGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.AuthRateLimitCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AuthRateLimitCountAggregateOutputType> | 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 ReadUncommitted: "ReadUncommitted";
+    readonly ReadCommitted: "ReadCommitted";
+    readonly RepeatableRead: "RepeatableRead";
+    readonly Serializable: "Serializable";
+};
+export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel];
+export declare const AgentScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly systemPrompt: "systemPrompt";
+    readonly model: "model";
+    readonly budgetUsd: "budgetUsd";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly kind: "kind";
+    readonly schedule: "schedule";
+    readonly timezone: "timezone";
+    readonly scheduleEnabled: "scheduleEnabled";
+    readonly lastScheduledAt: "lastScheduledAt";
+    readonly maxTurns: "maxTurns";
+    readonly ownerId: "ownerId";
+    readonly budgetGroupId: "budgetGroupId";
+    readonly memoryEnabled: "memoryEnabled";
+};
+export type AgentScalarFieldEnum = (typeof AgentScalarFieldEnum)[keyof typeof AgentScalarFieldEnum];
+export declare const AgentSubAgentScalarFieldEnum: {
+    readonly parentAgentId: "parentAgentId";
+    readonly childAgentId: "childAgentId";
+    readonly boundName: "boundName";
+};
+export type AgentSubAgentScalarFieldEnum = (typeof AgentSubAgentScalarFieldEnum)[keyof typeof AgentSubAgentScalarFieldEnum];
+export declare const BudgetGroupScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly ownerId: "ownerId";
+    readonly dailyBudgetUsd: "dailyBudgetUsd";
+    readonly weeklyBudgetUsd: "weeklyBudgetUsd";
+    readonly monthlyBudgetUsd: "monthlyBudgetUsd";
+    readonly warnThresholdRatio: "warnThresholdRatio";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type BudgetGroupScalarFieldEnum = (typeof BudgetGroupScalarFieldEnum)[keyof typeof BudgetGroupScalarFieldEnum];
+export declare const ToolScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly description: "description";
+    readonly paramsZod: "paramsZod";
+    readonly jsonSchema: "jsonSchema";
+    readonly code: "code";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly ownerId: "ownerId";
+};
+export type ToolScalarFieldEnum = (typeof ToolScalarFieldEnum)[keyof typeof ToolScalarFieldEnum];
+export declare const AgentToolScalarFieldEnum: {
+    readonly agentId: "agentId";
+    readonly toolId: "toolId";
+    readonly allowedSecrets: "allowedSecrets";
+    readonly allowedDatastorePrefixes: "allowedDatastorePrefixes";
+    readonly allowedHosts: "allowedHosts";
+    readonly allowedSharedDatastorePrefixes: "allowedSharedDatastorePrefixes";
+};
+export type AgentToolScalarFieldEnum = (typeof AgentToolScalarFieldEnum)[keyof typeof AgentToolScalarFieldEnum];
+export declare const DatastoreScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly ownerId: "ownerId";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type DatastoreScalarFieldEnum = (typeof DatastoreScalarFieldEnum)[keyof typeof DatastoreScalarFieldEnum];
+export declare const AgentDatastoreScalarFieldEnum: {
+    readonly agentId: "agentId";
+    readonly datastoreId: "datastoreId";
+    readonly boundName: "boundName";
+};
+export type AgentDatastoreScalarFieldEnum = (typeof AgentDatastoreScalarFieldEnum)[keyof typeof AgentDatastoreScalarFieldEnum];
+export declare const DatastoreEntryScalarFieldEnum: {
+    readonly id: "id";
+    readonly agentId: "agentId";
+    readonly datastoreId: "datastoreId";
+    readonly key: "key";
+    readonly value: "value";
+    readonly pii: "pii";
+    readonly keyId: "keyId";
+    readonly updatedAt: "updatedAt";
+};
+export type DatastoreEntryScalarFieldEnum = (typeof DatastoreEntryScalarFieldEnum)[keyof typeof DatastoreEntryScalarFieldEnum];
+export declare const AgentMemoryScalarFieldEnum: {
+    readonly agentId: "agentId";
+    readonly key: "key";
+    readonly content: "content";
+    readonly updatedAt: "updatedAt";
+};
+export type AgentMemoryScalarFieldEnum = (typeof AgentMemoryScalarFieldEnum)[keyof typeof AgentMemoryScalarFieldEnum];
+export declare const RunScalarFieldEnum: {
+    readonly id: "id";
+    readonly agentId: "agentId";
+    readonly status: "status";
+    readonly trigger: "trigger";
+    readonly tokensIn: "tokensIn";
+    readonly tokensOut: "tokensOut";
+    readonly costUsd: "costUsd";
+    readonly error: "error";
+    readonly startedAt: "startedAt";
+    readonly finishedAt: "finishedAt";
+    readonly heartbeatAt: "heartbeatAt";
+    readonly finalText: "finalText";
+    readonly turns: "turns";
+    readonly executionManaged: "executionManaged";
+    readonly executionBackend: "executionBackend";
+    readonly parentRunId: "parentRunId";
+    readonly grantedParentMemoryKeys: "grantedParentMemoryKeys";
+    readonly taskOverride: "taskOverride";
+};
+export type RunScalarFieldEnum = (typeof RunScalarFieldEnum)[keyof typeof RunScalarFieldEnum];
+export declare const CodingAgentProfileScalarFieldEnum: {
+    readonly agentId: "agentId";
+    readonly provider: "provider";
+    readonly repository: "repository";
+    readonly baseRef: "baseRef";
+    readonly defaultTask: "defaultTask";
+    readonly allowWebhookTaskOverride: "allowWebhookTaskOverride";
+    readonly timeoutSec: "timeoutSec";
+    readonly allowedEgress: "allowedEgress";
+    readonly protectedPaths: "protectedPaths";
+    readonly toolchain: "toolchain";
+    readonly toolchainVersion: "toolchainVersion";
+    readonly workerImageRef: "workerImageRef";
+    readonly workspaceDiskMb: "workspaceDiskMb";
+};
+export type CodingAgentProfileScalarFieldEnum = (typeof CodingAgentProfileScalarFieldEnum)[keyof typeof CodingAgentProfileScalarFieldEnum];
+export declare const CodingRunScalarFieldEnum: {
+    readonly runId: "runId";
+    readonly task: "task";
+    readonly repository: "repository";
+    readonly baseRef: "baseRef";
+    readonly headRef: "headRef";
+    readonly provider: "provider";
+    readonly model: "model";
+    readonly timeoutSec: "timeoutSec";
+    readonly allowedEgress: "allowedEgress";
+    readonly protectedPaths: "protectedPaths";
+    readonly jobBackend: "jobBackend";
+    readonly jobHandle: "jobHandle";
+    readonly result: "result";
+    readonly resultSchema: "resultSchema";
+    readonly failureCategory: "failureCategory";
+    readonly diagnosticId: "diagnosticId";
+    readonly workerImage: "workerImage";
+    readonly budgetReservedUsd: "budgetReservedUsd";
+    readonly queuedAt: "queuedAt";
+    readonly workspaceDiskMb: "workspaceDiskMb";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly rootCodingRunId: "rootCodingRunId";
+};
+export type CodingRunScalarFieldEnum = (typeof CodingRunScalarFieldEnum)[keyof typeof CodingRunScalarFieldEnum];
+export declare const CodingProxySessionScalarFieldEnum: {
+    readonly id: "id";
+    readonly runId: "runId";
+    readonly capabilityHash: "capabilityHash";
+    readonly credentialRef: "credentialRef";
+    readonly protocol: "protocol";
+    readonly allowedModels: "allowedModels";
+    readonly deadlineAt: "deadlineAt";
+    readonly budgetUsd: "budgetUsd";
+    readonly status: "status";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type CodingProxySessionScalarFieldEnum = (typeof CodingProxySessionScalarFieldEnum)[keyof typeof CodingProxySessionScalarFieldEnum];
+export declare const CodingProxyRequestScalarFieldEnum: {
+    readonly id: "id";
+    readonly sessionId: "sessionId";
+    readonly requestKey: "requestKey";
+    readonly requestFingerprint: "requestFingerprint";
+    readonly model: "model";
+    readonly status: "status";
+    readonly reservationUsd: "reservationUsd";
+    readonly actualCostUsd: "actualCostUsd";
+    readonly pricingVersion: "pricingVersion";
+    readonly pricingSnapshot: "pricingSnapshot";
+    readonly inputTokens: "inputTokens";
+    readonly outputTokens: "outputTokens";
+    readonly cachedInputTokens: "cachedInputTokens";
+    readonly cacheWriteTokens: "cacheWriteTokens";
+    readonly reasoningTokens: "reasoningTokens";
+    readonly upstreamStatus: "upstreamStatus";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+    readonly completedAt: "completedAt";
+};
+export type CodingProxyRequestScalarFieldEnum = (typeof CodingProxyRequestScalarFieldEnum)[keyof typeof CodingProxyRequestScalarFieldEnum];
+export declare const SchedulerLeaseScalarFieldEnum: {
+    readonly scope: "scope";
+    readonly holder: "holder";
+    readonly expiresAt: "expiresAt";
+    readonly updatedAt: "updatedAt";
+};
+export type SchedulerLeaseScalarFieldEnum = (typeof SchedulerLeaseScalarFieldEnum)[keyof typeof SchedulerLeaseScalarFieldEnum];
+export declare const PrincipalScalarFieldEnum: {
+    readonly id: "id";
+    readonly subject: "subject";
+    readonly createdAt: "createdAt";
+};
+export type PrincipalScalarFieldEnum = (typeof PrincipalScalarFieldEnum)[keyof typeof PrincipalScalarFieldEnum];
+export declare const TaskScalarFieldEnum: {
+    readonly id: "id";
+    readonly kind: "kind";
+    readonly runId: "runId";
+    readonly principalId: "principalId";
+    readonly status: "status";
+    readonly inputRequests: "inputRequests";
+    readonly inputResponses: "inputResponses";
+    readonly result: "result";
+    readonly error: "error";
+    readonly ttlAt: "ttlAt";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type TaskScalarFieldEnum = (typeof TaskScalarFieldEnum)[keyof typeof TaskScalarFieldEnum];
+export declare const SecretScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly ciphertext: "ciphertext";
+    readonly keyId: "keyId";
+    readonly ownerId: "ownerId";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type SecretScalarFieldEnum = (typeof SecretScalarFieldEnum)[keyof typeof SecretScalarFieldEnum];
+export declare const AgentSecretScalarFieldEnum: {
+    readonly agentId: "agentId";
+    readonly secretId: "secretId";
+    readonly boundName: "boundName";
+};
+export type AgentSecretScalarFieldEnum = (typeof AgentSecretScalarFieldEnum)[keyof typeof AgentSecretScalarFieldEnum];
+export declare const SecretElicitationOutcomeScalarFieldEnum: {
+    readonly ownerId: "ownerId";
+    readonly secretName: "secretName";
+    readonly outcome: "outcome";
+    readonly expiresAt: "expiresAt";
+};
+export type SecretElicitationOutcomeScalarFieldEnum = (typeof SecretElicitationOutcomeScalarFieldEnum)[keyof typeof SecretElicitationOutcomeScalarFieldEnum];
+export declare const WebhookScalarFieldEnum: {
+    readonly id: "id";
+    readonly agentId: "agentId";
+    readonly secretHash: "secretHash";
+    readonly status: "status";
+    readonly ownerId: "ownerId";
+    readonly createdAt: "createdAt";
+    readonly lastFiredAt: "lastFiredAt";
+};
+export type WebhookScalarFieldEnum = (typeof WebhookScalarFieldEnum)[keyof typeof WebhookScalarFieldEnum];
+export declare const OAuthClientScalarFieldEnum: {
+    readonly clientId: "clientId";
+    readonly metadata: "metadata";
+    readonly createdAt: "createdAt";
+};
+export type OAuthClientScalarFieldEnum = (typeof OAuthClientScalarFieldEnum)[keyof typeof OAuthClientScalarFieldEnum];
+export declare const OAuthGrantScalarFieldEnum: {
+    readonly id: "id";
+    readonly familyId: "familyId";
+    readonly refreshTokenHash: "refreshTokenHash";
+    readonly expiresAt: "expiresAt";
+    readonly createdAt: "createdAt";
+    readonly consumedAt: "consumedAt";
+    readonly revokedAt: "revokedAt";
+    readonly replacedById: "replacedById";
+};
+export type OAuthGrantScalarFieldEnum = (typeof OAuthGrantScalarFieldEnum)[keyof typeof OAuthGrantScalarFieldEnum];
+export declare const AuthUserScalarFieldEnum: {
+    readonly id: "id";
+    readonly principalId: "principalId";
+    readonly displayName: "displayName";
+    readonly status: "status";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type AuthUserScalarFieldEnum = (typeof AuthUserScalarFieldEnum)[keyof typeof AuthUserScalarFieldEnum];
+export declare const AuthLoginKeyScalarFieldEnum: {
+    readonly keyId: "keyId";
+    readonly userId: "userId";
+    readonly secretHash: "secretHash";
+    readonly createdAt: "createdAt";
+    readonly lastUsedAt: "lastUsedAt";
+    readonly expiresAt: "expiresAt";
+    readonly revokedAt: "revokedAt";
+};
+export type AuthLoginKeyScalarFieldEnum = (typeof AuthLoginKeyScalarFieldEnum)[keyof typeof AuthLoginKeyScalarFieldEnum];
+export declare const AuthSessionScalarFieldEnum: {
+    readonly sessionId: "sessionId";
+    readonly userId: "userId";
+    readonly secretHash: "secretHash";
+    readonly createdAt: "createdAt";
+    readonly lastSeenAt: "lastSeenAt";
+    readonly expiresAt: "expiresAt";
+    readonly revokedAt: "revokedAt";
+};
+export type AuthSessionScalarFieldEnum = (typeof AuthSessionScalarFieldEnum)[keyof typeof AuthSessionScalarFieldEnum];
+export declare const AuthFormChallengeScalarFieldEnum: {
+    readonly challengeId: "challengeId";
+    readonly sessionId: "sessionId";
+    readonly purpose: "purpose";
+    readonly binding: "binding";
+    readonly secretHash: "secretHash";
+    readonly createdAt: "createdAt";
+    readonly expiresAt: "expiresAt";
+    readonly consumedAt: "consumedAt";
+};
+export type AuthFormChallengeScalarFieldEnum = (typeof AuthFormChallengeScalarFieldEnum)[keyof typeof AuthFormChallengeScalarFieldEnum];
+export declare const OAuthAuthorizationRequestScalarFieldEnum: {
+    readonly id: "id";
+    readonly clientId: "clientId";
+    readonly redirectUri: "redirectUri";
+    readonly resource: "resource";
+    readonly requestedScope: "requestedScope";
+    readonly codeChallenge: "codeChallenge";
+    readonly state: "state";
+    readonly createdAt: "createdAt";
+    readonly expiresAt: "expiresAt";
+    readonly consumedAt: "consumedAt";
+};
+export type OAuthAuthorizationRequestScalarFieldEnum = (typeof OAuthAuthorizationRequestScalarFieldEnum)[keyof typeof OAuthAuthorizationRequestScalarFieldEnum];
+export declare const OAuthAuthorizationCodeScalarFieldEnum: {
+    readonly codeId: "codeId";
+    readonly secretHash: "secretHash";
+    readonly clientId: "clientId";
+    readonly userId: "userId";
+    readonly redirectUri: "redirectUri";
+    readonly resource: "resource";
+    readonly scope: "scope";
+    readonly codeChallenge: "codeChallenge";
+    readonly createdAt: "createdAt";
+    readonly expiresAt: "expiresAt";
+    readonly consumedAt: "consumedAt";
+};
+export type OAuthAuthorizationCodeScalarFieldEnum = (typeof OAuthAuthorizationCodeScalarFieldEnum)[keyof typeof OAuthAuthorizationCodeScalarFieldEnum];
+export declare const OAuthFamilyScalarFieldEnum: {
+    readonly id: "id";
+    readonly clientId: "clientId";
+    readonly userId: "userId";
+    readonly scope: "scope";
+    readonly resource: "resource";
+    readonly expiresAt: "expiresAt";
+    readonly revokedAt: "revokedAt";
+    readonly createdAt: "createdAt";
+};
+export type OAuthFamilyScalarFieldEnum = (typeof OAuthFamilyScalarFieldEnum)[keyof typeof OAuthFamilyScalarFieldEnum];
+export declare const AuthRateLimitScalarFieldEnum: {
+    readonly key: "key";
+    readonly hits: "hits";
+    readonly expiresAt: "expiresAt";
+};
+export type AuthRateLimitScalarFieldEnum = (typeof AuthRateLimitScalarFieldEnum)[keyof typeof AuthRateLimitScalarFieldEnum];
+export declare const SortOrder: {
+    readonly asc: "asc";
+    readonly desc: "desc";
+};
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
+export declare const JsonNullValueInput: {
+    readonly JsonNull: runtime.JsonNullClass;
+};
+export type JsonNullValueInput = (typeof JsonNullValueInput)[keyof typeof JsonNullValueInput];
+export declare const NullableJsonNullValueInput: {
+    readonly DbNull: runtime.DbNullClass;
+    readonly JsonNull: runtime.JsonNullClass;
+};
+export type NullableJsonNullValueInput = (typeof NullableJsonNullValueInput)[keyof typeof NullableJsonNullValueInput];
+export declare const QueryMode: {
+    readonly default: "default";
+    readonly insensitive: "insensitive";
+};
+export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode];
+export declare const NullsOrder: {
+    readonly first: "first";
+    readonly last: "last";
+};
+export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder];
+export declare const JsonNullValueFilter: {
+    readonly DbNull: runtime.DbNullClass;
+    readonly JsonNull: runtime.JsonNullClass;
+    readonly AnyNull: runtime.AnyNullClass;
+};
+export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter];
+/**
+ * Field references
+ */
+/**
+ * Reference to a field of type 'String'
+ */
+export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>;
+/**
+ * Reference to a field of type 'String[]'
+ */
+export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>;
+/**
+ * Reference to a field of type 'Decimal'
+ */
+export type DecimalFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Decimal'>;
+/**
+ * Reference to a field of type 'Decimal[]'
+ */
+export type ListDecimalFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Decimal[]'>;
+/**
+ * Reference to a field of type 'DateTime'
+ */
+export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>;
+/**
+ * Reference to a field of type 'DateTime[]'
+ */
+export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>;
+/**
+ * Reference to a field of type 'AgentKind'
+ */
+export type EnumAgentKindFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AgentKind'>;
+/**
+ * Reference to a field of type 'AgentKind[]'
+ */
+export type ListEnumAgentKindFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AgentKind[]'>;
+/**
+ * Reference to a field of type 'Boolean'
+ */
+export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>;
+/**
+ * Reference to a field of type 'Int'
+ */
+export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>;
+/**
+ * Reference to a field of type 'Int[]'
+ */
+export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>;
+/**
+ * Reference to a field of type 'Json'
+ */
+export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>;
+/**
+ * Reference to a field of type 'QueryMode'
+ */
+export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>;
+/**
+ * Reference to a field of type 'RunStatus'
+ */
+export type EnumRunStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RunStatus'>;
+/**
+ * Reference to a field of type 'RunStatus[]'
+ */
+export type ListEnumRunStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RunStatus[]'>;
+/**
+ * Reference to a field of type 'RunTrigger'
+ */
+export type EnumRunTriggerFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RunTrigger'>;
+/**
+ * Reference to a field of type 'RunTrigger[]'
+ */
+export type ListEnumRunTriggerFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RunTrigger[]'>;
+/**
+ * Reference to a field of type 'CodingProxySessionStatus'
+ */
+export type EnumCodingProxySessionStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CodingProxySessionStatus'>;
+/**
+ * Reference to a field of type 'CodingProxySessionStatus[]'
+ */
+export type ListEnumCodingProxySessionStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CodingProxySessionStatus[]'>;
+/**
+ * Reference to a field of type 'CodingProxyRequestStatus'
+ */
+export type EnumCodingProxyRequestStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CodingProxyRequestStatus'>;
+/**
+ * Reference to a field of type 'CodingProxyRequestStatus[]'
+ */
+export type ListEnumCodingProxyRequestStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CodingProxyRequestStatus[]'>;
+/**
+ * Reference to a field of type 'TaskKind'
+ */
+export type EnumTaskKindFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TaskKind'>;
+/**
+ * Reference to a field of type 'TaskKind[]'
+ */
+export type ListEnumTaskKindFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TaskKind[]'>;
+/**
+ * Reference to a field of type 'TaskStatus'
+ */
+export type EnumTaskStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TaskStatus'>;
+/**
+ * Reference to a field of type 'TaskStatus[]'
+ */
+export type ListEnumTaskStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'TaskStatus[]'>;
+/**
+ * Reference to a field of type 'WebhookStatus'
+ */
+export type EnumWebhookStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WebhookStatus'>;
+/**
+ * Reference to a field of type 'WebhookStatus[]'
+ */
+export type ListEnumWebhookStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'WebhookStatus[]'>;
+/**
+ * Reference to a field of type 'Float'
+ */
+export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>;
+/**
+ * Reference to a field of type 'Float[]'
+ */
+export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>;
+/**
+ * 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';
+/**
+ * Options common to all variants of `PrismaClientOptions`, regardless of whether you connect to your database through a driver adapter or through Prisma Accelerate.
+ */
+export interface PrismaClientBaseOptions {
+    /**
+     * @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[];
+    /**
+     * Optional maximum size for the query plan cache. If not provided, a default size will be used.
+     * A value of `0` can be used to disable the cache entirely. A higher cache size can improve
+     * performance for applications that execute a large number of unique queries, while a smaller
+     * cache size can reduce memory usage.
+     *
+     * @example
+     * ```
+     * const prisma = new PrismaClient({
+     *   adapter,
+     *   queryPlanCacheMaxSize: 100,
+     * })
+     * ```
+     */
+    queryPlanCacheMaxSize?: number;
+}
+/**
+ * `PrismaClient` options for connecting to your database through Prisma Accelerate instead of a driver adapter.
+ *
+ * Learn more: https://pris.ly/d/accelerate
+ */
+export interface PrismaClientOptionsWithAccelerateUrl extends PrismaClientBaseOptions {
+    /**
+     * The Prisma Accelerate connection URL. Use this option to connect to your database through Prisma Accelerate instead of using a driver adapter to connect directly.
+     *
+     * Learn more: https://pris.ly/d/accelerate
+     */
+    accelerateUrl: string;
+    adapter?: never;
+}
+/**
+ * `PrismaClient` options for connecting to your database through a driver adapter. This is the common case in Prisma 7.
+ *
+ * Learn more: https://pris.ly/d/driver-adapters
+ */
+export interface PrismaClientOptionsWithAdapter extends PrismaClientBaseOptions {
+    /**
+     * A driver adapter that PrismaClient uses to connect to your database, such as the ones provided by `@prisma/adapter-pg`, `@prisma/adapter-libsql`, `@prisma/adapter-planetscale`, etc.
+     *
+     * A driver adapter is **required** unless you connect to your database through Prisma Accelerate (in which case use `accelerateUrl` instead).
+     *
+     * Learn more: https://pris.ly/d/driver-adapters
+     *
+     * @example
+     * ```ts
+     * import { PrismaPg } from '@prisma/adapter-pg'
+     * import { PrismaClient } from './generated/prisma/client'
+     *
+     * const adapter = new PrismaPg({ connectionString: process.env.DATABASE_URL })
+     * const prisma = new PrismaClient({ adapter })
+     * ```
+     */
+    adapter: runtime.SqlDriverAdapterFactory;
+    accelerateUrl?: never;
+}
+/**
+ * Options passed to the `PrismaClient` constructor.
+ *
+ * A driver adapter (or, alternatively, a Prisma Accelerate URL) is **required**. See {@link PrismaClientOptionsWithAdapter} and {@link PrismaClientOptionsWithAccelerateUrl} for the two variants. All other properties live in {@link PrismaClientBaseOptions} and are optional.
+ *
+ * Learn more about driver adapters: https://pris.ly/d/driver-adapters
+ */
+export type PrismaClientOptions = PrismaClientOptionsWithAccelerateUrl | PrismaClientOptionsWithAdapter;
+export type GlobalOmitConfig = {
+    agent?: Prisma.AgentOmit;
+    agentSubAgent?: Prisma.AgentSubAgentOmit;
+    budgetGroup?: Prisma.BudgetGroupOmit;
+    tool?: Prisma.ToolOmit;
+    agentTool?: Prisma.AgentToolOmit;
+    datastore?: Prisma.DatastoreOmit;
+    agentDatastore?: Prisma.AgentDatastoreOmit;
+    datastoreEntry?: Prisma.DatastoreEntryOmit;
+    agentMemory?: Prisma.AgentMemoryOmit;
+    run?: Prisma.RunOmit;
+    codingAgentProfile?: Prisma.CodingAgentProfileOmit;
+    codingRun?: Prisma.CodingRunOmit;
+    codingProxySession?: Prisma.CodingProxySessionOmit;
+    codingProxyRequest?: Prisma.CodingProxyRequestOmit;
+    schedulerLease?: Prisma.SchedulerLeaseOmit;
+    principal?: Prisma.PrincipalOmit;
+    task?: Prisma.TaskOmit;
+    secret?: Prisma.SecretOmit;
+    agentSecret?: Prisma.AgentSecretOmit;
+    secretElicitationOutcome?: Prisma.SecretElicitationOutcomeOmit;
+    webhook?: Prisma.WebhookOmit;
+    oAuthClient?: Prisma.OAuthClientOmit;
+    oAuthGrant?: Prisma.OAuthGrantOmit;
+    authUser?: Prisma.AuthUserOmit;
+    authLoginKey?: Prisma.AuthLoginKeyOmit;
+    authSession?: Prisma.AuthSessionOmit;
+    authFormChallenge?: Prisma.AuthFormChallengeOmit;
+    oAuthAuthorizationRequest?: Prisma.OAuthAuthorizationRequestOmit;
+    oAuthAuthorizationCode?: Prisma.OAuthAuthorizationCodeOmit;
+    oAuthFamily?: Prisma.OAuthFamilyOmit;
+    authRateLimit?: Prisma.AuthRateLimitOmit;
+};
+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>;