/**
 * Client
**/

import * as runtime from './runtime/library.js';
import $Types = runtime.Types // general types
import $Public = runtime.Types.Public
import $Utils = runtime.Types.Utils
import $Extensions = runtime.Types.Extensions
import $Result = runtime.Types.Result

export type PrismaPromise<T> = $Public.PrismaPromise<T>


/**
 * Model AWS_Policy_Role
 * 
 */
export type AWS_Policy_Role = $Result.DefaultSelection<Prisma.$AWS_Policy_RolePayload>
/**
 * Model Ai_Agent_Assistants
 * 
 */
export type Ai_Agent_Assistants = $Result.DefaultSelection<Prisma.$Ai_Agent_AssistantsPayload>
/**
 * Model Ai_Agent_Threads
 * 
 */
export type Ai_Agent_Threads = $Result.DefaultSelection<Prisma.$Ai_Agent_ThreadsPayload>
/**
 * Model Assistant
 * 
 */
export type Assistant = $Result.DefaultSelection<Prisma.$AssistantPayload>
/**
 * Model Chat
 * 
 */
export type Chat = $Result.DefaultSelection<Prisma.$ChatPayload>
/**
 * Model Disposition
 * 
 */
export type Disposition = $Result.DefaultSelection<Prisma.$DispositionPayload>
/**
 * Model Group
 * 
 */
export type Group = $Result.DefaultSelection<Prisma.$GroupPayload>
/**
 * Model GroupFile
 * 
 */
export type GroupFile = $Result.DefaultSelection<Prisma.$GroupFilePayload>
/**
 * Model InvitationCode
 * 
 */
export type InvitationCode = $Result.DefaultSelection<Prisma.$InvitationCodePayload>
/**
 * Model ai_agent_park_session
 * 
 */
export type ai_agent_park_session = $Result.DefaultSelection<Prisma.$ai_agent_park_sessionPayload>
/**
 * Model classroom_ob_comment
 * 
 */
export type classroom_ob_comment = $Result.DefaultSelection<Prisma.$classroom_ob_commentPayload>
/**
 * Model classroom_observation
 * 
 */
export type classroom_observation = $Result.DefaultSelection<Prisma.$classroom_observationPayload>
/**
 * Model course_resource
 * 
 */
export type course_resource = $Result.DefaultSelection<Prisma.$course_resourcePayload>
/**
 * Model knowledge_construction_doc
 * 
 */
export type knowledge_construction_doc = $Result.DefaultSelection<Prisma.$knowledge_construction_docPayload>
/**
 * Model meeting_trick
 * 
 */
export type meeting_trick = $Result.DefaultSelection<Prisma.$meeting_trickPayload>
/**
 * Model meeting_trick_chat
 * 
 */
export type meeting_trick_chat = $Result.DefaultSelection<Prisma.$meeting_trick_chatPayload>
/**
 * Model muti_agent_list
 * 
 */
export type muti_agent_list = $Result.DefaultSelection<Prisma.$muti_agent_listPayload>
/**
 * Model park_chat_file_list
 * 
 */
export type park_chat_file_list = $Result.DefaultSelection<Prisma.$park_chat_file_listPayload>
/**
 * Model token
 * 
 */
export type token = $Result.DefaultSelection<Prisma.$tokenPayload>

/**
 * ##  Prisma Client ʲˢ
 * 
 * Type-safe database client for TypeScript & Node.js
 * @example
 * ```
 * const prisma = new PrismaClient()
 * // Fetch zero or more AWS_Policy_Roles
 * const aWS_Policy_Roles = await prisma.aWS_Policy_Role.findMany()
 * ```
 *
 * 
 * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
 */
export class PrismaClient<
  ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
  U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never,
  ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs
> {
  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }

    /**
   * ##  Prisma Client ʲˢ
   * 
   * Type-safe database client for TypeScript & Node.js
   * @example
   * ```
   * const prisma = new PrismaClient()
   * // Fetch zero or more AWS_Policy_Roles
   * const aWS_Policy_Roles = await prisma.aWS_Policy_Role.findMany()
   * ```
   *
   * 
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
   */

  constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
  $on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): void;

  /**
   * Connect with the database
   */
  $connect(): $Utils.JsPromise<void>;

  /**
   * Disconnect from the database
   */
  $disconnect(): $Utils.JsPromise<void>;

  /**
   * Add a middleware
   * @deprecated since 4.16.0. For new code, prefer client extensions instead.
   * @see https://pris.ly/d/extensions
   */
  $use(cb: Prisma.Middleware): void

/**
   * Executes a prepared raw query and returns the number of affected rows.
   * @example
   * ```
   * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
   * ```
   * 
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;

  /**
   * Executes a raw query and returns the number of affected rows.
   * Susceptible to SQL injections, see documentation.
   * @example
   * ```
   * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
   * ```
   * 
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;

  /**
   * Performs a prepared raw query and returns the `SELECT` data.
   * @example
   * ```
   * const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
   * ```
   * 
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;

  /**
   * Performs a raw query and returns the `SELECT` data.
   * Susceptible to SQL injections, see documentation.
   * @example
   * ```
   * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
   * ```
   * 
   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
   */
  $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;

  /**
   * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
   * @example
   * ```
   * const [george, bob, alice] = await prisma.$transaction([
   *   prisma.user.create({ data: { name: 'George' } }),
   *   prisma.user.create({ data: { name: 'Bob' } }),
   *   prisma.user.create({ data: { name: 'Alice' } }),
   * ])
   * ```
   * 
   * Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
   */
  $transaction<P extends Prisma.PrismaPromise<any>[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<runtime.Types.Utils.UnwrapTuple<P>>

  $transaction<R>(fn: (prisma: Omit<PrismaClient, runtime.ITXClientDenyList>) => $Utils.JsPromise<R>, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise<R>


  $extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb, ExtArgs>

      /**
   * `prisma.aWS_Policy_Role`: Exposes CRUD operations for the **AWS_Policy_Role** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AWS_Policy_Roles
    * const aWS_Policy_Roles = await prisma.aWS_Policy_Role.findMany()
    * ```
    */
  get aWS_Policy_Role(): Prisma.AWS_Policy_RoleDelegate<ExtArgs>;

  /**
   * `prisma.ai_Agent_Assistants`: Exposes CRUD operations for the **Ai_Agent_Assistants** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Ai_Agent_Assistants
    * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.findMany()
    * ```
    */
  get ai_Agent_Assistants(): Prisma.Ai_Agent_AssistantsDelegate<ExtArgs>;

  /**
   * `prisma.ai_Agent_Threads`: Exposes CRUD operations for the **Ai_Agent_Threads** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Ai_Agent_Threads
    * const ai_Agent_Threads = await prisma.ai_Agent_Threads.findMany()
    * ```
    */
  get ai_Agent_Threads(): Prisma.Ai_Agent_ThreadsDelegate<ExtArgs>;

  /**
   * `prisma.assistant`: Exposes CRUD operations for the **Assistant** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Assistants
    * const assistants = await prisma.assistant.findMany()
    * ```
    */
  get assistant(): Prisma.AssistantDelegate<ExtArgs>;

  /**
   * `prisma.chat`: Exposes CRUD operations for the **Chat** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Chats
    * const chats = await prisma.chat.findMany()
    * ```
    */
  get chat(): Prisma.ChatDelegate<ExtArgs>;

  /**
   * `prisma.disposition`: Exposes CRUD operations for the **Disposition** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Dispositions
    * const dispositions = await prisma.disposition.findMany()
    * ```
    */
  get disposition(): Prisma.DispositionDelegate<ExtArgs>;

  /**
   * `prisma.group`: Exposes CRUD operations for the **Group** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Groups
    * const groups = await prisma.group.findMany()
    * ```
    */
  get group(): Prisma.GroupDelegate<ExtArgs>;

  /**
   * `prisma.groupFile`: Exposes CRUD operations for the **GroupFile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more GroupFiles
    * const groupFiles = await prisma.groupFile.findMany()
    * ```
    */
  get groupFile(): Prisma.GroupFileDelegate<ExtArgs>;

  /**
   * `prisma.invitationCode`: Exposes CRUD operations for the **InvitationCode** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more InvitationCodes
    * const invitationCodes = await prisma.invitationCode.findMany()
    * ```
    */
  get invitationCode(): Prisma.InvitationCodeDelegate<ExtArgs>;

  /**
   * `prisma.ai_agent_park_session`: Exposes CRUD operations for the **ai_agent_park_session** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Ai_agent_park_sessions
    * const ai_agent_park_sessions = await prisma.ai_agent_park_session.findMany()
    * ```
    */
  get ai_agent_park_session(): Prisma.ai_agent_park_sessionDelegate<ExtArgs>;

  /**
   * `prisma.classroom_ob_comment`: Exposes CRUD operations for the **classroom_ob_comment** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Classroom_ob_comments
    * const classroom_ob_comments = await prisma.classroom_ob_comment.findMany()
    * ```
    */
  get classroom_ob_comment(): Prisma.classroom_ob_commentDelegate<ExtArgs>;

  /**
   * `prisma.classroom_observation`: Exposes CRUD operations for the **classroom_observation** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Classroom_observations
    * const classroom_observations = await prisma.classroom_observation.findMany()
    * ```
    */
  get classroom_observation(): Prisma.classroom_observationDelegate<ExtArgs>;

  /**
   * `prisma.course_resource`: Exposes CRUD operations for the **course_resource** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Course_resources
    * const course_resources = await prisma.course_resource.findMany()
    * ```
    */
  get course_resource(): Prisma.course_resourceDelegate<ExtArgs>;

  /**
   * `prisma.knowledge_construction_doc`: Exposes CRUD operations for the **knowledge_construction_doc** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Knowledge_construction_docs
    * const knowledge_construction_docs = await prisma.knowledge_construction_doc.findMany()
    * ```
    */
  get knowledge_construction_doc(): Prisma.knowledge_construction_docDelegate<ExtArgs>;

  /**
   * `prisma.meeting_trick`: Exposes CRUD operations for the **meeting_trick** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Meeting_tricks
    * const meeting_tricks = await prisma.meeting_trick.findMany()
    * ```
    */
  get meeting_trick(): Prisma.meeting_trickDelegate<ExtArgs>;

  /**
   * `prisma.meeting_trick_chat`: Exposes CRUD operations for the **meeting_trick_chat** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Meeting_trick_chats
    * const meeting_trick_chats = await prisma.meeting_trick_chat.findMany()
    * ```
    */
  get meeting_trick_chat(): Prisma.meeting_trick_chatDelegate<ExtArgs>;

  /**
   * `prisma.muti_agent_list`: Exposes CRUD operations for the **muti_agent_list** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Muti_agent_lists
    * const muti_agent_lists = await prisma.muti_agent_list.findMany()
    * ```
    */
  get muti_agent_list(): Prisma.muti_agent_listDelegate<ExtArgs>;

  /**
   * `prisma.park_chat_file_list`: Exposes CRUD operations for the **park_chat_file_list** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Park_chat_file_lists
    * const park_chat_file_lists = await prisma.park_chat_file_list.findMany()
    * ```
    */
  get park_chat_file_list(): Prisma.park_chat_file_listDelegate<ExtArgs>;

  /**
   * `prisma.token`: Exposes CRUD operations for the **token** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Tokens
    * const tokens = await prisma.token.findMany()
    * ```
    */
  get token(): Prisma.tokenDelegate<ExtArgs>;
}

export namespace Prisma {
  export import DMMF = runtime.DMMF

  export type PrismaPromise<T> = $Public.PrismaPromise<T>

  /**
   * Validator
   */
  export import validator = runtime.Public.validator

  /**
   * Prisma Errors
   */
  export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
  export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
  export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
  export import PrismaClientInitializationError = runtime.PrismaClientInitializationError
  export import PrismaClientValidationError = runtime.PrismaClientValidationError
  export import NotFoundError = runtime.NotFoundError

  /**
   * Re-export of sql-template-tag
   */
  export import sql = runtime.sqltag
  export import empty = runtime.empty
  export import join = runtime.join
  export import raw = runtime.raw
  export import Sql = runtime.Sql

  /**
   * Decimal.js
   */
  export import Decimal = runtime.Decimal

  export type DecimalJsLike = runtime.DecimalJsLike

  /**
   * Metrics 
   */
  export type Metrics = runtime.Metrics
  export type Metric<T> = runtime.Metric<T>
  export type MetricHistogram = runtime.MetricHistogram
  export type MetricHistogramBucket = runtime.MetricHistogramBucket

  /**
  * Extensions
  */
  export import Extension = $Extensions.UserArgs
  export import getExtensionContext = runtime.Extensions.getExtensionContext
  export import Args = $Public.Args
  export import Payload = $Public.Payload
  export import Result = $Public.Result
  export import Exact = $Public.Exact

  /**
   * Prisma Client JS version: 5.18.0
   * Query Engine version: 4c784e32044a8a016d99474bd02a3b6123742169
   */
  export type PrismaVersion = {
    client: string
  }

  export const prismaVersion: PrismaVersion 

  /**
   * Utility Types
   */

  /**
   * From https://github.com/sindresorhus/type-fest/
   * Matches a JSON object.
   * This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. 
   */
  export type JsonObject = {[Key in string]?: JsonValue}

  /**
   * From https://github.com/sindresorhus/type-fest/
   * Matches a JSON array.
   */
  export interface JsonArray extends Array<JsonValue> {}

  /**
   * From https://github.com/sindresorhus/type-fest/
   * Matches any valid JSON value.
   */
  export type JsonValue = string | number | boolean | JsonObject | JsonArray | null

  /**
   * Matches a JSON object.
   * Unlike `JsonObject`, this type allows undefined and read-only properties.
   */
  export type InputJsonObject = {readonly [Key in string]?: InputJsonValue | null}

  /**
   * Matches a JSON array.
   * Unlike `JsonArray`, readonly arrays are assignable to this type.
   */
  export interface InputJsonArray extends ReadonlyArray<InputJsonValue | null> {}

  /**
   * Matches any valid value that can be used as an input for operations like
   * create and update as the value of a JSON field. Unlike `JsonValue`, this
   * type allows read-only arrays and read-only object properties and disallows
   * `null` at the top level.
   *
   * `null` cannot be used as the value of a JSON field because its meaning
   * would be ambiguous. Use `Prisma.JsonNull` to store the JSON null value or
   * `Prisma.DbNull` to clear the JSON value and set the field to the database
   * NULL value instead.
   *
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-by-null-values
   */
  export type InputJsonValue = string | number | boolean | InputJsonObject | InputJsonArray | { toJSON(): unknown }

  /**
   * Types of the values used to represent different kinds of `null` values when working with JSON fields.
   * 
   * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
   */
  namespace NullTypes {
    /**
    * Type of `Prisma.DbNull`.
    * 
    * You cannot use other instances of this class. Please use the `Prisma.DbNull` value.
    * 
    * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
    */
    class DbNull {
      private DbNull: never
      private constructor()
    }

    /**
    * Type of `Prisma.JsonNull`.
    * 
    * You cannot use other instances of this class. Please use the `Prisma.JsonNull` value.
    * 
    * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
    */
    class JsonNull {
      private JsonNull: never
      private constructor()
    }

    /**
    * Type of `Prisma.AnyNull`.
    * 
    * You cannot use other instances of this class. Please use the `Prisma.AnyNull` value.
    * 
    * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
    */
    class AnyNull {
      private AnyNull: never
      private constructor()
    }
  }

  /**
   * 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 const DbNull: NullTypes.DbNull

  /**
   * 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 const JsonNull: NullTypes.JsonNull

  /**
   * 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 const AnyNull: NullTypes.AnyNull

  type SelectAndInclude = {
    select: any
    include: any
  }

  type SelectAndOmit = {
    select: any
    omit: any
  }

  /**
   * Get the type of the value, that the Promise holds.
   */
  export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;

  /**
   * Get the return type of a function which returns a Promise.
   */
  export type PromiseReturnType<T extends (...args: any) => $Utils.JsPromise<any>> = PromiseType<ReturnType<T>>

  /**
   * 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>;

  export type RequiredKeys<T> = {
    [K in keyof T]-?: {} extends Prisma__Pick<T, K> ? never : K
  }[keyof T]

  export type TruthyKeys<T> = keyof {
    [K in keyof T as T[K] extends false | undefined | null ? never : K]: K
  }

  export type TrueKeys<T> = TruthyKeys<Prisma__Pick<T, RequiredKeys<T>>>

  /**
   * Subset
   * @desc From `T` pick properties that exist in `U`. Simple version of Intersection
   */
  export type Subset<T, U> = {
    [key in keyof T]: key extends keyof U ? T[key] : never;
  };

  /**
   * SelectSubset
   * @desc From `T` pick properties that exist in `U`. Simple version of Intersection.
   * Additionally, it validates, if both select and include are present. If the case, it errors.
   */
  export type SelectSubset<T, U> = {
    [key in keyof T]: key extends keyof U ? T[key] : never
  } &
    (T extends SelectAndInclude
      ? 'Please either choose `select` or `include`.'
      : T extends SelectAndOmit
        ? 'Please either choose `select` or `omit`.'
        : {})

  /**
   * Subset + Intersection
   * @desc From `T` pick properties that exist in `U` and intersect `K`
   */
  export type SubsetIntersection<T, U, K> = {
    [key in keyof T]: key extends keyof U ? T[key] : never
  } &
    K

  type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };

  /**
   * XOR is needed to have a real mutually exclusive union type
   * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
   */
  type XOR<T, U> =
    T extends object ?
    U extends object ?
      (Without<T, U> & U) | (Without<U, T> & T)
    : U : T


  /**
   * Is T a Record?
   */
  type IsObject<T extends any> = T extends Array<any>
  ? False
  : T extends Date
  ? False
  : T extends Uint8Array
  ? False
  : T extends BigInt
  ? False
  : T extends object
  ? True
  : False


  /**
   * If it's T[], return T
   */
  export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T

  /**
   * From ts-toolbelt
   */

  type __Either<O extends object, K extends Key> = Omit<O, K> &
    {
      // Merge all but K
      [P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities
    }[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]

  type Either<
    O extends object,
    K extends Key,
    strict extends Boolean = 1
  > = O extends unknown ? _Either<O, K, strict> : never

  export type Union = any

  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 AtBasic<O extends object, K extends Key> = K extends keyof O ? O[K] : never;
  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;
  };

  // cause typescript not to expand types and preserve names
  type NoExpand<T> = T extends unknown ? T : never;

  // this type assumes the passed object is entirely optional
  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 ? K : 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>>>;

  /**
  A [[Boolean]]
  */
  export type Boolean = True | False

  // /**
  // 1
  // */
  export type True = 1

  /**
  0
  */
  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 // anything `never` is false
    : 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

  type Cast<A, B> = A extends B ? A : B;

  export const type: unique symbol;



  /**
   * Used by group by
   */

  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

  type GetHavingFields<T> = {
    [K in keyof T]: Or<
      Or<Extends<'OR', K>, Extends<'AND', K>>,
      Extends<'NOT', K>
    > extends True
      ? // infer is only needed to not hit TS limit
        // based on the brilliant idea of Pierre-Antoine Mills
        // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
        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>
  type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T

  /**
   * Like `Pick`, but additionally can also accept an array of keys
   */
  type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>

  /**
   * Exclude all keys with underscores
   */
  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 const ModelName: {
    AWS_Policy_Role: 'AWS_Policy_Role',
    Ai_Agent_Assistants: 'Ai_Agent_Assistants',
    Ai_Agent_Threads: 'Ai_Agent_Threads',
    Assistant: 'Assistant',
    Chat: 'Chat',
    Disposition: 'Disposition',
    Group: 'Group',
    GroupFile: 'GroupFile',
    InvitationCode: 'InvitationCode',
    ai_agent_park_session: 'ai_agent_park_session',
    classroom_ob_comment: 'classroom_ob_comment',
    classroom_observation: 'classroom_observation',
    course_resource: 'course_resource',
    knowledge_construction_doc: 'knowledge_construction_doc',
    meeting_trick: 'meeting_trick',
    meeting_trick_chat: 'meeting_trick_chat',
    muti_agent_list: 'muti_agent_list',
    park_chat_file_list: 'park_chat_file_list',
    token: 'token'
  };

  export type ModelName = (typeof ModelName)[keyof typeof ModelName]


  export type Datasources = {
    db?: Datasource
  }

  interface TypeMapCb extends $Utils.Fn<{extArgs: $Extensions.InternalArgs, clientOptions: PrismaClientOptions }, $Utils.Record<string, any>> {
    returns: Prisma.TypeMap<this['params']['extArgs'], this['params']['clientOptions']>
  }

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
    meta: {
      modelProps: "aWS_Policy_Role" | "ai_Agent_Assistants" | "ai_Agent_Threads" | "assistant" | "chat" | "disposition" | "group" | "groupFile" | "invitationCode" | "ai_agent_park_session" | "classroom_ob_comment" | "classroom_observation" | "course_resource" | "knowledge_construction_doc" | "meeting_trick" | "meeting_trick_chat" | "muti_agent_list" | "park_chat_file_list" | "token"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      AWS_Policy_Role: {
        payload: Prisma.$AWS_Policy_RolePayload<ExtArgs>
        fields: Prisma.AWS_Policy_RoleFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AWS_Policy_RoleFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AWS_Policy_RolePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AWS_Policy_RoleFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AWS_Policy_RolePayload>
          }
          findFirst: {
            args: Prisma.AWS_Policy_RoleFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AWS_Policy_RolePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AWS_Policy_RoleFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AWS_Policy_RolePayload>
          }
          findMany: {
            args: Prisma.AWS_Policy_RoleFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AWS_Policy_RolePayload>[]
          }
          create: {
            args: Prisma.AWS_Policy_RoleCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AWS_Policy_RolePayload>
          }
          createMany: {
            args: Prisma.AWS_Policy_RoleCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.AWS_Policy_RoleDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AWS_Policy_RolePayload>
          }
          update: {
            args: Prisma.AWS_Policy_RoleUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AWS_Policy_RolePayload>
          }
          deleteMany: {
            args: Prisma.AWS_Policy_RoleDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AWS_Policy_RoleUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AWS_Policy_RoleUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AWS_Policy_RolePayload>
          }
          aggregate: {
            args: Prisma.AWS_Policy_RoleAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAWS_Policy_Role>
          }
          groupBy: {
            args: Prisma.AWS_Policy_RoleGroupByArgs<ExtArgs>
            result: $Utils.Optional<AWS_Policy_RoleGroupByOutputType>[]
          }
          count: {
            args: Prisma.AWS_Policy_RoleCountArgs<ExtArgs>
            result: $Utils.Optional<AWS_Policy_RoleCountAggregateOutputType> | number
          }
        }
      }
      Ai_Agent_Assistants: {
        payload: Prisma.$Ai_Agent_AssistantsPayload<ExtArgs>
        fields: Prisma.Ai_Agent_AssistantsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.Ai_Agent_AssistantsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_AssistantsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.Ai_Agent_AssistantsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_AssistantsPayload>
          }
          findFirst: {
            args: Prisma.Ai_Agent_AssistantsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_AssistantsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.Ai_Agent_AssistantsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_AssistantsPayload>
          }
          findMany: {
            args: Prisma.Ai_Agent_AssistantsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_AssistantsPayload>[]
          }
          create: {
            args: Prisma.Ai_Agent_AssistantsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_AssistantsPayload>
          }
          createMany: {
            args: Prisma.Ai_Agent_AssistantsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.Ai_Agent_AssistantsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_AssistantsPayload>
          }
          update: {
            args: Prisma.Ai_Agent_AssistantsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_AssistantsPayload>
          }
          deleteMany: {
            args: Prisma.Ai_Agent_AssistantsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.Ai_Agent_AssistantsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.Ai_Agent_AssistantsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_AssistantsPayload>
          }
          aggregate: {
            args: Prisma.Ai_Agent_AssistantsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAi_Agent_Assistants>
          }
          groupBy: {
            args: Prisma.Ai_Agent_AssistantsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Ai_Agent_AssistantsGroupByOutputType>[]
          }
          count: {
            args: Prisma.Ai_Agent_AssistantsCountArgs<ExtArgs>
            result: $Utils.Optional<Ai_Agent_AssistantsCountAggregateOutputType> | number
          }
        }
      }
      Ai_Agent_Threads: {
        payload: Prisma.$Ai_Agent_ThreadsPayload<ExtArgs>
        fields: Prisma.Ai_Agent_ThreadsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.Ai_Agent_ThreadsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_ThreadsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.Ai_Agent_ThreadsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_ThreadsPayload>
          }
          findFirst: {
            args: Prisma.Ai_Agent_ThreadsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_ThreadsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.Ai_Agent_ThreadsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_ThreadsPayload>
          }
          findMany: {
            args: Prisma.Ai_Agent_ThreadsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_ThreadsPayload>[]
          }
          create: {
            args: Prisma.Ai_Agent_ThreadsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_ThreadsPayload>
          }
          createMany: {
            args: Prisma.Ai_Agent_ThreadsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.Ai_Agent_ThreadsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_ThreadsPayload>
          }
          update: {
            args: Prisma.Ai_Agent_ThreadsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_ThreadsPayload>
          }
          deleteMany: {
            args: Prisma.Ai_Agent_ThreadsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.Ai_Agent_ThreadsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.Ai_Agent_ThreadsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$Ai_Agent_ThreadsPayload>
          }
          aggregate: {
            args: Prisma.Ai_Agent_ThreadsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAi_Agent_Threads>
          }
          groupBy: {
            args: Prisma.Ai_Agent_ThreadsGroupByArgs<ExtArgs>
            result: $Utils.Optional<Ai_Agent_ThreadsGroupByOutputType>[]
          }
          count: {
            args: Prisma.Ai_Agent_ThreadsCountArgs<ExtArgs>
            result: $Utils.Optional<Ai_Agent_ThreadsCountAggregateOutputType> | number
          }
        }
      }
      Assistant: {
        payload: Prisma.$AssistantPayload<ExtArgs>
        fields: Prisma.AssistantFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AssistantFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssistantPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AssistantFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssistantPayload>
          }
          findFirst: {
            args: Prisma.AssistantFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssistantPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AssistantFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssistantPayload>
          }
          findMany: {
            args: Prisma.AssistantFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssistantPayload>[]
          }
          create: {
            args: Prisma.AssistantCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssistantPayload>
          }
          createMany: {
            args: Prisma.AssistantCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.AssistantDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssistantPayload>
          }
          update: {
            args: Prisma.AssistantUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssistantPayload>
          }
          deleteMany: {
            args: Prisma.AssistantDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AssistantUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AssistantUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssistantPayload>
          }
          aggregate: {
            args: Prisma.AssistantAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAssistant>
          }
          groupBy: {
            args: Prisma.AssistantGroupByArgs<ExtArgs>
            result: $Utils.Optional<AssistantGroupByOutputType>[]
          }
          count: {
            args: Prisma.AssistantCountArgs<ExtArgs>
            result: $Utils.Optional<AssistantCountAggregateOutputType> | number
          }
        }
      }
      Chat: {
        payload: Prisma.$ChatPayload<ExtArgs>
        fields: Prisma.ChatFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChatFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChatFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          findFirst: {
            args: Prisma.ChatFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChatFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          findMany: {
            args: Prisma.ChatFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>[]
          }
          create: {
            args: Prisma.ChatCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          createMany: {
            args: Prisma.ChatCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ChatDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          update: {
            args: Prisma.ChatUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          deleteMany: {
            args: Prisma.ChatDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ChatUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ChatUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ChatPayload>
          }
          aggregate: {
            args: Prisma.ChatAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateChat>
          }
          groupBy: {
            args: Prisma.ChatGroupByArgs<ExtArgs>
            result: $Utils.Optional<ChatGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChatCountArgs<ExtArgs>
            result: $Utils.Optional<ChatCountAggregateOutputType> | number
          }
        }
      }
      Disposition: {
        payload: Prisma.$DispositionPayload<ExtArgs>
        fields: Prisma.DispositionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.DispositionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DispositionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.DispositionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DispositionPayload>
          }
          findFirst: {
            args: Prisma.DispositionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DispositionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.DispositionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DispositionPayload>
          }
          findMany: {
            args: Prisma.DispositionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DispositionPayload>[]
          }
          create: {
            args: Prisma.DispositionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DispositionPayload>
          }
          createMany: {
            args: Prisma.DispositionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.DispositionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DispositionPayload>
          }
          update: {
            args: Prisma.DispositionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DispositionPayload>
          }
          deleteMany: {
            args: Prisma.DispositionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.DispositionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.DispositionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$DispositionPayload>
          }
          aggregate: {
            args: Prisma.DispositionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateDisposition>
          }
          groupBy: {
            args: Prisma.DispositionGroupByArgs<ExtArgs>
            result: $Utils.Optional<DispositionGroupByOutputType>[]
          }
          count: {
            args: Prisma.DispositionCountArgs<ExtArgs>
            result: $Utils.Optional<DispositionCountAggregateOutputType> | number
          }
        }
      }
      Group: {
        payload: Prisma.$GroupPayload<ExtArgs>
        fields: Prisma.GroupFieldRefs
        operations: {
          findUnique: {
            args: Prisma.GroupFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.GroupFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          findFirst: {
            args: Prisma.GroupFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.GroupFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          findMany: {
            args: Prisma.GroupFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>[]
          }
          create: {
            args: Prisma.GroupCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          createMany: {
            args: Prisma.GroupCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.GroupDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          update: {
            args: Prisma.GroupUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          deleteMany: {
            args: Prisma.GroupDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.GroupUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.GroupUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupPayload>
          }
          aggregate: {
            args: Prisma.GroupAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateGroup>
          }
          groupBy: {
            args: Prisma.GroupGroupByArgs<ExtArgs>
            result: $Utils.Optional<GroupGroupByOutputType>[]
          }
          count: {
            args: Prisma.GroupCountArgs<ExtArgs>
            result: $Utils.Optional<GroupCountAggregateOutputType> | number
          }
        }
      }
      GroupFile: {
        payload: Prisma.$GroupFilePayload<ExtArgs>
        fields: Prisma.GroupFileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.GroupFileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupFilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.GroupFileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupFilePayload>
          }
          findFirst: {
            args: Prisma.GroupFileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupFilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.GroupFileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupFilePayload>
          }
          findMany: {
            args: Prisma.GroupFileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupFilePayload>[]
          }
          create: {
            args: Prisma.GroupFileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupFilePayload>
          }
          createMany: {
            args: Prisma.GroupFileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.GroupFileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupFilePayload>
          }
          update: {
            args: Prisma.GroupFileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupFilePayload>
          }
          deleteMany: {
            args: Prisma.GroupFileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.GroupFileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.GroupFileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GroupFilePayload>
          }
          aggregate: {
            args: Prisma.GroupFileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateGroupFile>
          }
          groupBy: {
            args: Prisma.GroupFileGroupByArgs<ExtArgs>
            result: $Utils.Optional<GroupFileGroupByOutputType>[]
          }
          count: {
            args: Prisma.GroupFileCountArgs<ExtArgs>
            result: $Utils.Optional<GroupFileCountAggregateOutputType> | number
          }
        }
      }
      InvitationCode: {
        payload: Prisma.$InvitationCodePayload<ExtArgs>
        fields: Prisma.InvitationCodeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.InvitationCodeFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InvitationCodePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.InvitationCodeFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InvitationCodePayload>
          }
          findFirst: {
            args: Prisma.InvitationCodeFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InvitationCodePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.InvitationCodeFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InvitationCodePayload>
          }
          findMany: {
            args: Prisma.InvitationCodeFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InvitationCodePayload>[]
          }
          create: {
            args: Prisma.InvitationCodeCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InvitationCodePayload>
          }
          createMany: {
            args: Prisma.InvitationCodeCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.InvitationCodeDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InvitationCodePayload>
          }
          update: {
            args: Prisma.InvitationCodeUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InvitationCodePayload>
          }
          deleteMany: {
            args: Prisma.InvitationCodeDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.InvitationCodeUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.InvitationCodeUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$InvitationCodePayload>
          }
          aggregate: {
            args: Prisma.InvitationCodeAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateInvitationCode>
          }
          groupBy: {
            args: Prisma.InvitationCodeGroupByArgs<ExtArgs>
            result: $Utils.Optional<InvitationCodeGroupByOutputType>[]
          }
          count: {
            args: Prisma.InvitationCodeCountArgs<ExtArgs>
            result: $Utils.Optional<InvitationCodeCountAggregateOutputType> | number
          }
        }
      }
      ai_agent_park_session: {
        payload: Prisma.$ai_agent_park_sessionPayload<ExtArgs>
        fields: Prisma.ai_agent_park_sessionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ai_agent_park_sessionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ai_agent_park_sessionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ai_agent_park_sessionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ai_agent_park_sessionPayload>
          }
          findFirst: {
            args: Prisma.ai_agent_park_sessionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ai_agent_park_sessionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ai_agent_park_sessionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ai_agent_park_sessionPayload>
          }
          findMany: {
            args: Prisma.ai_agent_park_sessionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ai_agent_park_sessionPayload>[]
          }
          create: {
            args: Prisma.ai_agent_park_sessionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ai_agent_park_sessionPayload>
          }
          createMany: {
            args: Prisma.ai_agent_park_sessionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ai_agent_park_sessionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ai_agent_park_sessionPayload>
          }
          update: {
            args: Prisma.ai_agent_park_sessionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ai_agent_park_sessionPayload>
          }
          deleteMany: {
            args: Prisma.ai_agent_park_sessionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ai_agent_park_sessionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ai_agent_park_sessionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ai_agent_park_sessionPayload>
          }
          aggregate: {
            args: Prisma.Ai_agent_park_sessionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAi_agent_park_session>
          }
          groupBy: {
            args: Prisma.ai_agent_park_sessionGroupByArgs<ExtArgs>
            result: $Utils.Optional<Ai_agent_park_sessionGroupByOutputType>[]
          }
          count: {
            args: Prisma.ai_agent_park_sessionCountArgs<ExtArgs>
            result: $Utils.Optional<Ai_agent_park_sessionCountAggregateOutputType> | number
          }
        }
      }
      classroom_ob_comment: {
        payload: Prisma.$classroom_ob_commentPayload<ExtArgs>
        fields: Prisma.classroom_ob_commentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.classroom_ob_commentFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_ob_commentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.classroom_ob_commentFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_ob_commentPayload>
          }
          findFirst: {
            args: Prisma.classroom_ob_commentFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_ob_commentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.classroom_ob_commentFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_ob_commentPayload>
          }
          findMany: {
            args: Prisma.classroom_ob_commentFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_ob_commentPayload>[]
          }
          create: {
            args: Prisma.classroom_ob_commentCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_ob_commentPayload>
          }
          createMany: {
            args: Prisma.classroom_ob_commentCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.classroom_ob_commentDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_ob_commentPayload>
          }
          update: {
            args: Prisma.classroom_ob_commentUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_ob_commentPayload>
          }
          deleteMany: {
            args: Prisma.classroom_ob_commentDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.classroom_ob_commentUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.classroom_ob_commentUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_ob_commentPayload>
          }
          aggregate: {
            args: Prisma.Classroom_ob_commentAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateClassroom_ob_comment>
          }
          groupBy: {
            args: Prisma.classroom_ob_commentGroupByArgs<ExtArgs>
            result: $Utils.Optional<Classroom_ob_commentGroupByOutputType>[]
          }
          count: {
            args: Prisma.classroom_ob_commentCountArgs<ExtArgs>
            result: $Utils.Optional<Classroom_ob_commentCountAggregateOutputType> | number
          }
        }
      }
      classroom_observation: {
        payload: Prisma.$classroom_observationPayload<ExtArgs>
        fields: Prisma.classroom_observationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.classroom_observationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_observationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.classroom_observationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_observationPayload>
          }
          findFirst: {
            args: Prisma.classroom_observationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_observationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.classroom_observationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_observationPayload>
          }
          findMany: {
            args: Prisma.classroom_observationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_observationPayload>[]
          }
          create: {
            args: Prisma.classroom_observationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_observationPayload>
          }
          createMany: {
            args: Prisma.classroom_observationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.classroom_observationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_observationPayload>
          }
          update: {
            args: Prisma.classroom_observationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_observationPayload>
          }
          deleteMany: {
            args: Prisma.classroom_observationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.classroom_observationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.classroom_observationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$classroom_observationPayload>
          }
          aggregate: {
            args: Prisma.Classroom_observationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateClassroom_observation>
          }
          groupBy: {
            args: Prisma.classroom_observationGroupByArgs<ExtArgs>
            result: $Utils.Optional<Classroom_observationGroupByOutputType>[]
          }
          count: {
            args: Prisma.classroom_observationCountArgs<ExtArgs>
            result: $Utils.Optional<Classroom_observationCountAggregateOutputType> | number
          }
        }
      }
      course_resource: {
        payload: Prisma.$course_resourcePayload<ExtArgs>
        fields: Prisma.course_resourceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.course_resourceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$course_resourcePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.course_resourceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$course_resourcePayload>
          }
          findFirst: {
            args: Prisma.course_resourceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$course_resourcePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.course_resourceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$course_resourcePayload>
          }
          findMany: {
            args: Prisma.course_resourceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$course_resourcePayload>[]
          }
          create: {
            args: Prisma.course_resourceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$course_resourcePayload>
          }
          createMany: {
            args: Prisma.course_resourceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.course_resourceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$course_resourcePayload>
          }
          update: {
            args: Prisma.course_resourceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$course_resourcePayload>
          }
          deleteMany: {
            args: Prisma.course_resourceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.course_resourceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.course_resourceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$course_resourcePayload>
          }
          aggregate: {
            args: Prisma.Course_resourceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCourse_resource>
          }
          groupBy: {
            args: Prisma.course_resourceGroupByArgs<ExtArgs>
            result: $Utils.Optional<Course_resourceGroupByOutputType>[]
          }
          count: {
            args: Prisma.course_resourceCountArgs<ExtArgs>
            result: $Utils.Optional<Course_resourceCountAggregateOutputType> | number
          }
        }
      }
      knowledge_construction_doc: {
        payload: Prisma.$knowledge_construction_docPayload<ExtArgs>
        fields: Prisma.knowledge_construction_docFieldRefs
        operations: {
          findUnique: {
            args: Prisma.knowledge_construction_docFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$knowledge_construction_docPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.knowledge_construction_docFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$knowledge_construction_docPayload>
          }
          findFirst: {
            args: Prisma.knowledge_construction_docFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$knowledge_construction_docPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.knowledge_construction_docFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$knowledge_construction_docPayload>
          }
          findMany: {
            args: Prisma.knowledge_construction_docFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$knowledge_construction_docPayload>[]
          }
          create: {
            args: Prisma.knowledge_construction_docCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$knowledge_construction_docPayload>
          }
          createMany: {
            args: Prisma.knowledge_construction_docCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.knowledge_construction_docDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$knowledge_construction_docPayload>
          }
          update: {
            args: Prisma.knowledge_construction_docUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$knowledge_construction_docPayload>
          }
          deleteMany: {
            args: Prisma.knowledge_construction_docDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.knowledge_construction_docUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.knowledge_construction_docUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$knowledge_construction_docPayload>
          }
          aggregate: {
            args: Prisma.Knowledge_construction_docAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateKnowledge_construction_doc>
          }
          groupBy: {
            args: Prisma.knowledge_construction_docGroupByArgs<ExtArgs>
            result: $Utils.Optional<Knowledge_construction_docGroupByOutputType>[]
          }
          count: {
            args: Prisma.knowledge_construction_docCountArgs<ExtArgs>
            result: $Utils.Optional<Knowledge_construction_docCountAggregateOutputType> | number
          }
        }
      }
      meeting_trick: {
        payload: Prisma.$meeting_trickPayload<ExtArgs>
        fields: Prisma.meeting_trickFieldRefs
        operations: {
          findUnique: {
            args: Prisma.meeting_trickFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trickPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.meeting_trickFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trickPayload>
          }
          findFirst: {
            args: Prisma.meeting_trickFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trickPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.meeting_trickFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trickPayload>
          }
          findMany: {
            args: Prisma.meeting_trickFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trickPayload>[]
          }
          create: {
            args: Prisma.meeting_trickCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trickPayload>
          }
          createMany: {
            args: Prisma.meeting_trickCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.meeting_trickDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trickPayload>
          }
          update: {
            args: Prisma.meeting_trickUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trickPayload>
          }
          deleteMany: {
            args: Prisma.meeting_trickDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.meeting_trickUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.meeting_trickUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trickPayload>
          }
          aggregate: {
            args: Prisma.Meeting_trickAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMeeting_trick>
          }
          groupBy: {
            args: Prisma.meeting_trickGroupByArgs<ExtArgs>
            result: $Utils.Optional<Meeting_trickGroupByOutputType>[]
          }
          count: {
            args: Prisma.meeting_trickCountArgs<ExtArgs>
            result: $Utils.Optional<Meeting_trickCountAggregateOutputType> | number
          }
        }
      }
      meeting_trick_chat: {
        payload: Prisma.$meeting_trick_chatPayload<ExtArgs>
        fields: Prisma.meeting_trick_chatFieldRefs
        operations: {
          findUnique: {
            args: Prisma.meeting_trick_chatFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trick_chatPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.meeting_trick_chatFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trick_chatPayload>
          }
          findFirst: {
            args: Prisma.meeting_trick_chatFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trick_chatPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.meeting_trick_chatFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trick_chatPayload>
          }
          findMany: {
            args: Prisma.meeting_trick_chatFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trick_chatPayload>[]
          }
          create: {
            args: Prisma.meeting_trick_chatCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trick_chatPayload>
          }
          createMany: {
            args: Prisma.meeting_trick_chatCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.meeting_trick_chatDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trick_chatPayload>
          }
          update: {
            args: Prisma.meeting_trick_chatUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trick_chatPayload>
          }
          deleteMany: {
            args: Prisma.meeting_trick_chatDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.meeting_trick_chatUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.meeting_trick_chatUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$meeting_trick_chatPayload>
          }
          aggregate: {
            args: Prisma.Meeting_trick_chatAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMeeting_trick_chat>
          }
          groupBy: {
            args: Prisma.meeting_trick_chatGroupByArgs<ExtArgs>
            result: $Utils.Optional<Meeting_trick_chatGroupByOutputType>[]
          }
          count: {
            args: Prisma.meeting_trick_chatCountArgs<ExtArgs>
            result: $Utils.Optional<Meeting_trick_chatCountAggregateOutputType> | number
          }
        }
      }
      muti_agent_list: {
        payload: Prisma.$muti_agent_listPayload<ExtArgs>
        fields: Prisma.muti_agent_listFieldRefs
        operations: {
          findUnique: {
            args: Prisma.muti_agent_listFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$muti_agent_listPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.muti_agent_listFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$muti_agent_listPayload>
          }
          findFirst: {
            args: Prisma.muti_agent_listFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$muti_agent_listPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.muti_agent_listFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$muti_agent_listPayload>
          }
          findMany: {
            args: Prisma.muti_agent_listFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$muti_agent_listPayload>[]
          }
          create: {
            args: Prisma.muti_agent_listCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$muti_agent_listPayload>
          }
          createMany: {
            args: Prisma.muti_agent_listCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.muti_agent_listDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$muti_agent_listPayload>
          }
          update: {
            args: Prisma.muti_agent_listUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$muti_agent_listPayload>
          }
          deleteMany: {
            args: Prisma.muti_agent_listDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.muti_agent_listUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.muti_agent_listUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$muti_agent_listPayload>
          }
          aggregate: {
            args: Prisma.Muti_agent_listAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMuti_agent_list>
          }
          groupBy: {
            args: Prisma.muti_agent_listGroupByArgs<ExtArgs>
            result: $Utils.Optional<Muti_agent_listGroupByOutputType>[]
          }
          count: {
            args: Prisma.muti_agent_listCountArgs<ExtArgs>
            result: $Utils.Optional<Muti_agent_listCountAggregateOutputType> | number
          }
        }
      }
      park_chat_file_list: {
        payload: Prisma.$park_chat_file_listPayload<ExtArgs>
        fields: Prisma.park_chat_file_listFieldRefs
        operations: {
          findUnique: {
            args: Prisma.park_chat_file_listFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$park_chat_file_listPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.park_chat_file_listFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$park_chat_file_listPayload>
          }
          findFirst: {
            args: Prisma.park_chat_file_listFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$park_chat_file_listPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.park_chat_file_listFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$park_chat_file_listPayload>
          }
          findMany: {
            args: Prisma.park_chat_file_listFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$park_chat_file_listPayload>[]
          }
          create: {
            args: Prisma.park_chat_file_listCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$park_chat_file_listPayload>
          }
          createMany: {
            args: Prisma.park_chat_file_listCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.park_chat_file_listDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$park_chat_file_listPayload>
          }
          update: {
            args: Prisma.park_chat_file_listUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$park_chat_file_listPayload>
          }
          deleteMany: {
            args: Prisma.park_chat_file_listDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.park_chat_file_listUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.park_chat_file_listUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$park_chat_file_listPayload>
          }
          aggregate: {
            args: Prisma.Park_chat_file_listAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePark_chat_file_list>
          }
          groupBy: {
            args: Prisma.park_chat_file_listGroupByArgs<ExtArgs>
            result: $Utils.Optional<Park_chat_file_listGroupByOutputType>[]
          }
          count: {
            args: Prisma.park_chat_file_listCountArgs<ExtArgs>
            result: $Utils.Optional<Park_chat_file_listCountAggregateOutputType> | number
          }
        }
      }
      token: {
        payload: Prisma.$tokenPayload<ExtArgs>
        fields: Prisma.tokenFieldRefs
        operations: {
          findUnique: {
            args: Prisma.tokenFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$tokenPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.tokenFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$tokenPayload>
          }
          findFirst: {
            args: Prisma.tokenFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$tokenPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.tokenFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$tokenPayload>
          }
          findMany: {
            args: Prisma.tokenFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$tokenPayload>[]
          }
          create: {
            args: Prisma.tokenCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$tokenPayload>
          }
          createMany: {
            args: Prisma.tokenCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.tokenDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$tokenPayload>
          }
          update: {
            args: Prisma.tokenUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$tokenPayload>
          }
          deleteMany: {
            args: Prisma.tokenDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.tokenUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.tokenUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$tokenPayload>
          }
          aggregate: {
            args: Prisma.TokenAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateToken>
          }
          groupBy: {
            args: Prisma.tokenGroupByArgs<ExtArgs>
            result: $Utils.Optional<TokenGroupByOutputType>[]
          }
          count: {
            args: Prisma.tokenCountArgs<ExtArgs>
            result: $Utils.Optional<TokenCountAggregateOutputType> | number
          }
        }
      }
    }
  } & {
    other: {
      payload: any
      operations: {
        $executeRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
        $executeRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $queryRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
        $queryRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
      }
    }
  }
  export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs>
  export type DefaultPrismaClient = PrismaClient
  export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
  export interface PrismaClientOptions {
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasources?: Datasources
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasourceUrl?: string
    /**
     * @default "colorless"
     */
    errorFormat?: ErrorFormat
    /**
     * @example
     * ```
     * // Defaults to stdout
     * log: ['query', 'info', 'warn', 'error']
     * 
     * // Emit as events
     * log: [
     *   { emit: 'stdout', level: 'query' },
     *   { emit: 'stdout', level: 'info' },
     *   { emit: 'stdout', level: 'warn' }
     *   { emit: 'stdout', level: 'error' }
     * ]
     * ```
     * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
     */
    log?: (LogLevel | LogDefinition)[]
    /**
     * The default values for transactionOptions
     * maxWait ?= 2000
     * timeout ?= 5000
     */
    transactionOptions?: {
      maxWait?: number
      timeout?: number
      isolationLevel?: Prisma.TransactionIsolationLevel
    }
  }


  /* Types for Logging */
  export type LogLevel = 'info' | 'query' | 'warn' | 'error'
  export type LogDefinition = {
    level: LogLevel
    emit: 'stdout' | 'event'
  }

  export type GetLogType<T extends LogLevel | LogDefinition> = T extends LogDefinition ? T['emit'] extends 'event' ? T['level'] : never : never
  export type GetEvents<T extends any> = T extends Array<LogLevel | LogDefinition> ?
    GetLogType<T[0]> | GetLogType<T[1]> | GetLogType<T[2]> | GetLogType<T[3]>
    : never

  export type QueryEvent = {
    timestamp: Date
    query: string
    params: string
    duration: number
    target: string
  }

  export type LogEvent = {
    timestamp: Date
    message: string
    target: string
  }
  /* End Types for Logging */


  export type PrismaAction =
    | 'findUnique'
    | 'findUniqueOrThrow'
    | 'findMany'
    | 'findFirst'
    | 'findFirstOrThrow'
    | 'create'
    | 'createMany'
    | 'createManyAndReturn'
    | 'update'
    | 'updateMany'
    | 'upsert'
    | 'delete'
    | 'deleteMany'
    | 'executeRaw'
    | 'queryRaw'
    | 'aggregate'
    | 'count'
    | 'runCommandRaw'
    | 'findRaw'
    | 'groupBy'

  /**
   * These options are being passed into the middleware as "params"
   */
  export type MiddlewareParams = {
    model?: ModelName
    action: PrismaAction
    args: any
    dataPath: string[]
    runInTransaction: boolean
  }

  /**
   * The `T` type makes sure, that the `return proceed` is not forgotten in the middleware implementation
   */
  export type Middleware<T = any> = (
    params: MiddlewareParams,
    next: (params: MiddlewareParams) => $Utils.JsPromise<T>,
  ) => $Utils.JsPromise<T>

  // tested in getLogLevel.test.ts
  export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined;

  /**
   * `PrismaClient` proxy available in interactive transactions.
   */
  export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClientDenyList>

  export type Datasource = {
    url?: string
  }

  /**
   * Count Types
   */



  /**
   * Models
   */

  /**
   * Model AWS_Policy_Role
   */

  export type AggregateAWS_Policy_Role = {
    _count: AWS_Policy_RoleCountAggregateOutputType | null
    _min: AWS_Policy_RoleMinAggregateOutputType | null
    _max: AWS_Policy_RoleMaxAggregateOutputType | null
  }

  export type AWS_Policy_RoleMinAggregateOutputType = {
    id: string | null
    assistant_id: string | null
    agent_bedrock_policy: string | null
    agent_kb_schema_policy: string | null
    kb_bedrock_policy: string | null
    kb_aoss_policy: string | null
    kb_s3_policy: string | null
    agent_role_name: string | null
    kb_role_name: string | null
    createtime: Date | null
  }

  export type AWS_Policy_RoleMaxAggregateOutputType = {
    id: string | null
    assistant_id: string | null
    agent_bedrock_policy: string | null
    agent_kb_schema_policy: string | null
    kb_bedrock_policy: string | null
    kb_aoss_policy: string | null
    kb_s3_policy: string | null
    agent_role_name: string | null
    kb_role_name: string | null
    createtime: Date | null
  }

  export type AWS_Policy_RoleCountAggregateOutputType = {
    id: number
    assistant_id: number
    agent_bedrock_policy: number
    agent_kb_schema_policy: number
    kb_bedrock_policy: number
    kb_aoss_policy: number
    kb_s3_policy: number
    agent_role_name: number
    kb_role_name: number
    createtime: number
    _all: number
  }


  export type AWS_Policy_RoleMinAggregateInputType = {
    id?: true
    assistant_id?: true
    agent_bedrock_policy?: true
    agent_kb_schema_policy?: true
    kb_bedrock_policy?: true
    kb_aoss_policy?: true
    kb_s3_policy?: true
    agent_role_name?: true
    kb_role_name?: true
    createtime?: true
  }

  export type AWS_Policy_RoleMaxAggregateInputType = {
    id?: true
    assistant_id?: true
    agent_bedrock_policy?: true
    agent_kb_schema_policy?: true
    kb_bedrock_policy?: true
    kb_aoss_policy?: true
    kb_s3_policy?: true
    agent_role_name?: true
    kb_role_name?: true
    createtime?: true
  }

  export type AWS_Policy_RoleCountAggregateInputType = {
    id?: true
    assistant_id?: true
    agent_bedrock_policy?: true
    agent_kb_schema_policy?: true
    kb_bedrock_policy?: true
    kb_aoss_policy?: true
    kb_s3_policy?: true
    agent_role_name?: true
    kb_role_name?: true
    createtime?: true
    _all?: true
  }

  export type AWS_Policy_RoleAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AWS_Policy_Role to aggregate.
     */
    where?: AWS_Policy_RoleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AWS_Policy_Roles to fetch.
     */
    orderBy?: AWS_Policy_RoleOrderByWithRelationInput | AWS_Policy_RoleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AWS_Policy_RoleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AWS_Policy_Roles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` AWS_Policy_Roles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned AWS_Policy_Roles
    **/
    _count?: true | AWS_Policy_RoleCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AWS_Policy_RoleMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AWS_Policy_RoleMaxAggregateInputType
  }

  export type GetAWS_Policy_RoleAggregateType<T extends AWS_Policy_RoleAggregateArgs> = {
        [P in keyof T & keyof AggregateAWS_Policy_Role]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateAWS_Policy_Role[P]>
      : GetScalarType<T[P], AggregateAWS_Policy_Role[P]>
  }




  export type AWS_Policy_RoleGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AWS_Policy_RoleWhereInput
    orderBy?: AWS_Policy_RoleOrderByWithAggregationInput | AWS_Policy_RoleOrderByWithAggregationInput[]
    by: AWS_Policy_RoleScalarFieldEnum[] | AWS_Policy_RoleScalarFieldEnum
    having?: AWS_Policy_RoleScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AWS_Policy_RoleCountAggregateInputType | true
    _min?: AWS_Policy_RoleMinAggregateInputType
    _max?: AWS_Policy_RoleMaxAggregateInputType
  }

  export type AWS_Policy_RoleGroupByOutputType = {
    id: string
    assistant_id: string | null
    agent_bedrock_policy: string | null
    agent_kb_schema_policy: string | null
    kb_bedrock_policy: string | null
    kb_aoss_policy: string | null
    kb_s3_policy: string | null
    agent_role_name: string | null
    kb_role_name: string | null
    createtime: Date | null
    _count: AWS_Policy_RoleCountAggregateOutputType | null
    _min: AWS_Policy_RoleMinAggregateOutputType | null
    _max: AWS_Policy_RoleMaxAggregateOutputType | null
  }

  type GetAWS_Policy_RoleGroupByPayload<T extends AWS_Policy_RoleGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<AWS_Policy_RoleGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof AWS_Policy_RoleGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], AWS_Policy_RoleGroupByOutputType[P]>
            : GetScalarType<T[P], AWS_Policy_RoleGroupByOutputType[P]>
        }
      >
    >


  export type AWS_Policy_RoleSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    assistant_id?: boolean
    agent_bedrock_policy?: boolean
    agent_kb_schema_policy?: boolean
    kb_bedrock_policy?: boolean
    kb_aoss_policy?: boolean
    kb_s3_policy?: boolean
    agent_role_name?: boolean
    kb_role_name?: boolean
    createtime?: boolean
  }, ExtArgs["result"]["aWS_Policy_Role"]>


  export type AWS_Policy_RoleSelectScalar = {
    id?: boolean
    assistant_id?: boolean
    agent_bedrock_policy?: boolean
    agent_kb_schema_policy?: boolean
    kb_bedrock_policy?: boolean
    kb_aoss_policy?: boolean
    kb_s3_policy?: boolean
    agent_role_name?: boolean
    kb_role_name?: boolean
    createtime?: boolean
  }


  export type $AWS_Policy_RolePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AWS_Policy_Role"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      assistant_id: string | null
      agent_bedrock_policy: string | null
      agent_kb_schema_policy: string | null
      kb_bedrock_policy: string | null
      kb_aoss_policy: string | null
      kb_s3_policy: string | null
      agent_role_name: string | null
      kb_role_name: string | null
      createtime: Date | null
    }, ExtArgs["result"]["aWS_Policy_Role"]>
    composites: {}
  }

  type AWS_Policy_RoleGetPayload<S extends boolean | null | undefined | AWS_Policy_RoleDefaultArgs> = $Result.GetResult<Prisma.$AWS_Policy_RolePayload, S>

  type AWS_Policy_RoleCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<AWS_Policy_RoleFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: AWS_Policy_RoleCountAggregateInputType | true
    }

  export interface AWS_Policy_RoleDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['AWS_Policy_Role'], meta: { name: 'AWS_Policy_Role' } }
    /**
     * Find zero or one AWS_Policy_Role that matches the filter.
     * @param {AWS_Policy_RoleFindUniqueArgs} args - Arguments to find a AWS_Policy_Role
     * @example
     * // Get one AWS_Policy_Role
     * const aWS_Policy_Role = await prisma.aWS_Policy_Role.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends AWS_Policy_RoleFindUniqueArgs>(args: SelectSubset<T, AWS_Policy_RoleFindUniqueArgs<ExtArgs>>): Prisma__AWS_Policy_RoleClient<$Result.GetResult<Prisma.$AWS_Policy_RolePayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one AWS_Policy_Role that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {AWS_Policy_RoleFindUniqueOrThrowArgs} args - Arguments to find a AWS_Policy_Role
     * @example
     * // Get one AWS_Policy_Role
     * const aWS_Policy_Role = await prisma.aWS_Policy_Role.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends AWS_Policy_RoleFindUniqueOrThrowArgs>(args: SelectSubset<T, AWS_Policy_RoleFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AWS_Policy_RoleClient<$Result.GetResult<Prisma.$AWS_Policy_RolePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first AWS_Policy_Role that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AWS_Policy_RoleFindFirstArgs} args - Arguments to find a AWS_Policy_Role
     * @example
     * // Get one AWS_Policy_Role
     * const aWS_Policy_Role = await prisma.aWS_Policy_Role.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AWS_Policy_RoleFindFirstArgs>(args?: SelectSubset<T, AWS_Policy_RoleFindFirstArgs<ExtArgs>>): Prisma__AWS_Policy_RoleClient<$Result.GetResult<Prisma.$AWS_Policy_RolePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first AWS_Policy_Role that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AWS_Policy_RoleFindFirstOrThrowArgs} args - Arguments to find a AWS_Policy_Role
     * @example
     * // Get one AWS_Policy_Role
     * const aWS_Policy_Role = await prisma.aWS_Policy_Role.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AWS_Policy_RoleFindFirstOrThrowArgs>(args?: SelectSubset<T, AWS_Policy_RoleFindFirstOrThrowArgs<ExtArgs>>): Prisma__AWS_Policy_RoleClient<$Result.GetResult<Prisma.$AWS_Policy_RolePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more AWS_Policy_Roles that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AWS_Policy_RoleFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all AWS_Policy_Roles
     * const aWS_Policy_Roles = await prisma.aWS_Policy_Role.findMany()
     * 
     * // Get first 10 AWS_Policy_Roles
     * const aWS_Policy_Roles = await prisma.aWS_Policy_Role.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const aWS_Policy_RoleWithIdOnly = await prisma.aWS_Policy_Role.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends AWS_Policy_RoleFindManyArgs>(args?: SelectSubset<T, AWS_Policy_RoleFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AWS_Policy_RolePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a AWS_Policy_Role.
     * @param {AWS_Policy_RoleCreateArgs} args - Arguments to create a AWS_Policy_Role.
     * @example
     * // Create one AWS_Policy_Role
     * const AWS_Policy_Role = await prisma.aWS_Policy_Role.create({
     *   data: {
     *     // ... data to create a AWS_Policy_Role
     *   }
     * })
     * 
     */
    create<T extends AWS_Policy_RoleCreateArgs>(args: SelectSubset<T, AWS_Policy_RoleCreateArgs<ExtArgs>>): Prisma__AWS_Policy_RoleClient<$Result.GetResult<Prisma.$AWS_Policy_RolePayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many AWS_Policy_Roles.
     * @param {AWS_Policy_RoleCreateManyArgs} args - Arguments to create many AWS_Policy_Roles.
     * @example
     * // Create many AWS_Policy_Roles
     * const aWS_Policy_Role = await prisma.aWS_Policy_Role.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends AWS_Policy_RoleCreateManyArgs>(args?: SelectSubset<T, AWS_Policy_RoleCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a AWS_Policy_Role.
     * @param {AWS_Policy_RoleDeleteArgs} args - Arguments to delete one AWS_Policy_Role.
     * @example
     * // Delete one AWS_Policy_Role
     * const AWS_Policy_Role = await prisma.aWS_Policy_Role.delete({
     *   where: {
     *     // ... filter to delete one AWS_Policy_Role
     *   }
     * })
     * 
     */
    delete<T extends AWS_Policy_RoleDeleteArgs>(args: SelectSubset<T, AWS_Policy_RoleDeleteArgs<ExtArgs>>): Prisma__AWS_Policy_RoleClient<$Result.GetResult<Prisma.$AWS_Policy_RolePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one AWS_Policy_Role.
     * @param {AWS_Policy_RoleUpdateArgs} args - Arguments to update one AWS_Policy_Role.
     * @example
     * // Update one AWS_Policy_Role
     * const aWS_Policy_Role = await prisma.aWS_Policy_Role.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AWS_Policy_RoleUpdateArgs>(args: SelectSubset<T, AWS_Policy_RoleUpdateArgs<ExtArgs>>): Prisma__AWS_Policy_RoleClient<$Result.GetResult<Prisma.$AWS_Policy_RolePayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more AWS_Policy_Roles.
     * @param {AWS_Policy_RoleDeleteManyArgs} args - Arguments to filter AWS_Policy_Roles to delete.
     * @example
     * // Delete a few AWS_Policy_Roles
     * const { count } = await prisma.aWS_Policy_Role.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends AWS_Policy_RoleDeleteManyArgs>(args?: SelectSubset<T, AWS_Policy_RoleDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more AWS_Policy_Roles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AWS_Policy_RoleUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many AWS_Policy_Roles
     * const aWS_Policy_Role = await prisma.aWS_Policy_Role.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends AWS_Policy_RoleUpdateManyArgs>(args: SelectSubset<T, AWS_Policy_RoleUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one AWS_Policy_Role.
     * @param {AWS_Policy_RoleUpsertArgs} args - Arguments to update or create a AWS_Policy_Role.
     * @example
     * // Update or create a AWS_Policy_Role
     * const aWS_Policy_Role = await prisma.aWS_Policy_Role.upsert({
     *   create: {
     *     // ... data to create a AWS_Policy_Role
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the AWS_Policy_Role we want to update
     *   }
     * })
     */
    upsert<T extends AWS_Policy_RoleUpsertArgs>(args: SelectSubset<T, AWS_Policy_RoleUpsertArgs<ExtArgs>>): Prisma__AWS_Policy_RoleClient<$Result.GetResult<Prisma.$AWS_Policy_RolePayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of AWS_Policy_Roles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AWS_Policy_RoleCountArgs} args - Arguments to filter AWS_Policy_Roles to count.
     * @example
     * // Count the number of AWS_Policy_Roles
     * const count = await prisma.aWS_Policy_Role.count({
     *   where: {
     *     // ... the filter for the AWS_Policy_Roles we want to count
     *   }
     * })
    **/
    count<T extends AWS_Policy_RoleCountArgs>(
      args?: Subset<T, AWS_Policy_RoleCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], AWS_Policy_RoleCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a AWS_Policy_Role.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AWS_Policy_RoleAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends AWS_Policy_RoleAggregateArgs>(args: Subset<T, AWS_Policy_RoleAggregateArgs>): Prisma.PrismaPromise<GetAWS_Policy_RoleAggregateType<T>>

    /**
     * Group by AWS_Policy_Role.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AWS_Policy_RoleGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends AWS_Policy_RoleGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AWS_Policy_RoleGroupByArgs['orderBy'] }
        : { orderBy?: AWS_Policy_RoleGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, AWS_Policy_RoleGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAWS_Policy_RoleGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the AWS_Policy_Role model
   */
  readonly fields: AWS_Policy_RoleFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for AWS_Policy_Role.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__AWS_Policy_RoleClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the AWS_Policy_Role model
   */ 
  interface AWS_Policy_RoleFieldRefs {
    readonly id: FieldRef<"AWS_Policy_Role", 'String'>
    readonly assistant_id: FieldRef<"AWS_Policy_Role", 'String'>
    readonly agent_bedrock_policy: FieldRef<"AWS_Policy_Role", 'String'>
    readonly agent_kb_schema_policy: FieldRef<"AWS_Policy_Role", 'String'>
    readonly kb_bedrock_policy: FieldRef<"AWS_Policy_Role", 'String'>
    readonly kb_aoss_policy: FieldRef<"AWS_Policy_Role", 'String'>
    readonly kb_s3_policy: FieldRef<"AWS_Policy_Role", 'String'>
    readonly agent_role_name: FieldRef<"AWS_Policy_Role", 'String'>
    readonly kb_role_name: FieldRef<"AWS_Policy_Role", 'String'>
    readonly createtime: FieldRef<"AWS_Policy_Role", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * AWS_Policy_Role findUnique
   */
  export type AWS_Policy_RoleFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AWS_Policy_Role
     */
    select?: AWS_Policy_RoleSelect<ExtArgs> | null
    /**
     * Filter, which AWS_Policy_Role to fetch.
     */
    where: AWS_Policy_RoleWhereUniqueInput
  }

  /**
   * AWS_Policy_Role findUniqueOrThrow
   */
  export type AWS_Policy_RoleFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AWS_Policy_Role
     */
    select?: AWS_Policy_RoleSelect<ExtArgs> | null
    /**
     * Filter, which AWS_Policy_Role to fetch.
     */
    where: AWS_Policy_RoleWhereUniqueInput
  }

  /**
   * AWS_Policy_Role findFirst
   */
  export type AWS_Policy_RoleFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AWS_Policy_Role
     */
    select?: AWS_Policy_RoleSelect<ExtArgs> | null
    /**
     * Filter, which AWS_Policy_Role to fetch.
     */
    where?: AWS_Policy_RoleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AWS_Policy_Roles to fetch.
     */
    orderBy?: AWS_Policy_RoleOrderByWithRelationInput | AWS_Policy_RoleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AWS_Policy_Roles.
     */
    cursor?: AWS_Policy_RoleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AWS_Policy_Roles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` AWS_Policy_Roles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of AWS_Policy_Roles.
     */
    distinct?: AWS_Policy_RoleScalarFieldEnum | AWS_Policy_RoleScalarFieldEnum[]
  }

  /**
   * AWS_Policy_Role findFirstOrThrow
   */
  export type AWS_Policy_RoleFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AWS_Policy_Role
     */
    select?: AWS_Policy_RoleSelect<ExtArgs> | null
    /**
     * Filter, which AWS_Policy_Role to fetch.
     */
    where?: AWS_Policy_RoleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AWS_Policy_Roles to fetch.
     */
    orderBy?: AWS_Policy_RoleOrderByWithRelationInput | AWS_Policy_RoleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AWS_Policy_Roles.
     */
    cursor?: AWS_Policy_RoleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AWS_Policy_Roles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` AWS_Policy_Roles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of AWS_Policy_Roles.
     */
    distinct?: AWS_Policy_RoleScalarFieldEnum | AWS_Policy_RoleScalarFieldEnum[]
  }

  /**
   * AWS_Policy_Role findMany
   */
  export type AWS_Policy_RoleFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AWS_Policy_Role
     */
    select?: AWS_Policy_RoleSelect<ExtArgs> | null
    /**
     * Filter, which AWS_Policy_Roles to fetch.
     */
    where?: AWS_Policy_RoleWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AWS_Policy_Roles to fetch.
     */
    orderBy?: AWS_Policy_RoleOrderByWithRelationInput | AWS_Policy_RoleOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing AWS_Policy_Roles.
     */
    cursor?: AWS_Policy_RoleWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AWS_Policy_Roles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` AWS_Policy_Roles.
     */
    skip?: number
    distinct?: AWS_Policy_RoleScalarFieldEnum | AWS_Policy_RoleScalarFieldEnum[]
  }

  /**
   * AWS_Policy_Role create
   */
  export type AWS_Policy_RoleCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AWS_Policy_Role
     */
    select?: AWS_Policy_RoleSelect<ExtArgs> | null
    /**
     * The data needed to create a AWS_Policy_Role.
     */
    data: XOR<AWS_Policy_RoleCreateInput, AWS_Policy_RoleUncheckedCreateInput>
  }

  /**
   * AWS_Policy_Role createMany
   */
  export type AWS_Policy_RoleCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many AWS_Policy_Roles.
     */
    data: AWS_Policy_RoleCreateManyInput | AWS_Policy_RoleCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * AWS_Policy_Role update
   */
  export type AWS_Policy_RoleUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AWS_Policy_Role
     */
    select?: AWS_Policy_RoleSelect<ExtArgs> | null
    /**
     * The data needed to update a AWS_Policy_Role.
     */
    data: XOR<AWS_Policy_RoleUpdateInput, AWS_Policy_RoleUncheckedUpdateInput>
    /**
     * Choose, which AWS_Policy_Role to update.
     */
    where: AWS_Policy_RoleWhereUniqueInput
  }

  /**
   * AWS_Policy_Role updateMany
   */
  export type AWS_Policy_RoleUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AWS_Policy_Roles.
     */
    data: XOR<AWS_Policy_RoleUpdateManyMutationInput, AWS_Policy_RoleUncheckedUpdateManyInput>
    /**
     * Filter which AWS_Policy_Roles to update
     */
    where?: AWS_Policy_RoleWhereInput
  }

  /**
   * AWS_Policy_Role upsert
   */
  export type AWS_Policy_RoleUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AWS_Policy_Role
     */
    select?: AWS_Policy_RoleSelect<ExtArgs> | null
    /**
     * The filter to search for the AWS_Policy_Role to update in case it exists.
     */
    where: AWS_Policy_RoleWhereUniqueInput
    /**
     * In case the AWS_Policy_Role found by the `where` argument doesn't exist, create a new AWS_Policy_Role with this data.
     */
    create: XOR<AWS_Policy_RoleCreateInput, AWS_Policy_RoleUncheckedCreateInput>
    /**
     * In case the AWS_Policy_Role was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AWS_Policy_RoleUpdateInput, AWS_Policy_RoleUncheckedUpdateInput>
  }

  /**
   * AWS_Policy_Role delete
   */
  export type AWS_Policy_RoleDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AWS_Policy_Role
     */
    select?: AWS_Policy_RoleSelect<ExtArgs> | null
    /**
     * Filter which AWS_Policy_Role to delete.
     */
    where: AWS_Policy_RoleWhereUniqueInput
  }

  /**
   * AWS_Policy_Role deleteMany
   */
  export type AWS_Policy_RoleDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AWS_Policy_Roles to delete
     */
    where?: AWS_Policy_RoleWhereInput
  }

  /**
   * AWS_Policy_Role without action
   */
  export type AWS_Policy_RoleDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AWS_Policy_Role
     */
    select?: AWS_Policy_RoleSelect<ExtArgs> | null
  }


  /**
   * Model Ai_Agent_Assistants
   */

  export type AggregateAi_Agent_Assistants = {
    _count: Ai_Agent_AssistantsCountAggregateOutputType | null
    _min: Ai_Agent_AssistantsMinAggregateOutputType | null
    _max: Ai_Agent_AssistantsMaxAggregateOutputType | null
  }

  export type Ai_Agent_AssistantsMinAggregateOutputType = {
    id: string | null
    userId: string | null
    username: string | null
    agent_sort: string | null
    agent_tag: string | null
    assistantName: string | null
    description: string | null
    prologue: string | null
    headUrl: string | null
    instructions: string | null
    isRetrieval: boolean | null
    isCode: boolean | null
    isGoogle: boolean | null
    isDalleImage: boolean | null
    functionNames: string | null
    functionContents: string | null
    assistant_id: string | null
    thread_id: string | null
    file_ids: string | null
    file_names: string | null
    isPublish: boolean | null
    organize_id: string | null
    vector_store_id: string | null
    modelType: string | null
    createtime: Date | null
    updatetime: Date | null
    a: string | null
  }

  export type Ai_Agent_AssistantsMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    username: string | null
    agent_sort: string | null
    agent_tag: string | null
    assistantName: string | null
    description: string | null
    prologue: string | null
    headUrl: string | null
    instructions: string | null
    isRetrieval: boolean | null
    isCode: boolean | null
    isGoogle: boolean | null
    isDalleImage: boolean | null
    functionNames: string | null
    functionContents: string | null
    assistant_id: string | null
    thread_id: string | null
    file_ids: string | null
    file_names: string | null
    isPublish: boolean | null
    organize_id: string | null
    vector_store_id: string | null
    modelType: string | null
    createtime: Date | null
    updatetime: Date | null
    a: string | null
  }

  export type Ai_Agent_AssistantsCountAggregateOutputType = {
    id: number
    userId: number
    username: number
    agent_sort: number
    agent_tag: number
    assistantName: number
    description: number
    prologue: number
    headUrl: number
    instructions: number
    isRetrieval: number
    isCode: number
    isGoogle: number
    isDalleImage: number
    functionNames: number
    functionContents: number
    assistant_id: number
    thread_id: number
    file_ids: number
    file_names: number
    isPublish: number
    organize_id: number
    vector_store_id: number
    modelType: number
    createtime: number
    updatetime: number
    a: number
    _all: number
  }


  export type Ai_Agent_AssistantsMinAggregateInputType = {
    id?: true
    userId?: true
    username?: true
    agent_sort?: true
    agent_tag?: true
    assistantName?: true
    description?: true
    prologue?: true
    headUrl?: true
    instructions?: true
    isRetrieval?: true
    isCode?: true
    isGoogle?: true
    isDalleImage?: true
    functionNames?: true
    functionContents?: true
    assistant_id?: true
    thread_id?: true
    file_ids?: true
    file_names?: true
    isPublish?: true
    organize_id?: true
    vector_store_id?: true
    modelType?: true
    createtime?: true
    updatetime?: true
    a?: true
  }

  export type Ai_Agent_AssistantsMaxAggregateInputType = {
    id?: true
    userId?: true
    username?: true
    agent_sort?: true
    agent_tag?: true
    assistantName?: true
    description?: true
    prologue?: true
    headUrl?: true
    instructions?: true
    isRetrieval?: true
    isCode?: true
    isGoogle?: true
    isDalleImage?: true
    functionNames?: true
    functionContents?: true
    assistant_id?: true
    thread_id?: true
    file_ids?: true
    file_names?: true
    isPublish?: true
    organize_id?: true
    vector_store_id?: true
    modelType?: true
    createtime?: true
    updatetime?: true
    a?: true
  }

  export type Ai_Agent_AssistantsCountAggregateInputType = {
    id?: true
    userId?: true
    username?: true
    agent_sort?: true
    agent_tag?: true
    assistantName?: true
    description?: true
    prologue?: true
    headUrl?: true
    instructions?: true
    isRetrieval?: true
    isCode?: true
    isGoogle?: true
    isDalleImage?: true
    functionNames?: true
    functionContents?: true
    assistant_id?: true
    thread_id?: true
    file_ids?: true
    file_names?: true
    isPublish?: true
    organize_id?: true
    vector_store_id?: true
    modelType?: true
    createtime?: true
    updatetime?: true
    a?: true
    _all?: true
  }

  export type Ai_Agent_AssistantsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Ai_Agent_Assistants to aggregate.
     */
    where?: Ai_Agent_AssistantsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Ai_Agent_Assistants to fetch.
     */
    orderBy?: Ai_Agent_AssistantsOrderByWithRelationInput | Ai_Agent_AssistantsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: Ai_Agent_AssistantsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Ai_Agent_Assistants from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Ai_Agent_Assistants.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Ai_Agent_Assistants
    **/
    _count?: true | Ai_Agent_AssistantsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Ai_Agent_AssistantsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Ai_Agent_AssistantsMaxAggregateInputType
  }

  export type GetAi_Agent_AssistantsAggregateType<T extends Ai_Agent_AssistantsAggregateArgs> = {
        [P in keyof T & keyof AggregateAi_Agent_Assistants]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateAi_Agent_Assistants[P]>
      : GetScalarType<T[P], AggregateAi_Agent_Assistants[P]>
  }




  export type Ai_Agent_AssistantsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: Ai_Agent_AssistantsWhereInput
    orderBy?: Ai_Agent_AssistantsOrderByWithAggregationInput | Ai_Agent_AssistantsOrderByWithAggregationInput[]
    by: Ai_Agent_AssistantsScalarFieldEnum[] | Ai_Agent_AssistantsScalarFieldEnum
    having?: Ai_Agent_AssistantsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Ai_Agent_AssistantsCountAggregateInputType | true
    _min?: Ai_Agent_AssistantsMinAggregateInputType
    _max?: Ai_Agent_AssistantsMaxAggregateInputType
  }

  export type Ai_Agent_AssistantsGroupByOutputType = {
    id: string
    userId: string | null
    username: string | null
    agent_sort: string | null
    agent_tag: string | null
    assistantName: string | null
    description: string | null
    prologue: string | null
    headUrl: string | null
    instructions: string | null
    isRetrieval: boolean | null
    isCode: boolean | null
    isGoogle: boolean | null
    isDalleImage: boolean | null
    functionNames: string | null
    functionContents: string | null
    assistant_id: string | null
    thread_id: string | null
    file_ids: string | null
    file_names: string | null
    isPublish: boolean | null
    organize_id: string | null
    vector_store_id: string | null
    modelType: string | null
    createtime: Date | null
    updatetime: Date | null
    a: string | null
    _count: Ai_Agent_AssistantsCountAggregateOutputType | null
    _min: Ai_Agent_AssistantsMinAggregateOutputType | null
    _max: Ai_Agent_AssistantsMaxAggregateOutputType | null
  }

  type GetAi_Agent_AssistantsGroupByPayload<T extends Ai_Agent_AssistantsGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Ai_Agent_AssistantsGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Ai_Agent_AssistantsGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Ai_Agent_AssistantsGroupByOutputType[P]>
            : GetScalarType<T[P], Ai_Agent_AssistantsGroupByOutputType[P]>
        }
      >
    >


  export type Ai_Agent_AssistantsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    username?: boolean
    agent_sort?: boolean
    agent_tag?: boolean
    assistantName?: boolean
    description?: boolean
    prologue?: boolean
    headUrl?: boolean
    instructions?: boolean
    isRetrieval?: boolean
    isCode?: boolean
    isGoogle?: boolean
    isDalleImage?: boolean
    functionNames?: boolean
    functionContents?: boolean
    assistant_id?: boolean
    thread_id?: boolean
    file_ids?: boolean
    file_names?: boolean
    isPublish?: boolean
    organize_id?: boolean
    vector_store_id?: boolean
    modelType?: boolean
    createtime?: boolean
    updatetime?: boolean
    a?: boolean
  }, ExtArgs["result"]["ai_Agent_Assistants"]>


  export type Ai_Agent_AssistantsSelectScalar = {
    id?: boolean
    userId?: boolean
    username?: boolean
    agent_sort?: boolean
    agent_tag?: boolean
    assistantName?: boolean
    description?: boolean
    prologue?: boolean
    headUrl?: boolean
    instructions?: boolean
    isRetrieval?: boolean
    isCode?: boolean
    isGoogle?: boolean
    isDalleImage?: boolean
    functionNames?: boolean
    functionContents?: boolean
    assistant_id?: boolean
    thread_id?: boolean
    file_ids?: boolean
    file_names?: boolean
    isPublish?: boolean
    organize_id?: boolean
    vector_store_id?: boolean
    modelType?: boolean
    createtime?: boolean
    updatetime?: boolean
    a?: boolean
  }


  export type $Ai_Agent_AssistantsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Ai_Agent_Assistants"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string | null
      username: string | null
      agent_sort: string | null
      agent_tag: string | null
      assistantName: string | null
      description: string | null
      prologue: string | null
      headUrl: string | null
      instructions: string | null
      isRetrieval: boolean | null
      isCode: boolean | null
      isGoogle: boolean | null
      isDalleImage: boolean | null
      functionNames: string | null
      functionContents: string | null
      assistant_id: string | null
      thread_id: string | null
      file_ids: string | null
      file_names: string | null
      isPublish: boolean | null
      organize_id: string | null
      vector_store_id: string | null
      modelType: string | null
      createtime: Date | null
      updatetime: Date | null
      a: string | null
    }, ExtArgs["result"]["ai_Agent_Assistants"]>
    composites: {}
  }

  type Ai_Agent_AssistantsGetPayload<S extends boolean | null | undefined | Ai_Agent_AssistantsDefaultArgs> = $Result.GetResult<Prisma.$Ai_Agent_AssistantsPayload, S>

  type Ai_Agent_AssistantsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<Ai_Agent_AssistantsFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Ai_Agent_AssistantsCountAggregateInputType | true
    }

  export interface Ai_Agent_AssistantsDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Ai_Agent_Assistants'], meta: { name: 'Ai_Agent_Assistants' } }
    /**
     * Find zero or one Ai_Agent_Assistants that matches the filter.
     * @param {Ai_Agent_AssistantsFindUniqueArgs} args - Arguments to find a Ai_Agent_Assistants
     * @example
     * // Get one Ai_Agent_Assistants
     * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends Ai_Agent_AssistantsFindUniqueArgs>(args: SelectSubset<T, Ai_Agent_AssistantsFindUniqueArgs<ExtArgs>>): Prisma__Ai_Agent_AssistantsClient<$Result.GetResult<Prisma.$Ai_Agent_AssistantsPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Ai_Agent_Assistants that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {Ai_Agent_AssistantsFindUniqueOrThrowArgs} args - Arguments to find a Ai_Agent_Assistants
     * @example
     * // Get one Ai_Agent_Assistants
     * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends Ai_Agent_AssistantsFindUniqueOrThrowArgs>(args: SelectSubset<T, Ai_Agent_AssistantsFindUniqueOrThrowArgs<ExtArgs>>): Prisma__Ai_Agent_AssistantsClient<$Result.GetResult<Prisma.$Ai_Agent_AssistantsPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Ai_Agent_Assistants that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_AssistantsFindFirstArgs} args - Arguments to find a Ai_Agent_Assistants
     * @example
     * // Get one Ai_Agent_Assistants
     * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends Ai_Agent_AssistantsFindFirstArgs>(args?: SelectSubset<T, Ai_Agent_AssistantsFindFirstArgs<ExtArgs>>): Prisma__Ai_Agent_AssistantsClient<$Result.GetResult<Prisma.$Ai_Agent_AssistantsPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Ai_Agent_Assistants that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_AssistantsFindFirstOrThrowArgs} args - Arguments to find a Ai_Agent_Assistants
     * @example
     * // Get one Ai_Agent_Assistants
     * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends Ai_Agent_AssistantsFindFirstOrThrowArgs>(args?: SelectSubset<T, Ai_Agent_AssistantsFindFirstOrThrowArgs<ExtArgs>>): Prisma__Ai_Agent_AssistantsClient<$Result.GetResult<Prisma.$Ai_Agent_AssistantsPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Ai_Agent_Assistants that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_AssistantsFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Ai_Agent_Assistants
     * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.findMany()
     * 
     * // Get first 10 Ai_Agent_Assistants
     * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const ai_Agent_AssistantsWithIdOnly = await prisma.ai_Agent_Assistants.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends Ai_Agent_AssistantsFindManyArgs>(args?: SelectSubset<T, Ai_Agent_AssistantsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$Ai_Agent_AssistantsPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Ai_Agent_Assistants.
     * @param {Ai_Agent_AssistantsCreateArgs} args - Arguments to create a Ai_Agent_Assistants.
     * @example
     * // Create one Ai_Agent_Assistants
     * const Ai_Agent_Assistants = await prisma.ai_Agent_Assistants.create({
     *   data: {
     *     // ... data to create a Ai_Agent_Assistants
     *   }
     * })
     * 
     */
    create<T extends Ai_Agent_AssistantsCreateArgs>(args: SelectSubset<T, Ai_Agent_AssistantsCreateArgs<ExtArgs>>): Prisma__Ai_Agent_AssistantsClient<$Result.GetResult<Prisma.$Ai_Agent_AssistantsPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Ai_Agent_Assistants.
     * @param {Ai_Agent_AssistantsCreateManyArgs} args - Arguments to create many Ai_Agent_Assistants.
     * @example
     * // Create many Ai_Agent_Assistants
     * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends Ai_Agent_AssistantsCreateManyArgs>(args?: SelectSubset<T, Ai_Agent_AssistantsCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Ai_Agent_Assistants.
     * @param {Ai_Agent_AssistantsDeleteArgs} args - Arguments to delete one Ai_Agent_Assistants.
     * @example
     * // Delete one Ai_Agent_Assistants
     * const Ai_Agent_Assistants = await prisma.ai_Agent_Assistants.delete({
     *   where: {
     *     // ... filter to delete one Ai_Agent_Assistants
     *   }
     * })
     * 
     */
    delete<T extends Ai_Agent_AssistantsDeleteArgs>(args: SelectSubset<T, Ai_Agent_AssistantsDeleteArgs<ExtArgs>>): Prisma__Ai_Agent_AssistantsClient<$Result.GetResult<Prisma.$Ai_Agent_AssistantsPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Ai_Agent_Assistants.
     * @param {Ai_Agent_AssistantsUpdateArgs} args - Arguments to update one Ai_Agent_Assistants.
     * @example
     * // Update one Ai_Agent_Assistants
     * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends Ai_Agent_AssistantsUpdateArgs>(args: SelectSubset<T, Ai_Agent_AssistantsUpdateArgs<ExtArgs>>): Prisma__Ai_Agent_AssistantsClient<$Result.GetResult<Prisma.$Ai_Agent_AssistantsPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Ai_Agent_Assistants.
     * @param {Ai_Agent_AssistantsDeleteManyArgs} args - Arguments to filter Ai_Agent_Assistants to delete.
     * @example
     * // Delete a few Ai_Agent_Assistants
     * const { count } = await prisma.ai_Agent_Assistants.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends Ai_Agent_AssistantsDeleteManyArgs>(args?: SelectSubset<T, Ai_Agent_AssistantsDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Ai_Agent_Assistants.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_AssistantsUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Ai_Agent_Assistants
     * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends Ai_Agent_AssistantsUpdateManyArgs>(args: SelectSubset<T, Ai_Agent_AssistantsUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Ai_Agent_Assistants.
     * @param {Ai_Agent_AssistantsUpsertArgs} args - Arguments to update or create a Ai_Agent_Assistants.
     * @example
     * // Update or create a Ai_Agent_Assistants
     * const ai_Agent_Assistants = await prisma.ai_Agent_Assistants.upsert({
     *   create: {
     *     // ... data to create a Ai_Agent_Assistants
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Ai_Agent_Assistants we want to update
     *   }
     * })
     */
    upsert<T extends Ai_Agent_AssistantsUpsertArgs>(args: SelectSubset<T, Ai_Agent_AssistantsUpsertArgs<ExtArgs>>): Prisma__Ai_Agent_AssistantsClient<$Result.GetResult<Prisma.$Ai_Agent_AssistantsPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Ai_Agent_Assistants.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_AssistantsCountArgs} args - Arguments to filter Ai_Agent_Assistants to count.
     * @example
     * // Count the number of Ai_Agent_Assistants
     * const count = await prisma.ai_Agent_Assistants.count({
     *   where: {
     *     // ... the filter for the Ai_Agent_Assistants we want to count
     *   }
     * })
    **/
    count<T extends Ai_Agent_AssistantsCountArgs>(
      args?: Subset<T, Ai_Agent_AssistantsCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Ai_Agent_AssistantsCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Ai_Agent_Assistants.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_AssistantsAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Ai_Agent_AssistantsAggregateArgs>(args: Subset<T, Ai_Agent_AssistantsAggregateArgs>): Prisma.PrismaPromise<GetAi_Agent_AssistantsAggregateType<T>>

    /**
     * Group by Ai_Agent_Assistants.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_AssistantsGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends Ai_Agent_AssistantsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: Ai_Agent_AssistantsGroupByArgs['orderBy'] }
        : { orderBy?: Ai_Agent_AssistantsGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, Ai_Agent_AssistantsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAi_Agent_AssistantsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Ai_Agent_Assistants model
   */
  readonly fields: Ai_Agent_AssistantsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Ai_Agent_Assistants.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__Ai_Agent_AssistantsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Ai_Agent_Assistants model
   */ 
  interface Ai_Agent_AssistantsFieldRefs {
    readonly id: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly userId: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly username: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly agent_sort: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly agent_tag: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly assistantName: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly description: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly prologue: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly headUrl: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly instructions: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly isRetrieval: FieldRef<"Ai_Agent_Assistants", 'Boolean'>
    readonly isCode: FieldRef<"Ai_Agent_Assistants", 'Boolean'>
    readonly isGoogle: FieldRef<"Ai_Agent_Assistants", 'Boolean'>
    readonly isDalleImage: FieldRef<"Ai_Agent_Assistants", 'Boolean'>
    readonly functionNames: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly functionContents: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly assistant_id: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly thread_id: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly file_ids: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly file_names: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly isPublish: FieldRef<"Ai_Agent_Assistants", 'Boolean'>
    readonly organize_id: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly vector_store_id: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly modelType: FieldRef<"Ai_Agent_Assistants", 'String'>
    readonly createtime: FieldRef<"Ai_Agent_Assistants", 'DateTime'>
    readonly updatetime: FieldRef<"Ai_Agent_Assistants", 'DateTime'>
    readonly a: FieldRef<"Ai_Agent_Assistants", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Ai_Agent_Assistants findUnique
   */
  export type Ai_Agent_AssistantsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Assistants
     */
    select?: Ai_Agent_AssistantsSelect<ExtArgs> | null
    /**
     * Filter, which Ai_Agent_Assistants to fetch.
     */
    where: Ai_Agent_AssistantsWhereUniqueInput
  }

  /**
   * Ai_Agent_Assistants findUniqueOrThrow
   */
  export type Ai_Agent_AssistantsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Assistants
     */
    select?: Ai_Agent_AssistantsSelect<ExtArgs> | null
    /**
     * Filter, which Ai_Agent_Assistants to fetch.
     */
    where: Ai_Agent_AssistantsWhereUniqueInput
  }

  /**
   * Ai_Agent_Assistants findFirst
   */
  export type Ai_Agent_AssistantsFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Assistants
     */
    select?: Ai_Agent_AssistantsSelect<ExtArgs> | null
    /**
     * Filter, which Ai_Agent_Assistants to fetch.
     */
    where?: Ai_Agent_AssistantsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Ai_Agent_Assistants to fetch.
     */
    orderBy?: Ai_Agent_AssistantsOrderByWithRelationInput | Ai_Agent_AssistantsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Ai_Agent_Assistants.
     */
    cursor?: Ai_Agent_AssistantsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Ai_Agent_Assistants from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Ai_Agent_Assistants.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Ai_Agent_Assistants.
     */
    distinct?: Ai_Agent_AssistantsScalarFieldEnum | Ai_Agent_AssistantsScalarFieldEnum[]
  }

  /**
   * Ai_Agent_Assistants findFirstOrThrow
   */
  export type Ai_Agent_AssistantsFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Assistants
     */
    select?: Ai_Agent_AssistantsSelect<ExtArgs> | null
    /**
     * Filter, which Ai_Agent_Assistants to fetch.
     */
    where?: Ai_Agent_AssistantsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Ai_Agent_Assistants to fetch.
     */
    orderBy?: Ai_Agent_AssistantsOrderByWithRelationInput | Ai_Agent_AssistantsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Ai_Agent_Assistants.
     */
    cursor?: Ai_Agent_AssistantsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Ai_Agent_Assistants from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Ai_Agent_Assistants.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Ai_Agent_Assistants.
     */
    distinct?: Ai_Agent_AssistantsScalarFieldEnum | Ai_Agent_AssistantsScalarFieldEnum[]
  }

  /**
   * Ai_Agent_Assistants findMany
   */
  export type Ai_Agent_AssistantsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Assistants
     */
    select?: Ai_Agent_AssistantsSelect<ExtArgs> | null
    /**
     * Filter, which Ai_Agent_Assistants to fetch.
     */
    where?: Ai_Agent_AssistantsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Ai_Agent_Assistants to fetch.
     */
    orderBy?: Ai_Agent_AssistantsOrderByWithRelationInput | Ai_Agent_AssistantsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Ai_Agent_Assistants.
     */
    cursor?: Ai_Agent_AssistantsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Ai_Agent_Assistants from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Ai_Agent_Assistants.
     */
    skip?: number
    distinct?: Ai_Agent_AssistantsScalarFieldEnum | Ai_Agent_AssistantsScalarFieldEnum[]
  }

  /**
   * Ai_Agent_Assistants create
   */
  export type Ai_Agent_AssistantsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Assistants
     */
    select?: Ai_Agent_AssistantsSelect<ExtArgs> | null
    /**
     * The data needed to create a Ai_Agent_Assistants.
     */
    data: XOR<Ai_Agent_AssistantsCreateInput, Ai_Agent_AssistantsUncheckedCreateInput>
  }

  /**
   * Ai_Agent_Assistants createMany
   */
  export type Ai_Agent_AssistantsCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Ai_Agent_Assistants.
     */
    data: Ai_Agent_AssistantsCreateManyInput | Ai_Agent_AssistantsCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Ai_Agent_Assistants update
   */
  export type Ai_Agent_AssistantsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Assistants
     */
    select?: Ai_Agent_AssistantsSelect<ExtArgs> | null
    /**
     * The data needed to update a Ai_Agent_Assistants.
     */
    data: XOR<Ai_Agent_AssistantsUpdateInput, Ai_Agent_AssistantsUncheckedUpdateInput>
    /**
     * Choose, which Ai_Agent_Assistants to update.
     */
    where: Ai_Agent_AssistantsWhereUniqueInput
  }

  /**
   * Ai_Agent_Assistants updateMany
   */
  export type Ai_Agent_AssistantsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Ai_Agent_Assistants.
     */
    data: XOR<Ai_Agent_AssistantsUpdateManyMutationInput, Ai_Agent_AssistantsUncheckedUpdateManyInput>
    /**
     * Filter which Ai_Agent_Assistants to update
     */
    where?: Ai_Agent_AssistantsWhereInput
  }

  /**
   * Ai_Agent_Assistants upsert
   */
  export type Ai_Agent_AssistantsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Assistants
     */
    select?: Ai_Agent_AssistantsSelect<ExtArgs> | null
    /**
     * The filter to search for the Ai_Agent_Assistants to update in case it exists.
     */
    where: Ai_Agent_AssistantsWhereUniqueInput
    /**
     * In case the Ai_Agent_Assistants found by the `where` argument doesn't exist, create a new Ai_Agent_Assistants with this data.
     */
    create: XOR<Ai_Agent_AssistantsCreateInput, Ai_Agent_AssistantsUncheckedCreateInput>
    /**
     * In case the Ai_Agent_Assistants was found with the provided `where` argument, update it with this data.
     */
    update: XOR<Ai_Agent_AssistantsUpdateInput, Ai_Agent_AssistantsUncheckedUpdateInput>
  }

  /**
   * Ai_Agent_Assistants delete
   */
  export type Ai_Agent_AssistantsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Assistants
     */
    select?: Ai_Agent_AssistantsSelect<ExtArgs> | null
    /**
     * Filter which Ai_Agent_Assistants to delete.
     */
    where: Ai_Agent_AssistantsWhereUniqueInput
  }

  /**
   * Ai_Agent_Assistants deleteMany
   */
  export type Ai_Agent_AssistantsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Ai_Agent_Assistants to delete
     */
    where?: Ai_Agent_AssistantsWhereInput
  }

  /**
   * Ai_Agent_Assistants without action
   */
  export type Ai_Agent_AssistantsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Assistants
     */
    select?: Ai_Agent_AssistantsSelect<ExtArgs> | null
  }


  /**
   * Model Ai_Agent_Threads
   */

  export type AggregateAi_Agent_Threads = {
    _count: Ai_Agent_ThreadsCountAggregateOutputType | null
    _min: Ai_Agent_ThreadsMinAggregateOutputType | null
    _max: Ai_Agent_ThreadsMaxAggregateOutputType | null
  }

  export type Ai_Agent_ThreadsMinAggregateOutputType = {
    id: string | null
    userId: string | null
    assistant_id: string | null
    thread_id: string | null
    createtime: Date | null
    session_name: string | null
  }

  export type Ai_Agent_ThreadsMaxAggregateOutputType = {
    id: string | null
    userId: string | null
    assistant_id: string | null
    thread_id: string | null
    createtime: Date | null
    session_name: string | null
  }

  export type Ai_Agent_ThreadsCountAggregateOutputType = {
    id: number
    userId: number
    assistant_id: number
    thread_id: number
    createtime: number
    session_name: number
    _all: number
  }


  export type Ai_Agent_ThreadsMinAggregateInputType = {
    id?: true
    userId?: true
    assistant_id?: true
    thread_id?: true
    createtime?: true
    session_name?: true
  }

  export type Ai_Agent_ThreadsMaxAggregateInputType = {
    id?: true
    userId?: true
    assistant_id?: true
    thread_id?: true
    createtime?: true
    session_name?: true
  }

  export type Ai_Agent_ThreadsCountAggregateInputType = {
    id?: true
    userId?: true
    assistant_id?: true
    thread_id?: true
    createtime?: true
    session_name?: true
    _all?: true
  }

  export type Ai_Agent_ThreadsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Ai_Agent_Threads to aggregate.
     */
    where?: Ai_Agent_ThreadsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Ai_Agent_Threads to fetch.
     */
    orderBy?: Ai_Agent_ThreadsOrderByWithRelationInput | Ai_Agent_ThreadsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: Ai_Agent_ThreadsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Ai_Agent_Threads from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Ai_Agent_Threads.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Ai_Agent_Threads
    **/
    _count?: true | Ai_Agent_ThreadsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Ai_Agent_ThreadsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Ai_Agent_ThreadsMaxAggregateInputType
  }

  export type GetAi_Agent_ThreadsAggregateType<T extends Ai_Agent_ThreadsAggregateArgs> = {
        [P in keyof T & keyof AggregateAi_Agent_Threads]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateAi_Agent_Threads[P]>
      : GetScalarType<T[P], AggregateAi_Agent_Threads[P]>
  }




  export type Ai_Agent_ThreadsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: Ai_Agent_ThreadsWhereInput
    orderBy?: Ai_Agent_ThreadsOrderByWithAggregationInput | Ai_Agent_ThreadsOrderByWithAggregationInput[]
    by: Ai_Agent_ThreadsScalarFieldEnum[] | Ai_Agent_ThreadsScalarFieldEnum
    having?: Ai_Agent_ThreadsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Ai_Agent_ThreadsCountAggregateInputType | true
    _min?: Ai_Agent_ThreadsMinAggregateInputType
    _max?: Ai_Agent_ThreadsMaxAggregateInputType
  }

  export type Ai_Agent_ThreadsGroupByOutputType = {
    id: string
    userId: string | null
    assistant_id: string | null
    thread_id: string | null
    createtime: Date | null
    session_name: string
    _count: Ai_Agent_ThreadsCountAggregateOutputType | null
    _min: Ai_Agent_ThreadsMinAggregateOutputType | null
    _max: Ai_Agent_ThreadsMaxAggregateOutputType | null
  }

  type GetAi_Agent_ThreadsGroupByPayload<T extends Ai_Agent_ThreadsGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Ai_Agent_ThreadsGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Ai_Agent_ThreadsGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Ai_Agent_ThreadsGroupByOutputType[P]>
            : GetScalarType<T[P], Ai_Agent_ThreadsGroupByOutputType[P]>
        }
      >
    >


  export type Ai_Agent_ThreadsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userId?: boolean
    assistant_id?: boolean
    thread_id?: boolean
    createtime?: boolean
    session_name?: boolean
  }, ExtArgs["result"]["ai_Agent_Threads"]>


  export type Ai_Agent_ThreadsSelectScalar = {
    id?: boolean
    userId?: boolean
    assistant_id?: boolean
    thread_id?: boolean
    createtime?: boolean
    session_name?: boolean
  }


  export type $Ai_Agent_ThreadsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Ai_Agent_Threads"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userId: string | null
      assistant_id: string | null
      thread_id: string | null
      createtime: Date | null
      session_name: string
    }, ExtArgs["result"]["ai_Agent_Threads"]>
    composites: {}
  }

  type Ai_Agent_ThreadsGetPayload<S extends boolean | null | undefined | Ai_Agent_ThreadsDefaultArgs> = $Result.GetResult<Prisma.$Ai_Agent_ThreadsPayload, S>

  type Ai_Agent_ThreadsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<Ai_Agent_ThreadsFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Ai_Agent_ThreadsCountAggregateInputType | true
    }

  export interface Ai_Agent_ThreadsDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Ai_Agent_Threads'], meta: { name: 'Ai_Agent_Threads' } }
    /**
     * Find zero or one Ai_Agent_Threads that matches the filter.
     * @param {Ai_Agent_ThreadsFindUniqueArgs} args - Arguments to find a Ai_Agent_Threads
     * @example
     * // Get one Ai_Agent_Threads
     * const ai_Agent_Threads = await prisma.ai_Agent_Threads.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends Ai_Agent_ThreadsFindUniqueArgs>(args: SelectSubset<T, Ai_Agent_ThreadsFindUniqueArgs<ExtArgs>>): Prisma__Ai_Agent_ThreadsClient<$Result.GetResult<Prisma.$Ai_Agent_ThreadsPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Ai_Agent_Threads that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {Ai_Agent_ThreadsFindUniqueOrThrowArgs} args - Arguments to find a Ai_Agent_Threads
     * @example
     * // Get one Ai_Agent_Threads
     * const ai_Agent_Threads = await prisma.ai_Agent_Threads.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends Ai_Agent_ThreadsFindUniqueOrThrowArgs>(args: SelectSubset<T, Ai_Agent_ThreadsFindUniqueOrThrowArgs<ExtArgs>>): Prisma__Ai_Agent_ThreadsClient<$Result.GetResult<Prisma.$Ai_Agent_ThreadsPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Ai_Agent_Threads that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_ThreadsFindFirstArgs} args - Arguments to find a Ai_Agent_Threads
     * @example
     * // Get one Ai_Agent_Threads
     * const ai_Agent_Threads = await prisma.ai_Agent_Threads.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends Ai_Agent_ThreadsFindFirstArgs>(args?: SelectSubset<T, Ai_Agent_ThreadsFindFirstArgs<ExtArgs>>): Prisma__Ai_Agent_ThreadsClient<$Result.GetResult<Prisma.$Ai_Agent_ThreadsPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Ai_Agent_Threads that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_ThreadsFindFirstOrThrowArgs} args - Arguments to find a Ai_Agent_Threads
     * @example
     * // Get one Ai_Agent_Threads
     * const ai_Agent_Threads = await prisma.ai_Agent_Threads.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends Ai_Agent_ThreadsFindFirstOrThrowArgs>(args?: SelectSubset<T, Ai_Agent_ThreadsFindFirstOrThrowArgs<ExtArgs>>): Prisma__Ai_Agent_ThreadsClient<$Result.GetResult<Prisma.$Ai_Agent_ThreadsPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Ai_Agent_Threads that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_ThreadsFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Ai_Agent_Threads
     * const ai_Agent_Threads = await prisma.ai_Agent_Threads.findMany()
     * 
     * // Get first 10 Ai_Agent_Threads
     * const ai_Agent_Threads = await prisma.ai_Agent_Threads.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const ai_Agent_ThreadsWithIdOnly = await prisma.ai_Agent_Threads.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends Ai_Agent_ThreadsFindManyArgs>(args?: SelectSubset<T, Ai_Agent_ThreadsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$Ai_Agent_ThreadsPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Ai_Agent_Threads.
     * @param {Ai_Agent_ThreadsCreateArgs} args - Arguments to create a Ai_Agent_Threads.
     * @example
     * // Create one Ai_Agent_Threads
     * const Ai_Agent_Threads = await prisma.ai_Agent_Threads.create({
     *   data: {
     *     // ... data to create a Ai_Agent_Threads
     *   }
     * })
     * 
     */
    create<T extends Ai_Agent_ThreadsCreateArgs>(args: SelectSubset<T, Ai_Agent_ThreadsCreateArgs<ExtArgs>>): Prisma__Ai_Agent_ThreadsClient<$Result.GetResult<Prisma.$Ai_Agent_ThreadsPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Ai_Agent_Threads.
     * @param {Ai_Agent_ThreadsCreateManyArgs} args - Arguments to create many Ai_Agent_Threads.
     * @example
     * // Create many Ai_Agent_Threads
     * const ai_Agent_Threads = await prisma.ai_Agent_Threads.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends Ai_Agent_ThreadsCreateManyArgs>(args?: SelectSubset<T, Ai_Agent_ThreadsCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Ai_Agent_Threads.
     * @param {Ai_Agent_ThreadsDeleteArgs} args - Arguments to delete one Ai_Agent_Threads.
     * @example
     * // Delete one Ai_Agent_Threads
     * const Ai_Agent_Threads = await prisma.ai_Agent_Threads.delete({
     *   where: {
     *     // ... filter to delete one Ai_Agent_Threads
     *   }
     * })
     * 
     */
    delete<T extends Ai_Agent_ThreadsDeleteArgs>(args: SelectSubset<T, Ai_Agent_ThreadsDeleteArgs<ExtArgs>>): Prisma__Ai_Agent_ThreadsClient<$Result.GetResult<Prisma.$Ai_Agent_ThreadsPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Ai_Agent_Threads.
     * @param {Ai_Agent_ThreadsUpdateArgs} args - Arguments to update one Ai_Agent_Threads.
     * @example
     * // Update one Ai_Agent_Threads
     * const ai_Agent_Threads = await prisma.ai_Agent_Threads.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends Ai_Agent_ThreadsUpdateArgs>(args: SelectSubset<T, Ai_Agent_ThreadsUpdateArgs<ExtArgs>>): Prisma__Ai_Agent_ThreadsClient<$Result.GetResult<Prisma.$Ai_Agent_ThreadsPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Ai_Agent_Threads.
     * @param {Ai_Agent_ThreadsDeleteManyArgs} args - Arguments to filter Ai_Agent_Threads to delete.
     * @example
     * // Delete a few Ai_Agent_Threads
     * const { count } = await prisma.ai_Agent_Threads.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends Ai_Agent_ThreadsDeleteManyArgs>(args?: SelectSubset<T, Ai_Agent_ThreadsDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Ai_Agent_Threads.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_ThreadsUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Ai_Agent_Threads
     * const ai_Agent_Threads = await prisma.ai_Agent_Threads.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends Ai_Agent_ThreadsUpdateManyArgs>(args: SelectSubset<T, Ai_Agent_ThreadsUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Ai_Agent_Threads.
     * @param {Ai_Agent_ThreadsUpsertArgs} args - Arguments to update or create a Ai_Agent_Threads.
     * @example
     * // Update or create a Ai_Agent_Threads
     * const ai_Agent_Threads = await prisma.ai_Agent_Threads.upsert({
     *   create: {
     *     // ... data to create a Ai_Agent_Threads
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Ai_Agent_Threads we want to update
     *   }
     * })
     */
    upsert<T extends Ai_Agent_ThreadsUpsertArgs>(args: SelectSubset<T, Ai_Agent_ThreadsUpsertArgs<ExtArgs>>): Prisma__Ai_Agent_ThreadsClient<$Result.GetResult<Prisma.$Ai_Agent_ThreadsPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Ai_Agent_Threads.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_ThreadsCountArgs} args - Arguments to filter Ai_Agent_Threads to count.
     * @example
     * // Count the number of Ai_Agent_Threads
     * const count = await prisma.ai_Agent_Threads.count({
     *   where: {
     *     // ... the filter for the Ai_Agent_Threads we want to count
     *   }
     * })
    **/
    count<T extends Ai_Agent_ThreadsCountArgs>(
      args?: Subset<T, Ai_Agent_ThreadsCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Ai_Agent_ThreadsCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Ai_Agent_Threads.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_ThreadsAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Ai_Agent_ThreadsAggregateArgs>(args: Subset<T, Ai_Agent_ThreadsAggregateArgs>): Prisma.PrismaPromise<GetAi_Agent_ThreadsAggregateType<T>>

    /**
     * Group by Ai_Agent_Threads.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_Agent_ThreadsGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends Ai_Agent_ThreadsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: Ai_Agent_ThreadsGroupByArgs['orderBy'] }
        : { orderBy?: Ai_Agent_ThreadsGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, Ai_Agent_ThreadsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAi_Agent_ThreadsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Ai_Agent_Threads model
   */
  readonly fields: Ai_Agent_ThreadsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Ai_Agent_Threads.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__Ai_Agent_ThreadsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Ai_Agent_Threads model
   */ 
  interface Ai_Agent_ThreadsFieldRefs {
    readonly id: FieldRef<"Ai_Agent_Threads", 'String'>
    readonly userId: FieldRef<"Ai_Agent_Threads", 'String'>
    readonly assistant_id: FieldRef<"Ai_Agent_Threads", 'String'>
    readonly thread_id: FieldRef<"Ai_Agent_Threads", 'String'>
    readonly createtime: FieldRef<"Ai_Agent_Threads", 'DateTime'>
    readonly session_name: FieldRef<"Ai_Agent_Threads", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Ai_Agent_Threads findUnique
   */
  export type Ai_Agent_ThreadsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Threads
     */
    select?: Ai_Agent_ThreadsSelect<ExtArgs> | null
    /**
     * Filter, which Ai_Agent_Threads to fetch.
     */
    where: Ai_Agent_ThreadsWhereUniqueInput
  }

  /**
   * Ai_Agent_Threads findUniqueOrThrow
   */
  export type Ai_Agent_ThreadsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Threads
     */
    select?: Ai_Agent_ThreadsSelect<ExtArgs> | null
    /**
     * Filter, which Ai_Agent_Threads to fetch.
     */
    where: Ai_Agent_ThreadsWhereUniqueInput
  }

  /**
   * Ai_Agent_Threads findFirst
   */
  export type Ai_Agent_ThreadsFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Threads
     */
    select?: Ai_Agent_ThreadsSelect<ExtArgs> | null
    /**
     * Filter, which Ai_Agent_Threads to fetch.
     */
    where?: Ai_Agent_ThreadsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Ai_Agent_Threads to fetch.
     */
    orderBy?: Ai_Agent_ThreadsOrderByWithRelationInput | Ai_Agent_ThreadsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Ai_Agent_Threads.
     */
    cursor?: Ai_Agent_ThreadsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Ai_Agent_Threads from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Ai_Agent_Threads.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Ai_Agent_Threads.
     */
    distinct?: Ai_Agent_ThreadsScalarFieldEnum | Ai_Agent_ThreadsScalarFieldEnum[]
  }

  /**
   * Ai_Agent_Threads findFirstOrThrow
   */
  export type Ai_Agent_ThreadsFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Threads
     */
    select?: Ai_Agent_ThreadsSelect<ExtArgs> | null
    /**
     * Filter, which Ai_Agent_Threads to fetch.
     */
    where?: Ai_Agent_ThreadsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Ai_Agent_Threads to fetch.
     */
    orderBy?: Ai_Agent_ThreadsOrderByWithRelationInput | Ai_Agent_ThreadsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Ai_Agent_Threads.
     */
    cursor?: Ai_Agent_ThreadsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Ai_Agent_Threads from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Ai_Agent_Threads.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Ai_Agent_Threads.
     */
    distinct?: Ai_Agent_ThreadsScalarFieldEnum | Ai_Agent_ThreadsScalarFieldEnum[]
  }

  /**
   * Ai_Agent_Threads findMany
   */
  export type Ai_Agent_ThreadsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Threads
     */
    select?: Ai_Agent_ThreadsSelect<ExtArgs> | null
    /**
     * Filter, which Ai_Agent_Threads to fetch.
     */
    where?: Ai_Agent_ThreadsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Ai_Agent_Threads to fetch.
     */
    orderBy?: Ai_Agent_ThreadsOrderByWithRelationInput | Ai_Agent_ThreadsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Ai_Agent_Threads.
     */
    cursor?: Ai_Agent_ThreadsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Ai_Agent_Threads from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Ai_Agent_Threads.
     */
    skip?: number
    distinct?: Ai_Agent_ThreadsScalarFieldEnum | Ai_Agent_ThreadsScalarFieldEnum[]
  }

  /**
   * Ai_Agent_Threads create
   */
  export type Ai_Agent_ThreadsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Threads
     */
    select?: Ai_Agent_ThreadsSelect<ExtArgs> | null
    /**
     * The data needed to create a Ai_Agent_Threads.
     */
    data: XOR<Ai_Agent_ThreadsCreateInput, Ai_Agent_ThreadsUncheckedCreateInput>
  }

  /**
   * Ai_Agent_Threads createMany
   */
  export type Ai_Agent_ThreadsCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Ai_Agent_Threads.
     */
    data: Ai_Agent_ThreadsCreateManyInput | Ai_Agent_ThreadsCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Ai_Agent_Threads update
   */
  export type Ai_Agent_ThreadsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Threads
     */
    select?: Ai_Agent_ThreadsSelect<ExtArgs> | null
    /**
     * The data needed to update a Ai_Agent_Threads.
     */
    data: XOR<Ai_Agent_ThreadsUpdateInput, Ai_Agent_ThreadsUncheckedUpdateInput>
    /**
     * Choose, which Ai_Agent_Threads to update.
     */
    where: Ai_Agent_ThreadsWhereUniqueInput
  }

  /**
   * Ai_Agent_Threads updateMany
   */
  export type Ai_Agent_ThreadsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Ai_Agent_Threads.
     */
    data: XOR<Ai_Agent_ThreadsUpdateManyMutationInput, Ai_Agent_ThreadsUncheckedUpdateManyInput>
    /**
     * Filter which Ai_Agent_Threads to update
     */
    where?: Ai_Agent_ThreadsWhereInput
  }

  /**
   * Ai_Agent_Threads upsert
   */
  export type Ai_Agent_ThreadsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Threads
     */
    select?: Ai_Agent_ThreadsSelect<ExtArgs> | null
    /**
     * The filter to search for the Ai_Agent_Threads to update in case it exists.
     */
    where: Ai_Agent_ThreadsWhereUniqueInput
    /**
     * In case the Ai_Agent_Threads found by the `where` argument doesn't exist, create a new Ai_Agent_Threads with this data.
     */
    create: XOR<Ai_Agent_ThreadsCreateInput, Ai_Agent_ThreadsUncheckedCreateInput>
    /**
     * In case the Ai_Agent_Threads was found with the provided `where` argument, update it with this data.
     */
    update: XOR<Ai_Agent_ThreadsUpdateInput, Ai_Agent_ThreadsUncheckedUpdateInput>
  }

  /**
   * Ai_Agent_Threads delete
   */
  export type Ai_Agent_ThreadsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Threads
     */
    select?: Ai_Agent_ThreadsSelect<ExtArgs> | null
    /**
     * Filter which Ai_Agent_Threads to delete.
     */
    where: Ai_Agent_ThreadsWhereUniqueInput
  }

  /**
   * Ai_Agent_Threads deleteMany
   */
  export type Ai_Agent_ThreadsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Ai_Agent_Threads to delete
     */
    where?: Ai_Agent_ThreadsWhereInput
  }

  /**
   * Ai_Agent_Threads without action
   */
  export type Ai_Agent_ThreadsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Ai_Agent_Threads
     */
    select?: Ai_Agent_ThreadsSelect<ExtArgs> | null
  }


  /**
   * Model Assistant
   */

  export type AggregateAssistant = {
    _count: AssistantCountAggregateOutputType | null
    _min: AssistantMinAggregateOutputType | null
    _max: AssistantMaxAggregateOutputType | null
  }

  export type AssistantMinAggregateOutputType = {
    id: string | null
    uid: string | null
    assistant_id: string | null
    thread_id: string | null
    file_ids: string | null
    vector_store_id: string | null
    createtime: Date | null
  }

  export type AssistantMaxAggregateOutputType = {
    id: string | null
    uid: string | null
    assistant_id: string | null
    thread_id: string | null
    file_ids: string | null
    vector_store_id: string | null
    createtime: Date | null
  }

  export type AssistantCountAggregateOutputType = {
    id: number
    uid: number
    assistant_id: number
    thread_id: number
    file_ids: number
    vector_store_id: number
    createtime: number
    _all: number
  }


  export type AssistantMinAggregateInputType = {
    id?: true
    uid?: true
    assistant_id?: true
    thread_id?: true
    file_ids?: true
    vector_store_id?: true
    createtime?: true
  }

  export type AssistantMaxAggregateInputType = {
    id?: true
    uid?: true
    assistant_id?: true
    thread_id?: true
    file_ids?: true
    vector_store_id?: true
    createtime?: true
  }

  export type AssistantCountAggregateInputType = {
    id?: true
    uid?: true
    assistant_id?: true
    thread_id?: true
    file_ids?: true
    vector_store_id?: true
    createtime?: true
    _all?: true
  }

  export type AssistantAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Assistant to aggregate.
     */
    where?: AssistantWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Assistants to fetch.
     */
    orderBy?: AssistantOrderByWithRelationInput | AssistantOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AssistantWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Assistants from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Assistants.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Assistants
    **/
    _count?: true | AssistantCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AssistantMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AssistantMaxAggregateInputType
  }

  export type GetAssistantAggregateType<T extends AssistantAggregateArgs> = {
        [P in keyof T & keyof AggregateAssistant]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateAssistant[P]>
      : GetScalarType<T[P], AggregateAssistant[P]>
  }




  export type AssistantGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AssistantWhereInput
    orderBy?: AssistantOrderByWithAggregationInput | AssistantOrderByWithAggregationInput[]
    by: AssistantScalarFieldEnum[] | AssistantScalarFieldEnum
    having?: AssistantScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AssistantCountAggregateInputType | true
    _min?: AssistantMinAggregateInputType
    _max?: AssistantMaxAggregateInputType
  }

  export type AssistantGroupByOutputType = {
    id: string
    uid: string | null
    assistant_id: string | null
    thread_id: string | null
    file_ids: string | null
    vector_store_id: string | null
    createtime: Date | null
    _count: AssistantCountAggregateOutputType | null
    _min: AssistantMinAggregateOutputType | null
    _max: AssistantMaxAggregateOutputType | null
  }

  type GetAssistantGroupByPayload<T extends AssistantGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<AssistantGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof AssistantGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], AssistantGroupByOutputType[P]>
            : GetScalarType<T[P], AssistantGroupByOutputType[P]>
        }
      >
    >


  export type AssistantSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    uid?: boolean
    assistant_id?: boolean
    thread_id?: boolean
    file_ids?: boolean
    vector_store_id?: boolean
    createtime?: boolean
  }, ExtArgs["result"]["assistant"]>


  export type AssistantSelectScalar = {
    id?: boolean
    uid?: boolean
    assistant_id?: boolean
    thread_id?: boolean
    file_ids?: boolean
    vector_store_id?: boolean
    createtime?: boolean
  }


  export type $AssistantPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Assistant"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      uid: string | null
      assistant_id: string | null
      thread_id: string | null
      file_ids: string | null
      vector_store_id: string | null
      createtime: Date | null
    }, ExtArgs["result"]["assistant"]>
    composites: {}
  }

  type AssistantGetPayload<S extends boolean | null | undefined | AssistantDefaultArgs> = $Result.GetResult<Prisma.$AssistantPayload, S>

  type AssistantCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<AssistantFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: AssistantCountAggregateInputType | true
    }

  export interface AssistantDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Assistant'], meta: { name: 'Assistant' } }
    /**
     * Find zero or one Assistant that matches the filter.
     * @param {AssistantFindUniqueArgs} args - Arguments to find a Assistant
     * @example
     * // Get one Assistant
     * const assistant = await prisma.assistant.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends AssistantFindUniqueArgs>(args: SelectSubset<T, AssistantFindUniqueArgs<ExtArgs>>): Prisma__AssistantClient<$Result.GetResult<Prisma.$AssistantPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Assistant that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {AssistantFindUniqueOrThrowArgs} args - Arguments to find a Assistant
     * @example
     * // Get one Assistant
     * const assistant = await prisma.assistant.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends AssistantFindUniqueOrThrowArgs>(args: SelectSubset<T, AssistantFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AssistantClient<$Result.GetResult<Prisma.$AssistantPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Assistant that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AssistantFindFirstArgs} args - Arguments to find a Assistant
     * @example
     * // Get one Assistant
     * const assistant = await prisma.assistant.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AssistantFindFirstArgs>(args?: SelectSubset<T, AssistantFindFirstArgs<ExtArgs>>): Prisma__AssistantClient<$Result.GetResult<Prisma.$AssistantPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Assistant that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AssistantFindFirstOrThrowArgs} args - Arguments to find a Assistant
     * @example
     * // Get one Assistant
     * const assistant = await prisma.assistant.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AssistantFindFirstOrThrowArgs>(args?: SelectSubset<T, AssistantFindFirstOrThrowArgs<ExtArgs>>): Prisma__AssistantClient<$Result.GetResult<Prisma.$AssistantPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Assistants that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AssistantFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Assistants
     * const assistants = await prisma.assistant.findMany()
     * 
     * // Get first 10 Assistants
     * const assistants = await prisma.assistant.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const assistantWithIdOnly = await prisma.assistant.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends AssistantFindManyArgs>(args?: SelectSubset<T, AssistantFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AssistantPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Assistant.
     * @param {AssistantCreateArgs} args - Arguments to create a Assistant.
     * @example
     * // Create one Assistant
     * const Assistant = await prisma.assistant.create({
     *   data: {
     *     // ... data to create a Assistant
     *   }
     * })
     * 
     */
    create<T extends AssistantCreateArgs>(args: SelectSubset<T, AssistantCreateArgs<ExtArgs>>): Prisma__AssistantClient<$Result.GetResult<Prisma.$AssistantPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Assistants.
     * @param {AssistantCreateManyArgs} args - Arguments to create many Assistants.
     * @example
     * // Create many Assistants
     * const assistant = await prisma.assistant.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends AssistantCreateManyArgs>(args?: SelectSubset<T, AssistantCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Assistant.
     * @param {AssistantDeleteArgs} args - Arguments to delete one Assistant.
     * @example
     * // Delete one Assistant
     * const Assistant = await prisma.assistant.delete({
     *   where: {
     *     // ... filter to delete one Assistant
     *   }
     * })
     * 
     */
    delete<T extends AssistantDeleteArgs>(args: SelectSubset<T, AssistantDeleteArgs<ExtArgs>>): Prisma__AssistantClient<$Result.GetResult<Prisma.$AssistantPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Assistant.
     * @param {AssistantUpdateArgs} args - Arguments to update one Assistant.
     * @example
     * // Update one Assistant
     * const assistant = await prisma.assistant.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AssistantUpdateArgs>(args: SelectSubset<T, AssistantUpdateArgs<ExtArgs>>): Prisma__AssistantClient<$Result.GetResult<Prisma.$AssistantPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Assistants.
     * @param {AssistantDeleteManyArgs} args - Arguments to filter Assistants to delete.
     * @example
     * // Delete a few Assistants
     * const { count } = await prisma.assistant.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends AssistantDeleteManyArgs>(args?: SelectSubset<T, AssistantDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Assistants.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AssistantUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Assistants
     * const assistant = await prisma.assistant.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends AssistantUpdateManyArgs>(args: SelectSubset<T, AssistantUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Assistant.
     * @param {AssistantUpsertArgs} args - Arguments to update or create a Assistant.
     * @example
     * // Update or create a Assistant
     * const assistant = await prisma.assistant.upsert({
     *   create: {
     *     // ... data to create a Assistant
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Assistant we want to update
     *   }
     * })
     */
    upsert<T extends AssistantUpsertArgs>(args: SelectSubset<T, AssistantUpsertArgs<ExtArgs>>): Prisma__AssistantClient<$Result.GetResult<Prisma.$AssistantPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Assistants.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AssistantCountArgs} args - Arguments to filter Assistants to count.
     * @example
     * // Count the number of Assistants
     * const count = await prisma.assistant.count({
     *   where: {
     *     // ... the filter for the Assistants we want to count
     *   }
     * })
    **/
    count<T extends AssistantCountArgs>(
      args?: Subset<T, AssistantCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], AssistantCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Assistant.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AssistantAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends AssistantAggregateArgs>(args: Subset<T, AssistantAggregateArgs>): Prisma.PrismaPromise<GetAssistantAggregateType<T>>

    /**
     * Group by Assistant.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AssistantGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends AssistantGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AssistantGroupByArgs['orderBy'] }
        : { orderBy?: AssistantGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, AssistantGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAssistantGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Assistant model
   */
  readonly fields: AssistantFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Assistant.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__AssistantClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Assistant model
   */ 
  interface AssistantFieldRefs {
    readonly id: FieldRef<"Assistant", 'String'>
    readonly uid: FieldRef<"Assistant", 'String'>
    readonly assistant_id: FieldRef<"Assistant", 'String'>
    readonly thread_id: FieldRef<"Assistant", 'String'>
    readonly file_ids: FieldRef<"Assistant", 'String'>
    readonly vector_store_id: FieldRef<"Assistant", 'String'>
    readonly createtime: FieldRef<"Assistant", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Assistant findUnique
   */
  export type AssistantFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Assistant
     */
    select?: AssistantSelect<ExtArgs> | null
    /**
     * Filter, which Assistant to fetch.
     */
    where: AssistantWhereUniqueInput
  }

  /**
   * Assistant findUniqueOrThrow
   */
  export type AssistantFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Assistant
     */
    select?: AssistantSelect<ExtArgs> | null
    /**
     * Filter, which Assistant to fetch.
     */
    where: AssistantWhereUniqueInput
  }

  /**
   * Assistant findFirst
   */
  export type AssistantFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Assistant
     */
    select?: AssistantSelect<ExtArgs> | null
    /**
     * Filter, which Assistant to fetch.
     */
    where?: AssistantWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Assistants to fetch.
     */
    orderBy?: AssistantOrderByWithRelationInput | AssistantOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Assistants.
     */
    cursor?: AssistantWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Assistants from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Assistants.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Assistants.
     */
    distinct?: AssistantScalarFieldEnum | AssistantScalarFieldEnum[]
  }

  /**
   * Assistant findFirstOrThrow
   */
  export type AssistantFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Assistant
     */
    select?: AssistantSelect<ExtArgs> | null
    /**
     * Filter, which Assistant to fetch.
     */
    where?: AssistantWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Assistants to fetch.
     */
    orderBy?: AssistantOrderByWithRelationInput | AssistantOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Assistants.
     */
    cursor?: AssistantWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Assistants from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Assistants.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Assistants.
     */
    distinct?: AssistantScalarFieldEnum | AssistantScalarFieldEnum[]
  }

  /**
   * Assistant findMany
   */
  export type AssistantFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Assistant
     */
    select?: AssistantSelect<ExtArgs> | null
    /**
     * Filter, which Assistants to fetch.
     */
    where?: AssistantWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Assistants to fetch.
     */
    orderBy?: AssistantOrderByWithRelationInput | AssistantOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Assistants.
     */
    cursor?: AssistantWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Assistants from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Assistants.
     */
    skip?: number
    distinct?: AssistantScalarFieldEnum | AssistantScalarFieldEnum[]
  }

  /**
   * Assistant create
   */
  export type AssistantCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Assistant
     */
    select?: AssistantSelect<ExtArgs> | null
    /**
     * The data needed to create a Assistant.
     */
    data: XOR<AssistantCreateInput, AssistantUncheckedCreateInput>
  }

  /**
   * Assistant createMany
   */
  export type AssistantCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Assistants.
     */
    data: AssistantCreateManyInput | AssistantCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Assistant update
   */
  export type AssistantUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Assistant
     */
    select?: AssistantSelect<ExtArgs> | null
    /**
     * The data needed to update a Assistant.
     */
    data: XOR<AssistantUpdateInput, AssistantUncheckedUpdateInput>
    /**
     * Choose, which Assistant to update.
     */
    where: AssistantWhereUniqueInput
  }

  /**
   * Assistant updateMany
   */
  export type AssistantUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Assistants.
     */
    data: XOR<AssistantUpdateManyMutationInput, AssistantUncheckedUpdateManyInput>
    /**
     * Filter which Assistants to update
     */
    where?: AssistantWhereInput
  }

  /**
   * Assistant upsert
   */
  export type AssistantUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Assistant
     */
    select?: AssistantSelect<ExtArgs> | null
    /**
     * The filter to search for the Assistant to update in case it exists.
     */
    where: AssistantWhereUniqueInput
    /**
     * In case the Assistant found by the `where` argument doesn't exist, create a new Assistant with this data.
     */
    create: XOR<AssistantCreateInput, AssistantUncheckedCreateInput>
    /**
     * In case the Assistant was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AssistantUpdateInput, AssistantUncheckedUpdateInput>
  }

  /**
   * Assistant delete
   */
  export type AssistantDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Assistant
     */
    select?: AssistantSelect<ExtArgs> | null
    /**
     * Filter which Assistant to delete.
     */
    where: AssistantWhereUniqueInput
  }

  /**
   * Assistant deleteMany
   */
  export type AssistantDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Assistants to delete
     */
    where?: AssistantWhereInput
  }

  /**
   * Assistant without action
   */
  export type AssistantDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Assistant
     */
    select?: AssistantSelect<ExtArgs> | null
  }


  /**
   * Model Chat
   */

  export type AggregateChat = {
    _count: ChatCountAggregateOutputType | null
    _avg: ChatAvgAggregateOutputType | null
    _sum: ChatSumAggregateOutputType | null
    _min: ChatMinAggregateOutputType | null
    _max: ChatMaxAggregateOutputType | null
  }

  export type ChatAvgAggregateOutputType = {
    isMindMap: number | null
  }

  export type ChatSumAggregateOutputType = {
    isMindMap: number | null
  }

  export type ChatMinAggregateOutputType = {
    id: string | null
    groupid: string | null
    userid: string | null
    username: string | null
    answer: string | null
    problem: string | null
    createtime: Date | null
    fileid: string | null
    isMindMap: number | null
    filename: string | null
    session_name: string | null
    scene: string | null
  }

  export type ChatMaxAggregateOutputType = {
    id: string | null
    groupid: string | null
    userid: string | null
    username: string | null
    answer: string | null
    problem: string | null
    createtime: Date | null
    fileid: string | null
    isMindMap: number | null
    filename: string | null
    session_name: string | null
    scene: string | null
  }

  export type ChatCountAggregateOutputType = {
    id: number
    groupid: number
    userid: number
    username: number
    answer: number
    problem: number
    createtime: number
    fileid: number
    isMindMap: number
    filename: number
    session_name: number
    scene: number
    _all: number
  }


  export type ChatAvgAggregateInputType = {
    isMindMap?: true
  }

  export type ChatSumAggregateInputType = {
    isMindMap?: true
  }

  export type ChatMinAggregateInputType = {
    id?: true
    groupid?: true
    userid?: true
    username?: true
    answer?: true
    problem?: true
    createtime?: true
    fileid?: true
    isMindMap?: true
    filename?: true
    session_name?: true
    scene?: true
  }

  export type ChatMaxAggregateInputType = {
    id?: true
    groupid?: true
    userid?: true
    username?: true
    answer?: true
    problem?: true
    createtime?: true
    fileid?: true
    isMindMap?: true
    filename?: true
    session_name?: true
    scene?: true
  }

  export type ChatCountAggregateInputType = {
    id?: true
    groupid?: true
    userid?: true
    username?: true
    answer?: true
    problem?: true
    createtime?: true
    fileid?: true
    isMindMap?: true
    filename?: true
    session_name?: true
    scene?: true
    _all?: true
  }

  export type ChatAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Chat to aggregate.
     */
    where?: ChatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Chats to fetch.
     */
    orderBy?: ChatOrderByWithRelationInput | ChatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ChatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Chats from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Chats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Chats
    **/
    _count?: true | ChatCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ChatAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ChatSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ChatMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ChatMaxAggregateInputType
  }

  export type GetChatAggregateType<T extends ChatAggregateArgs> = {
        [P in keyof T & keyof AggregateChat]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateChat[P]>
      : GetScalarType<T[P], AggregateChat[P]>
  }




  export type ChatGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChatWhereInput
    orderBy?: ChatOrderByWithAggregationInput | ChatOrderByWithAggregationInput[]
    by: ChatScalarFieldEnum[] | ChatScalarFieldEnum
    having?: ChatScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChatCountAggregateInputType | true
    _avg?: ChatAvgAggregateInputType
    _sum?: ChatSumAggregateInputType
    _min?: ChatMinAggregateInputType
    _max?: ChatMaxAggregateInputType
  }

  export type ChatGroupByOutputType = {
    id: string
    groupid: string | null
    userid: string | null
    username: string | null
    answer: string | null
    problem: string | null
    createtime: Date | null
    fileid: string | null
    isMindMap: number | null
    filename: string | null
    session_name: string
    scene: string | null
    _count: ChatCountAggregateOutputType | null
    _avg: ChatAvgAggregateOutputType | null
    _sum: ChatSumAggregateOutputType | null
    _min: ChatMinAggregateOutputType | null
    _max: ChatMaxAggregateOutputType | null
  }

  type GetChatGroupByPayload<T extends ChatGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ChatGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ChatGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ChatGroupByOutputType[P]>
            : GetScalarType<T[P], ChatGroupByOutputType[P]>
        }
      >
    >


  export type ChatSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    groupid?: boolean
    userid?: boolean
    username?: boolean
    answer?: boolean
    problem?: boolean
    createtime?: boolean
    fileid?: boolean
    isMindMap?: boolean
    filename?: boolean
    session_name?: boolean
    scene?: boolean
  }, ExtArgs["result"]["chat"]>


  export type ChatSelectScalar = {
    id?: boolean
    groupid?: boolean
    userid?: boolean
    username?: boolean
    answer?: boolean
    problem?: boolean
    createtime?: boolean
    fileid?: boolean
    isMindMap?: boolean
    filename?: boolean
    session_name?: boolean
    scene?: boolean
  }


  export type $ChatPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Chat"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      groupid: string | null
      userid: string | null
      username: string | null
      answer: string | null
      problem: string | null
      createtime: Date | null
      fileid: string | null
      isMindMap: number | null
      filename: string | null
      session_name: string
      scene: string | null
    }, ExtArgs["result"]["chat"]>
    composites: {}
  }

  type ChatGetPayload<S extends boolean | null | undefined | ChatDefaultArgs> = $Result.GetResult<Prisma.$ChatPayload, S>

  type ChatCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChatFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ChatCountAggregateInputType | true
    }

  export interface ChatDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Chat'], meta: { name: 'Chat' } }
    /**
     * Find zero or one Chat that matches the filter.
     * @param {ChatFindUniqueArgs} args - Arguments to find a Chat
     * @example
     * // Get one Chat
     * const chat = await prisma.chat.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends ChatFindUniqueArgs>(args: SelectSubset<T, ChatFindUniqueArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Chat that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {ChatFindUniqueOrThrowArgs} args - Arguments to find a Chat
     * @example
     * // Get one Chat
     * const chat = await prisma.chat.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends ChatFindUniqueOrThrowArgs>(args: SelectSubset<T, ChatFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Chat that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ChatFindFirstArgs} args - Arguments to find a Chat
     * @example
     * // Get one Chat
     * const chat = await prisma.chat.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ChatFindFirstArgs>(args?: SelectSubset<T, ChatFindFirstArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Chat that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ChatFindFirstOrThrowArgs} args - Arguments to find a Chat
     * @example
     * // Get one Chat
     * const chat = await prisma.chat.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ChatFindFirstOrThrowArgs>(args?: SelectSubset<T, ChatFindFirstOrThrowArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Chats that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ChatFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Chats
     * const chats = await prisma.chat.findMany()
     * 
     * // Get first 10 Chats
     * const chats = await prisma.chat.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const chatWithIdOnly = await prisma.chat.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ChatFindManyArgs>(args?: SelectSubset<T, ChatFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Chat.
     * @param {ChatCreateArgs} args - Arguments to create a Chat.
     * @example
     * // Create one Chat
     * const Chat = await prisma.chat.create({
     *   data: {
     *     // ... data to create a Chat
     *   }
     * })
     * 
     */
    create<T extends ChatCreateArgs>(args: SelectSubset<T, ChatCreateArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Chats.
     * @param {ChatCreateManyArgs} args - Arguments to create many Chats.
     * @example
     * // Create many Chats
     * const chat = await prisma.chat.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends ChatCreateManyArgs>(args?: SelectSubset<T, ChatCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Chat.
     * @param {ChatDeleteArgs} args - Arguments to delete one Chat.
     * @example
     * // Delete one Chat
     * const Chat = await prisma.chat.delete({
     *   where: {
     *     // ... filter to delete one Chat
     *   }
     * })
     * 
     */
    delete<T extends ChatDeleteArgs>(args: SelectSubset<T, ChatDeleteArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Chat.
     * @param {ChatUpdateArgs} args - Arguments to update one Chat.
     * @example
     * // Update one Chat
     * const chat = await prisma.chat.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ChatUpdateArgs>(args: SelectSubset<T, ChatUpdateArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Chats.
     * @param {ChatDeleteManyArgs} args - Arguments to filter Chats to delete.
     * @example
     * // Delete a few Chats
     * const { count } = await prisma.chat.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends ChatDeleteManyArgs>(args?: SelectSubset<T, ChatDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Chats.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ChatUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Chats
     * const chat = await prisma.chat.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends ChatUpdateManyArgs>(args: SelectSubset<T, ChatUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Chat.
     * @param {ChatUpsertArgs} args - Arguments to update or create a Chat.
     * @example
     * // Update or create a Chat
     * const chat = await prisma.chat.upsert({
     *   create: {
     *     // ... data to create a Chat
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Chat we want to update
     *   }
     * })
     */
    upsert<T extends ChatUpsertArgs>(args: SelectSubset<T, ChatUpsertArgs<ExtArgs>>): Prisma__ChatClient<$Result.GetResult<Prisma.$ChatPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Chats.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ChatCountArgs} args - Arguments to filter Chats to count.
     * @example
     * // Count the number of Chats
     * const count = await prisma.chat.count({
     *   where: {
     *     // ... the filter for the Chats we want to count
     *   }
     * })
    **/
    count<T extends ChatCountArgs>(
      args?: Subset<T, ChatCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ChatCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Chat.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ChatAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends ChatAggregateArgs>(args: Subset<T, ChatAggregateArgs>): Prisma.PrismaPromise<GetChatAggregateType<T>>

    /**
     * Group by Chat.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ChatGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends ChatGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ChatGroupByArgs['orderBy'] }
        : { orderBy?: ChatGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, ChatGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetChatGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Chat model
   */
  readonly fields: ChatFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Chat.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__ChatClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Chat model
   */ 
  interface ChatFieldRefs {
    readonly id: FieldRef<"Chat", 'String'>
    readonly groupid: FieldRef<"Chat", 'String'>
    readonly userid: FieldRef<"Chat", 'String'>
    readonly username: FieldRef<"Chat", 'String'>
    readonly answer: FieldRef<"Chat", 'String'>
    readonly problem: FieldRef<"Chat", 'String'>
    readonly createtime: FieldRef<"Chat", 'DateTime'>
    readonly fileid: FieldRef<"Chat", 'String'>
    readonly isMindMap: FieldRef<"Chat", 'Int'>
    readonly filename: FieldRef<"Chat", 'String'>
    readonly session_name: FieldRef<"Chat", 'String'>
    readonly scene: FieldRef<"Chat", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Chat findUnique
   */
  export type ChatFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Filter, which Chat to fetch.
     */
    where: ChatWhereUniqueInput
  }

  /**
   * Chat findUniqueOrThrow
   */
  export type ChatFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Filter, which Chat to fetch.
     */
    where: ChatWhereUniqueInput
  }

  /**
   * Chat findFirst
   */
  export type ChatFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Filter, which Chat to fetch.
     */
    where?: ChatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Chats to fetch.
     */
    orderBy?: ChatOrderByWithRelationInput | ChatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Chats.
     */
    cursor?: ChatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Chats from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Chats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Chats.
     */
    distinct?: ChatScalarFieldEnum | ChatScalarFieldEnum[]
  }

  /**
   * Chat findFirstOrThrow
   */
  export type ChatFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Filter, which Chat to fetch.
     */
    where?: ChatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Chats to fetch.
     */
    orderBy?: ChatOrderByWithRelationInput | ChatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Chats.
     */
    cursor?: ChatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Chats from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Chats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Chats.
     */
    distinct?: ChatScalarFieldEnum | ChatScalarFieldEnum[]
  }

  /**
   * Chat findMany
   */
  export type ChatFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Filter, which Chats to fetch.
     */
    where?: ChatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Chats to fetch.
     */
    orderBy?: ChatOrderByWithRelationInput | ChatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Chats.
     */
    cursor?: ChatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Chats from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Chats.
     */
    skip?: number
    distinct?: ChatScalarFieldEnum | ChatScalarFieldEnum[]
  }

  /**
   * Chat create
   */
  export type ChatCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * The data needed to create a Chat.
     */
    data?: XOR<ChatCreateInput, ChatUncheckedCreateInput>
  }

  /**
   * Chat createMany
   */
  export type ChatCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Chats.
     */
    data: ChatCreateManyInput | ChatCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Chat update
   */
  export type ChatUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * The data needed to update a Chat.
     */
    data: XOR<ChatUpdateInput, ChatUncheckedUpdateInput>
    /**
     * Choose, which Chat to update.
     */
    where: ChatWhereUniqueInput
  }

  /**
   * Chat updateMany
   */
  export type ChatUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Chats.
     */
    data: XOR<ChatUpdateManyMutationInput, ChatUncheckedUpdateManyInput>
    /**
     * Filter which Chats to update
     */
    where?: ChatWhereInput
  }

  /**
   * Chat upsert
   */
  export type ChatUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * The filter to search for the Chat to update in case it exists.
     */
    where: ChatWhereUniqueInput
    /**
     * In case the Chat found by the `where` argument doesn't exist, create a new Chat with this data.
     */
    create: XOR<ChatCreateInput, ChatUncheckedCreateInput>
    /**
     * In case the Chat was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChatUpdateInput, ChatUncheckedUpdateInput>
  }

  /**
   * Chat delete
   */
  export type ChatDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
    /**
     * Filter which Chat to delete.
     */
    where: ChatWhereUniqueInput
  }

  /**
   * Chat deleteMany
   */
  export type ChatDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Chats to delete
     */
    where?: ChatWhereInput
  }

  /**
   * Chat without action
   */
  export type ChatDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Chat
     */
    select?: ChatSelect<ExtArgs> | null
  }


  /**
   * Model Disposition
   */

  export type AggregateDisposition = {
    _count: DispositionCountAggregateOutputType | null
    _min: DispositionMinAggregateOutputType | null
    _max: DispositionMaxAggregateOutputType | null
  }

  export type DispositionMinAggregateOutputType = {
    id: string | null
    module: string | null
    disposition_class: string | null
    disposition_type: string | null
    disposition_style: string | null
    disposition_theme: string | null
    user_id: string | null
    create_time: Date | null
  }

  export type DispositionMaxAggregateOutputType = {
    id: string | null
    module: string | null
    disposition_class: string | null
    disposition_type: string | null
    disposition_style: string | null
    disposition_theme: string | null
    user_id: string | null
    create_time: Date | null
  }

  export type DispositionCountAggregateOutputType = {
    id: number
    module: number
    disposition_class: number
    disposition_type: number
    disposition_style: number
    disposition_theme: number
    user_id: number
    create_time: number
    _all: number
  }


  export type DispositionMinAggregateInputType = {
    id?: true
    module?: true
    disposition_class?: true
    disposition_type?: true
    disposition_style?: true
    disposition_theme?: true
    user_id?: true
    create_time?: true
  }

  export type DispositionMaxAggregateInputType = {
    id?: true
    module?: true
    disposition_class?: true
    disposition_type?: true
    disposition_style?: true
    disposition_theme?: true
    user_id?: true
    create_time?: true
  }

  export type DispositionCountAggregateInputType = {
    id?: true
    module?: true
    disposition_class?: true
    disposition_type?: true
    disposition_style?: true
    disposition_theme?: true
    user_id?: true
    create_time?: true
    _all?: true
  }

  export type DispositionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Disposition to aggregate.
     */
    where?: DispositionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Dispositions to fetch.
     */
    orderBy?: DispositionOrderByWithRelationInput | DispositionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: DispositionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Dispositions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Dispositions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Dispositions
    **/
    _count?: true | DispositionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: DispositionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: DispositionMaxAggregateInputType
  }

  export type GetDispositionAggregateType<T extends DispositionAggregateArgs> = {
        [P in keyof T & keyof AggregateDisposition]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateDisposition[P]>
      : GetScalarType<T[P], AggregateDisposition[P]>
  }




  export type DispositionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: DispositionWhereInput
    orderBy?: DispositionOrderByWithAggregationInput | DispositionOrderByWithAggregationInput[]
    by: DispositionScalarFieldEnum[] | DispositionScalarFieldEnum
    having?: DispositionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: DispositionCountAggregateInputType | true
    _min?: DispositionMinAggregateInputType
    _max?: DispositionMaxAggregateInputType
  }

  export type DispositionGroupByOutputType = {
    id: string
    module: string | null
    disposition_class: string | null
    disposition_type: string | null
    disposition_style: string | null
    disposition_theme: string | null
    user_id: string | null
    create_time: Date | null
    _count: DispositionCountAggregateOutputType | null
    _min: DispositionMinAggregateOutputType | null
    _max: DispositionMaxAggregateOutputType | null
  }

  type GetDispositionGroupByPayload<T extends DispositionGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<DispositionGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof DispositionGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], DispositionGroupByOutputType[P]>
            : GetScalarType<T[P], DispositionGroupByOutputType[P]>
        }
      >
    >


  export type DispositionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    module?: boolean
    disposition_class?: boolean
    disposition_type?: boolean
    disposition_style?: boolean
    disposition_theme?: boolean
    user_id?: boolean
    create_time?: boolean
  }, ExtArgs["result"]["disposition"]>


  export type DispositionSelectScalar = {
    id?: boolean
    module?: boolean
    disposition_class?: boolean
    disposition_type?: boolean
    disposition_style?: boolean
    disposition_theme?: boolean
    user_id?: boolean
    create_time?: boolean
  }


  export type $DispositionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Disposition"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      module: string | null
      disposition_class: string | null
      disposition_type: string | null
      disposition_style: string | null
      disposition_theme: string | null
      user_id: string | null
      create_time: Date | null
    }, ExtArgs["result"]["disposition"]>
    composites: {}
  }

  type DispositionGetPayload<S extends boolean | null | undefined | DispositionDefaultArgs> = $Result.GetResult<Prisma.$DispositionPayload, S>

  type DispositionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<DispositionFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: DispositionCountAggregateInputType | true
    }

  export interface DispositionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Disposition'], meta: { name: 'Disposition' } }
    /**
     * Find zero or one Disposition that matches the filter.
     * @param {DispositionFindUniqueArgs} args - Arguments to find a Disposition
     * @example
     * // Get one Disposition
     * const disposition = await prisma.disposition.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends DispositionFindUniqueArgs>(args: SelectSubset<T, DispositionFindUniqueArgs<ExtArgs>>): Prisma__DispositionClient<$Result.GetResult<Prisma.$DispositionPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Disposition that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {DispositionFindUniqueOrThrowArgs} args - Arguments to find a Disposition
     * @example
     * // Get one Disposition
     * const disposition = await prisma.disposition.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends DispositionFindUniqueOrThrowArgs>(args: SelectSubset<T, DispositionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__DispositionClient<$Result.GetResult<Prisma.$DispositionPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Disposition that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DispositionFindFirstArgs} args - Arguments to find a Disposition
     * @example
     * // Get one Disposition
     * const disposition = await prisma.disposition.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends DispositionFindFirstArgs>(args?: SelectSubset<T, DispositionFindFirstArgs<ExtArgs>>): Prisma__DispositionClient<$Result.GetResult<Prisma.$DispositionPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Disposition that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DispositionFindFirstOrThrowArgs} args - Arguments to find a Disposition
     * @example
     * // Get one Disposition
     * const disposition = await prisma.disposition.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends DispositionFindFirstOrThrowArgs>(args?: SelectSubset<T, DispositionFindFirstOrThrowArgs<ExtArgs>>): Prisma__DispositionClient<$Result.GetResult<Prisma.$DispositionPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Dispositions that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DispositionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Dispositions
     * const dispositions = await prisma.disposition.findMany()
     * 
     * // Get first 10 Dispositions
     * const dispositions = await prisma.disposition.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const dispositionWithIdOnly = await prisma.disposition.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends DispositionFindManyArgs>(args?: SelectSubset<T, DispositionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$DispositionPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Disposition.
     * @param {DispositionCreateArgs} args - Arguments to create a Disposition.
     * @example
     * // Create one Disposition
     * const Disposition = await prisma.disposition.create({
     *   data: {
     *     // ... data to create a Disposition
     *   }
     * })
     * 
     */
    create<T extends DispositionCreateArgs>(args: SelectSubset<T, DispositionCreateArgs<ExtArgs>>): Prisma__DispositionClient<$Result.GetResult<Prisma.$DispositionPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Dispositions.
     * @param {DispositionCreateManyArgs} args - Arguments to create many Dispositions.
     * @example
     * // Create many Dispositions
     * const disposition = await prisma.disposition.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends DispositionCreateManyArgs>(args?: SelectSubset<T, DispositionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Disposition.
     * @param {DispositionDeleteArgs} args - Arguments to delete one Disposition.
     * @example
     * // Delete one Disposition
     * const Disposition = await prisma.disposition.delete({
     *   where: {
     *     // ... filter to delete one Disposition
     *   }
     * })
     * 
     */
    delete<T extends DispositionDeleteArgs>(args: SelectSubset<T, DispositionDeleteArgs<ExtArgs>>): Prisma__DispositionClient<$Result.GetResult<Prisma.$DispositionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Disposition.
     * @param {DispositionUpdateArgs} args - Arguments to update one Disposition.
     * @example
     * // Update one Disposition
     * const disposition = await prisma.disposition.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends DispositionUpdateArgs>(args: SelectSubset<T, DispositionUpdateArgs<ExtArgs>>): Prisma__DispositionClient<$Result.GetResult<Prisma.$DispositionPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Dispositions.
     * @param {DispositionDeleteManyArgs} args - Arguments to filter Dispositions to delete.
     * @example
     * // Delete a few Dispositions
     * const { count } = await prisma.disposition.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends DispositionDeleteManyArgs>(args?: SelectSubset<T, DispositionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Dispositions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DispositionUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Dispositions
     * const disposition = await prisma.disposition.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends DispositionUpdateManyArgs>(args: SelectSubset<T, DispositionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Disposition.
     * @param {DispositionUpsertArgs} args - Arguments to update or create a Disposition.
     * @example
     * // Update or create a Disposition
     * const disposition = await prisma.disposition.upsert({
     *   create: {
     *     // ... data to create a Disposition
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Disposition we want to update
     *   }
     * })
     */
    upsert<T extends DispositionUpsertArgs>(args: SelectSubset<T, DispositionUpsertArgs<ExtArgs>>): Prisma__DispositionClient<$Result.GetResult<Prisma.$DispositionPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Dispositions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DispositionCountArgs} args - Arguments to filter Dispositions to count.
     * @example
     * // Count the number of Dispositions
     * const count = await prisma.disposition.count({
     *   where: {
     *     // ... the filter for the Dispositions we want to count
     *   }
     * })
    **/
    count<T extends DispositionCountArgs>(
      args?: Subset<T, DispositionCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], DispositionCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Disposition.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DispositionAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends DispositionAggregateArgs>(args: Subset<T, DispositionAggregateArgs>): Prisma.PrismaPromise<GetDispositionAggregateType<T>>

    /**
     * Group by Disposition.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {DispositionGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends DispositionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: DispositionGroupByArgs['orderBy'] }
        : { orderBy?: DispositionGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, DispositionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetDispositionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Disposition model
   */
  readonly fields: DispositionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Disposition.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__DispositionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Disposition model
   */ 
  interface DispositionFieldRefs {
    readonly id: FieldRef<"Disposition", 'String'>
    readonly module: FieldRef<"Disposition", 'String'>
    readonly disposition_class: FieldRef<"Disposition", 'String'>
    readonly disposition_type: FieldRef<"Disposition", 'String'>
    readonly disposition_style: FieldRef<"Disposition", 'String'>
    readonly disposition_theme: FieldRef<"Disposition", 'String'>
    readonly user_id: FieldRef<"Disposition", 'String'>
    readonly create_time: FieldRef<"Disposition", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Disposition findUnique
   */
  export type DispositionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Disposition
     */
    select?: DispositionSelect<ExtArgs> | null
    /**
     * Filter, which Disposition to fetch.
     */
    where: DispositionWhereUniqueInput
  }

  /**
   * Disposition findUniqueOrThrow
   */
  export type DispositionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Disposition
     */
    select?: DispositionSelect<ExtArgs> | null
    /**
     * Filter, which Disposition to fetch.
     */
    where: DispositionWhereUniqueInput
  }

  /**
   * Disposition findFirst
   */
  export type DispositionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Disposition
     */
    select?: DispositionSelect<ExtArgs> | null
    /**
     * Filter, which Disposition to fetch.
     */
    where?: DispositionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Dispositions to fetch.
     */
    orderBy?: DispositionOrderByWithRelationInput | DispositionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Dispositions.
     */
    cursor?: DispositionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Dispositions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Dispositions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Dispositions.
     */
    distinct?: DispositionScalarFieldEnum | DispositionScalarFieldEnum[]
  }

  /**
   * Disposition findFirstOrThrow
   */
  export type DispositionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Disposition
     */
    select?: DispositionSelect<ExtArgs> | null
    /**
     * Filter, which Disposition to fetch.
     */
    where?: DispositionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Dispositions to fetch.
     */
    orderBy?: DispositionOrderByWithRelationInput | DispositionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Dispositions.
     */
    cursor?: DispositionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Dispositions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Dispositions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Dispositions.
     */
    distinct?: DispositionScalarFieldEnum | DispositionScalarFieldEnum[]
  }

  /**
   * Disposition findMany
   */
  export type DispositionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Disposition
     */
    select?: DispositionSelect<ExtArgs> | null
    /**
     * Filter, which Dispositions to fetch.
     */
    where?: DispositionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Dispositions to fetch.
     */
    orderBy?: DispositionOrderByWithRelationInput | DispositionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Dispositions.
     */
    cursor?: DispositionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Dispositions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Dispositions.
     */
    skip?: number
    distinct?: DispositionScalarFieldEnum | DispositionScalarFieldEnum[]
  }

  /**
   * Disposition create
   */
  export type DispositionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Disposition
     */
    select?: DispositionSelect<ExtArgs> | null
    /**
     * The data needed to create a Disposition.
     */
    data: XOR<DispositionCreateInput, DispositionUncheckedCreateInput>
  }

  /**
   * Disposition createMany
   */
  export type DispositionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Dispositions.
     */
    data: DispositionCreateManyInput | DispositionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Disposition update
   */
  export type DispositionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Disposition
     */
    select?: DispositionSelect<ExtArgs> | null
    /**
     * The data needed to update a Disposition.
     */
    data: XOR<DispositionUpdateInput, DispositionUncheckedUpdateInput>
    /**
     * Choose, which Disposition to update.
     */
    where: DispositionWhereUniqueInput
  }

  /**
   * Disposition updateMany
   */
  export type DispositionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Dispositions.
     */
    data: XOR<DispositionUpdateManyMutationInput, DispositionUncheckedUpdateManyInput>
    /**
     * Filter which Dispositions to update
     */
    where?: DispositionWhereInput
  }

  /**
   * Disposition upsert
   */
  export type DispositionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Disposition
     */
    select?: DispositionSelect<ExtArgs> | null
    /**
     * The filter to search for the Disposition to update in case it exists.
     */
    where: DispositionWhereUniqueInput
    /**
     * In case the Disposition found by the `where` argument doesn't exist, create a new Disposition with this data.
     */
    create: XOR<DispositionCreateInput, DispositionUncheckedCreateInput>
    /**
     * In case the Disposition was found with the provided `where` argument, update it with this data.
     */
    update: XOR<DispositionUpdateInput, DispositionUncheckedUpdateInput>
  }

  /**
   * Disposition delete
   */
  export type DispositionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Disposition
     */
    select?: DispositionSelect<ExtArgs> | null
    /**
     * Filter which Disposition to delete.
     */
    where: DispositionWhereUniqueInput
  }

  /**
   * Disposition deleteMany
   */
  export type DispositionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Dispositions to delete
     */
    where?: DispositionWhereInput
  }

  /**
   * Disposition without action
   */
  export type DispositionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Disposition
     */
    select?: DispositionSelect<ExtArgs> | null
  }


  /**
   * Model Group
   */

  export type AggregateGroup = {
    _count: GroupCountAggregateOutputType | null
    _min: GroupMinAggregateOutputType | null
    _max: GroupMaxAggregateOutputType | null
  }

  export type GroupMinAggregateOutputType = {
    id: string | null
    name: string | null
    userid: string | null
    createtime: Date | null
  }

  export type GroupMaxAggregateOutputType = {
    id: string | null
    name: string | null
    userid: string | null
    createtime: Date | null
  }

  export type GroupCountAggregateOutputType = {
    id: number
    name: number
    userid: number
    createtime: number
    _all: number
  }


  export type GroupMinAggregateInputType = {
    id?: true
    name?: true
    userid?: true
    createtime?: true
  }

  export type GroupMaxAggregateInputType = {
    id?: true
    name?: true
    userid?: true
    createtime?: true
  }

  export type GroupCountAggregateInputType = {
    id?: true
    name?: true
    userid?: true
    createtime?: true
    _all?: true
  }

  export type GroupAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Group to aggregate.
     */
    where?: GroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Groups to fetch.
     */
    orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: GroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Groups from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Groups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Groups
    **/
    _count?: true | GroupCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: GroupMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: GroupMaxAggregateInputType
  }

  export type GetGroupAggregateType<T extends GroupAggregateArgs> = {
        [P in keyof T & keyof AggregateGroup]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateGroup[P]>
      : GetScalarType<T[P], AggregateGroup[P]>
  }




  export type GroupGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GroupWhereInput
    orderBy?: GroupOrderByWithAggregationInput | GroupOrderByWithAggregationInput[]
    by: GroupScalarFieldEnum[] | GroupScalarFieldEnum
    having?: GroupScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: GroupCountAggregateInputType | true
    _min?: GroupMinAggregateInputType
    _max?: GroupMaxAggregateInputType
  }

  export type GroupGroupByOutputType = {
    id: string
    name: string | null
    userid: string | null
    createtime: Date | null
    _count: GroupCountAggregateOutputType | null
    _min: GroupMinAggregateOutputType | null
    _max: GroupMaxAggregateOutputType | null
  }

  type GetGroupGroupByPayload<T extends GroupGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<GroupGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof GroupGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], GroupGroupByOutputType[P]>
            : GetScalarType<T[P], GroupGroupByOutputType[P]>
        }
      >
    >


  export type GroupSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    userid?: boolean
    createtime?: boolean
  }, ExtArgs["result"]["group"]>


  export type GroupSelectScalar = {
    id?: boolean
    name?: boolean
    userid?: boolean
    createtime?: boolean
  }


  export type $GroupPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Group"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string | null
      userid: string | null
      createtime: Date | null
    }, ExtArgs["result"]["group"]>
    composites: {}
  }

  type GroupGetPayload<S extends boolean | null | undefined | GroupDefaultArgs> = $Result.GetResult<Prisma.$GroupPayload, S>

  type GroupCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<GroupFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: GroupCountAggregateInputType | true
    }

  export interface GroupDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Group'], meta: { name: 'Group' } }
    /**
     * Find zero or one Group that matches the filter.
     * @param {GroupFindUniqueArgs} args - Arguments to find a Group
     * @example
     * // Get one Group
     * const group = await prisma.group.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends GroupFindUniqueArgs>(args: SelectSubset<T, GroupFindUniqueArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Group that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {GroupFindUniqueOrThrowArgs} args - Arguments to find a Group
     * @example
     * // Get one Group
     * const group = await prisma.group.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends GroupFindUniqueOrThrowArgs>(args: SelectSubset<T, GroupFindUniqueOrThrowArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Group that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupFindFirstArgs} args - Arguments to find a Group
     * @example
     * // Get one Group
     * const group = await prisma.group.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends GroupFindFirstArgs>(args?: SelectSubset<T, GroupFindFirstArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Group that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupFindFirstOrThrowArgs} args - Arguments to find a Group
     * @example
     * // Get one Group
     * const group = await prisma.group.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends GroupFindFirstOrThrowArgs>(args?: SelectSubset<T, GroupFindFirstOrThrowArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Groups that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Groups
     * const groups = await prisma.group.findMany()
     * 
     * // Get first 10 Groups
     * const groups = await prisma.group.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const groupWithIdOnly = await prisma.group.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends GroupFindManyArgs>(args?: SelectSubset<T, GroupFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Group.
     * @param {GroupCreateArgs} args - Arguments to create a Group.
     * @example
     * // Create one Group
     * const Group = await prisma.group.create({
     *   data: {
     *     // ... data to create a Group
     *   }
     * })
     * 
     */
    create<T extends GroupCreateArgs>(args: SelectSubset<T, GroupCreateArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Groups.
     * @param {GroupCreateManyArgs} args - Arguments to create many Groups.
     * @example
     * // Create many Groups
     * const group = await prisma.group.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends GroupCreateManyArgs>(args?: SelectSubset<T, GroupCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Group.
     * @param {GroupDeleteArgs} args - Arguments to delete one Group.
     * @example
     * // Delete one Group
     * const Group = await prisma.group.delete({
     *   where: {
     *     // ... filter to delete one Group
     *   }
     * })
     * 
     */
    delete<T extends GroupDeleteArgs>(args: SelectSubset<T, GroupDeleteArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Group.
     * @param {GroupUpdateArgs} args - Arguments to update one Group.
     * @example
     * // Update one Group
     * const group = await prisma.group.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends GroupUpdateArgs>(args: SelectSubset<T, GroupUpdateArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Groups.
     * @param {GroupDeleteManyArgs} args - Arguments to filter Groups to delete.
     * @example
     * // Delete a few Groups
     * const { count } = await prisma.group.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends GroupDeleteManyArgs>(args?: SelectSubset<T, GroupDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Groups.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Groups
     * const group = await prisma.group.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends GroupUpdateManyArgs>(args: SelectSubset<T, GroupUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Group.
     * @param {GroupUpsertArgs} args - Arguments to update or create a Group.
     * @example
     * // Update or create a Group
     * const group = await prisma.group.upsert({
     *   create: {
     *     // ... data to create a Group
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Group we want to update
     *   }
     * })
     */
    upsert<T extends GroupUpsertArgs>(args: SelectSubset<T, GroupUpsertArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Groups.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupCountArgs} args - Arguments to filter Groups to count.
     * @example
     * // Count the number of Groups
     * const count = await prisma.group.count({
     *   where: {
     *     // ... the filter for the Groups we want to count
     *   }
     * })
    **/
    count<T extends GroupCountArgs>(
      args?: Subset<T, GroupCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], GroupCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Group.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends GroupAggregateArgs>(args: Subset<T, GroupAggregateArgs>): Prisma.PrismaPromise<GetGroupAggregateType<T>>

    /**
     * Group by Group.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends GroupGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupGroupByArgs['orderBy'] }
        : { orderBy?: GroupGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, GroupGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetGroupGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Group model
   */
  readonly fields: GroupFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Group.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__GroupClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the Group model
   */ 
  interface GroupFieldRefs {
    readonly id: FieldRef<"Group", 'String'>
    readonly name: FieldRef<"Group", 'String'>
    readonly userid: FieldRef<"Group", 'String'>
    readonly createtime: FieldRef<"Group", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Group findUnique
   */
  export type GroupFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Filter, which Group to fetch.
     */
    where: GroupWhereUniqueInput
  }

  /**
   * Group findUniqueOrThrow
   */
  export type GroupFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Filter, which Group to fetch.
     */
    where: GroupWhereUniqueInput
  }

  /**
   * Group findFirst
   */
  export type GroupFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Filter, which Group to fetch.
     */
    where?: GroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Groups to fetch.
     */
    orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Groups.
     */
    cursor?: GroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Groups from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Groups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Groups.
     */
    distinct?: GroupScalarFieldEnum | GroupScalarFieldEnum[]
  }

  /**
   * Group findFirstOrThrow
   */
  export type GroupFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Filter, which Group to fetch.
     */
    where?: GroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Groups to fetch.
     */
    orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Groups.
     */
    cursor?: GroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Groups from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Groups.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Groups.
     */
    distinct?: GroupScalarFieldEnum | GroupScalarFieldEnum[]
  }

  /**
   * Group findMany
   */
  export type GroupFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Filter, which Groups to fetch.
     */
    where?: GroupWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Groups to fetch.
     */
    orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Groups.
     */
    cursor?: GroupWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Groups from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Groups.
     */
    skip?: number
    distinct?: GroupScalarFieldEnum | GroupScalarFieldEnum[]
  }

  /**
   * Group create
   */
  export type GroupCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * The data needed to create a Group.
     */
    data: XOR<GroupCreateInput, GroupUncheckedCreateInput>
  }

  /**
   * Group createMany
   */
  export type GroupCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Groups.
     */
    data: GroupCreateManyInput | GroupCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Group update
   */
  export type GroupUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * The data needed to update a Group.
     */
    data: XOR<GroupUpdateInput, GroupUncheckedUpdateInput>
    /**
     * Choose, which Group to update.
     */
    where: GroupWhereUniqueInput
  }

  /**
   * Group updateMany
   */
  export type GroupUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Groups.
     */
    data: XOR<GroupUpdateManyMutationInput, GroupUncheckedUpdateManyInput>
    /**
     * Filter which Groups to update
     */
    where?: GroupWhereInput
  }

  /**
   * Group upsert
   */
  export type GroupUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * The filter to search for the Group to update in case it exists.
     */
    where: GroupWhereUniqueInput
    /**
     * In case the Group found by the `where` argument doesn't exist, create a new Group with this data.
     */
    create: XOR<GroupCreateInput, GroupUncheckedCreateInput>
    /**
     * In case the Group was found with the provided `where` argument, update it with this data.
     */
    update: XOR<GroupUpdateInput, GroupUncheckedUpdateInput>
  }

  /**
   * Group delete
   */
  export type GroupDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
    /**
     * Filter which Group to delete.
     */
    where: GroupWhereUniqueInput
  }

  /**
   * Group deleteMany
   */
  export type GroupDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Groups to delete
     */
    where?: GroupWhereInput
  }

  /**
   * Group without action
   */
  export type GroupDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Group
     */
    select?: GroupSelect<ExtArgs> | null
  }


  /**
   * Model GroupFile
   */

  export type AggregateGroupFile = {
    _count: GroupFileCountAggregateOutputType | null
    _min: GroupFileMinAggregateOutputType | null
    _max: GroupFileMaxAggregateOutputType | null
  }

  export type GroupFileMinAggregateOutputType = {
    id: string | null
    userid: string | null
    fileurl: string | null
    filename: string | null
    groupid: string | null
    abstract: string | null
    assistantFileId: string | null
    modelType: string | null
    createtime: Date | null
  }

  export type GroupFileMaxAggregateOutputType = {
    id: string | null
    userid: string | null
    fileurl: string | null
    filename: string | null
    groupid: string | null
    abstract: string | null
    assistantFileId: string | null
    modelType: string | null
    createtime: Date | null
  }

  export type GroupFileCountAggregateOutputType = {
    id: number
    userid: number
    fileurl: number
    filename: number
    groupid: number
    abstract: number
    assistantFileId: number
    modelType: number
    createtime: number
    _all: number
  }


  export type GroupFileMinAggregateInputType = {
    id?: true
    userid?: true
    fileurl?: true
    filename?: true
    groupid?: true
    abstract?: true
    assistantFileId?: true
    modelType?: true
    createtime?: true
  }

  export type GroupFileMaxAggregateInputType = {
    id?: true
    userid?: true
    fileurl?: true
    filename?: true
    groupid?: true
    abstract?: true
    assistantFileId?: true
    modelType?: true
    createtime?: true
  }

  export type GroupFileCountAggregateInputType = {
    id?: true
    userid?: true
    fileurl?: true
    filename?: true
    groupid?: true
    abstract?: true
    assistantFileId?: true
    modelType?: true
    createtime?: true
    _all?: true
  }

  export type GroupFileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which GroupFile to aggregate.
     */
    where?: GroupFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GroupFiles to fetch.
     */
    orderBy?: GroupFileOrderByWithRelationInput | GroupFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: GroupFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GroupFiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GroupFiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned GroupFiles
    **/
    _count?: true | GroupFileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: GroupFileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: GroupFileMaxAggregateInputType
  }

  export type GetGroupFileAggregateType<T extends GroupFileAggregateArgs> = {
        [P in keyof T & keyof AggregateGroupFile]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateGroupFile[P]>
      : GetScalarType<T[P], AggregateGroupFile[P]>
  }




  export type GroupFileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GroupFileWhereInput
    orderBy?: GroupFileOrderByWithAggregationInput | GroupFileOrderByWithAggregationInput[]
    by: GroupFileScalarFieldEnum[] | GroupFileScalarFieldEnum
    having?: GroupFileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: GroupFileCountAggregateInputType | true
    _min?: GroupFileMinAggregateInputType
    _max?: GroupFileMaxAggregateInputType
  }

  export type GroupFileGroupByOutputType = {
    id: string
    userid: string | null
    fileurl: string | null
    filename: string | null
    groupid: string | null
    abstract: string | null
    assistantFileId: string | null
    modelType: string | null
    createtime: Date | null
    _count: GroupFileCountAggregateOutputType | null
    _min: GroupFileMinAggregateOutputType | null
    _max: GroupFileMaxAggregateOutputType | null
  }

  type GetGroupFileGroupByPayload<T extends GroupFileGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<GroupFileGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof GroupFileGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], GroupFileGroupByOutputType[P]>
            : GetScalarType<T[P], GroupFileGroupByOutputType[P]>
        }
      >
    >


  export type GroupFileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userid?: boolean
    fileurl?: boolean
    filename?: boolean
    groupid?: boolean
    abstract?: boolean
    assistantFileId?: boolean
    modelType?: boolean
    createtime?: boolean
  }, ExtArgs["result"]["groupFile"]>


  export type GroupFileSelectScalar = {
    id?: boolean
    userid?: boolean
    fileurl?: boolean
    filename?: boolean
    groupid?: boolean
    abstract?: boolean
    assistantFileId?: boolean
    modelType?: boolean
    createtime?: boolean
  }


  export type $GroupFilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "GroupFile"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userid: string | null
      fileurl: string | null
      filename: string | null
      groupid: string | null
      abstract: string | null
      assistantFileId: string | null
      modelType: string | null
      createtime: Date | null
    }, ExtArgs["result"]["groupFile"]>
    composites: {}
  }

  type GroupFileGetPayload<S extends boolean | null | undefined | GroupFileDefaultArgs> = $Result.GetResult<Prisma.$GroupFilePayload, S>

  type GroupFileCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<GroupFileFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: GroupFileCountAggregateInputType | true
    }

  export interface GroupFileDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['GroupFile'], meta: { name: 'GroupFile' } }
    /**
     * Find zero or one GroupFile that matches the filter.
     * @param {GroupFileFindUniqueArgs} args - Arguments to find a GroupFile
     * @example
     * // Get one GroupFile
     * const groupFile = await prisma.groupFile.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends GroupFileFindUniqueArgs>(args: SelectSubset<T, GroupFileFindUniqueArgs<ExtArgs>>): Prisma__GroupFileClient<$Result.GetResult<Prisma.$GroupFilePayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one GroupFile that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {GroupFileFindUniqueOrThrowArgs} args - Arguments to find a GroupFile
     * @example
     * // Get one GroupFile
     * const groupFile = await prisma.groupFile.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends GroupFileFindUniqueOrThrowArgs>(args: SelectSubset<T, GroupFileFindUniqueOrThrowArgs<ExtArgs>>): Prisma__GroupFileClient<$Result.GetResult<Prisma.$GroupFilePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first GroupFile that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupFileFindFirstArgs} args - Arguments to find a GroupFile
     * @example
     * // Get one GroupFile
     * const groupFile = await prisma.groupFile.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends GroupFileFindFirstArgs>(args?: SelectSubset<T, GroupFileFindFirstArgs<ExtArgs>>): Prisma__GroupFileClient<$Result.GetResult<Prisma.$GroupFilePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first GroupFile that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupFileFindFirstOrThrowArgs} args - Arguments to find a GroupFile
     * @example
     * // Get one GroupFile
     * const groupFile = await prisma.groupFile.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends GroupFileFindFirstOrThrowArgs>(args?: SelectSubset<T, GroupFileFindFirstOrThrowArgs<ExtArgs>>): Prisma__GroupFileClient<$Result.GetResult<Prisma.$GroupFilePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more GroupFiles that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupFileFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all GroupFiles
     * const groupFiles = await prisma.groupFile.findMany()
     * 
     * // Get first 10 GroupFiles
     * const groupFiles = await prisma.groupFile.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const groupFileWithIdOnly = await prisma.groupFile.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends GroupFileFindManyArgs>(args?: SelectSubset<T, GroupFileFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupFilePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a GroupFile.
     * @param {GroupFileCreateArgs} args - Arguments to create a GroupFile.
     * @example
     * // Create one GroupFile
     * const GroupFile = await prisma.groupFile.create({
     *   data: {
     *     // ... data to create a GroupFile
     *   }
     * })
     * 
     */
    create<T extends GroupFileCreateArgs>(args: SelectSubset<T, GroupFileCreateArgs<ExtArgs>>): Prisma__GroupFileClient<$Result.GetResult<Prisma.$GroupFilePayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many GroupFiles.
     * @param {GroupFileCreateManyArgs} args - Arguments to create many GroupFiles.
     * @example
     * // Create many GroupFiles
     * const groupFile = await prisma.groupFile.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends GroupFileCreateManyArgs>(args?: SelectSubset<T, GroupFileCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a GroupFile.
     * @param {GroupFileDeleteArgs} args - Arguments to delete one GroupFile.
     * @example
     * // Delete one GroupFile
     * const GroupFile = await prisma.groupFile.delete({
     *   where: {
     *     // ... filter to delete one GroupFile
     *   }
     * })
     * 
     */
    delete<T extends GroupFileDeleteArgs>(args: SelectSubset<T, GroupFileDeleteArgs<ExtArgs>>): Prisma__GroupFileClient<$Result.GetResult<Prisma.$GroupFilePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one GroupFile.
     * @param {GroupFileUpdateArgs} args - Arguments to update one GroupFile.
     * @example
     * // Update one GroupFile
     * const groupFile = await prisma.groupFile.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends GroupFileUpdateArgs>(args: SelectSubset<T, GroupFileUpdateArgs<ExtArgs>>): Prisma__GroupFileClient<$Result.GetResult<Prisma.$GroupFilePayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more GroupFiles.
     * @param {GroupFileDeleteManyArgs} args - Arguments to filter GroupFiles to delete.
     * @example
     * // Delete a few GroupFiles
     * const { count } = await prisma.groupFile.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends GroupFileDeleteManyArgs>(args?: SelectSubset<T, GroupFileDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more GroupFiles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupFileUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many GroupFiles
     * const groupFile = await prisma.groupFile.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends GroupFileUpdateManyArgs>(args: SelectSubset<T, GroupFileUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one GroupFile.
     * @param {GroupFileUpsertArgs} args - Arguments to update or create a GroupFile.
     * @example
     * // Update or create a GroupFile
     * const groupFile = await prisma.groupFile.upsert({
     *   create: {
     *     // ... data to create a GroupFile
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the GroupFile we want to update
     *   }
     * })
     */
    upsert<T extends GroupFileUpsertArgs>(args: SelectSubset<T, GroupFileUpsertArgs<ExtArgs>>): Prisma__GroupFileClient<$Result.GetResult<Prisma.$GroupFilePayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of GroupFiles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupFileCountArgs} args - Arguments to filter GroupFiles to count.
     * @example
     * // Count the number of GroupFiles
     * const count = await prisma.groupFile.count({
     *   where: {
     *     // ... the filter for the GroupFiles we want to count
     *   }
     * })
    **/
    count<T extends GroupFileCountArgs>(
      args?: Subset<T, GroupFileCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], GroupFileCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a GroupFile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupFileAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends GroupFileAggregateArgs>(args: Subset<T, GroupFileAggregateArgs>): Prisma.PrismaPromise<GetGroupFileAggregateType<T>>

    /**
     * Group by GroupFile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GroupFileGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends GroupFileGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GroupFileGroupByArgs['orderBy'] }
        : { orderBy?: GroupFileGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, GroupFileGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetGroupFileGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the GroupFile model
   */
  readonly fields: GroupFileFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for GroupFile.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__GroupFileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the GroupFile model
   */ 
  interface GroupFileFieldRefs {
    readonly id: FieldRef<"GroupFile", 'String'>
    readonly userid: FieldRef<"GroupFile", 'String'>
    readonly fileurl: FieldRef<"GroupFile", 'String'>
    readonly filename: FieldRef<"GroupFile", 'String'>
    readonly groupid: FieldRef<"GroupFile", 'String'>
    readonly abstract: FieldRef<"GroupFile", 'String'>
    readonly assistantFileId: FieldRef<"GroupFile", 'String'>
    readonly modelType: FieldRef<"GroupFile", 'String'>
    readonly createtime: FieldRef<"GroupFile", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * GroupFile findUnique
   */
  export type GroupFileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupFile
     */
    select?: GroupFileSelect<ExtArgs> | null
    /**
     * Filter, which GroupFile to fetch.
     */
    where: GroupFileWhereUniqueInput
  }

  /**
   * GroupFile findUniqueOrThrow
   */
  export type GroupFileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupFile
     */
    select?: GroupFileSelect<ExtArgs> | null
    /**
     * Filter, which GroupFile to fetch.
     */
    where: GroupFileWhereUniqueInput
  }

  /**
   * GroupFile findFirst
   */
  export type GroupFileFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupFile
     */
    select?: GroupFileSelect<ExtArgs> | null
    /**
     * Filter, which GroupFile to fetch.
     */
    where?: GroupFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GroupFiles to fetch.
     */
    orderBy?: GroupFileOrderByWithRelationInput | GroupFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for GroupFiles.
     */
    cursor?: GroupFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GroupFiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GroupFiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of GroupFiles.
     */
    distinct?: GroupFileScalarFieldEnum | GroupFileScalarFieldEnum[]
  }

  /**
   * GroupFile findFirstOrThrow
   */
  export type GroupFileFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupFile
     */
    select?: GroupFileSelect<ExtArgs> | null
    /**
     * Filter, which GroupFile to fetch.
     */
    where?: GroupFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GroupFiles to fetch.
     */
    orderBy?: GroupFileOrderByWithRelationInput | GroupFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for GroupFiles.
     */
    cursor?: GroupFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GroupFiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GroupFiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of GroupFiles.
     */
    distinct?: GroupFileScalarFieldEnum | GroupFileScalarFieldEnum[]
  }

  /**
   * GroupFile findMany
   */
  export type GroupFileFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupFile
     */
    select?: GroupFileSelect<ExtArgs> | null
    /**
     * Filter, which GroupFiles to fetch.
     */
    where?: GroupFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GroupFiles to fetch.
     */
    orderBy?: GroupFileOrderByWithRelationInput | GroupFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing GroupFiles.
     */
    cursor?: GroupFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GroupFiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GroupFiles.
     */
    skip?: number
    distinct?: GroupFileScalarFieldEnum | GroupFileScalarFieldEnum[]
  }

  /**
   * GroupFile create
   */
  export type GroupFileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupFile
     */
    select?: GroupFileSelect<ExtArgs> | null
    /**
     * The data needed to create a GroupFile.
     */
    data: XOR<GroupFileCreateInput, GroupFileUncheckedCreateInput>
  }

  /**
   * GroupFile createMany
   */
  export type GroupFileCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many GroupFiles.
     */
    data: GroupFileCreateManyInput | GroupFileCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * GroupFile update
   */
  export type GroupFileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupFile
     */
    select?: GroupFileSelect<ExtArgs> | null
    /**
     * The data needed to update a GroupFile.
     */
    data: XOR<GroupFileUpdateInput, GroupFileUncheckedUpdateInput>
    /**
     * Choose, which GroupFile to update.
     */
    where: GroupFileWhereUniqueInput
  }

  /**
   * GroupFile updateMany
   */
  export type GroupFileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update GroupFiles.
     */
    data: XOR<GroupFileUpdateManyMutationInput, GroupFileUncheckedUpdateManyInput>
    /**
     * Filter which GroupFiles to update
     */
    where?: GroupFileWhereInput
  }

  /**
   * GroupFile upsert
   */
  export type GroupFileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupFile
     */
    select?: GroupFileSelect<ExtArgs> | null
    /**
     * The filter to search for the GroupFile to update in case it exists.
     */
    where: GroupFileWhereUniqueInput
    /**
     * In case the GroupFile found by the `where` argument doesn't exist, create a new GroupFile with this data.
     */
    create: XOR<GroupFileCreateInput, GroupFileUncheckedCreateInput>
    /**
     * In case the GroupFile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<GroupFileUpdateInput, GroupFileUncheckedUpdateInput>
  }

  /**
   * GroupFile delete
   */
  export type GroupFileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupFile
     */
    select?: GroupFileSelect<ExtArgs> | null
    /**
     * Filter which GroupFile to delete.
     */
    where: GroupFileWhereUniqueInput
  }

  /**
   * GroupFile deleteMany
   */
  export type GroupFileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which GroupFiles to delete
     */
    where?: GroupFileWhereInput
  }

  /**
   * GroupFile without action
   */
  export type GroupFileDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GroupFile
     */
    select?: GroupFileSelect<ExtArgs> | null
  }


  /**
   * Model InvitationCode
   */

  export type AggregateInvitationCode = {
    _count: InvitationCodeCountAggregateOutputType | null
    _avg: InvitationCodeAvgAggregateOutputType | null
    _sum: InvitationCodeSumAggregateOutputType | null
    _min: InvitationCodeMinAggregateOutputType | null
    _max: InvitationCodeMaxAggregateOutputType | null
  }

  export type InvitationCodeAvgAggregateOutputType = {
    type: number | null
  }

  export type InvitationCodeSumAggregateOutputType = {
    type: number | null
  }

  export type InvitationCodeMinAggregateOutputType = {
    id: string | null
    cid: string | null
    themeId: string | null
    type: number | null
    invitationCode: string | null
    createtime: Date | null
  }

  export type InvitationCodeMaxAggregateOutputType = {
    id: string | null
    cid: string | null
    themeId: string | null
    type: number | null
    invitationCode: string | null
    createtime: Date | null
  }

  export type InvitationCodeCountAggregateOutputType = {
    id: number
    cid: number
    themeId: number
    type: number
    invitationCode: number
    createtime: number
    _all: number
  }


  export type InvitationCodeAvgAggregateInputType = {
    type?: true
  }

  export type InvitationCodeSumAggregateInputType = {
    type?: true
  }

  export type InvitationCodeMinAggregateInputType = {
    id?: true
    cid?: true
    themeId?: true
    type?: true
    invitationCode?: true
    createtime?: true
  }

  export type InvitationCodeMaxAggregateInputType = {
    id?: true
    cid?: true
    themeId?: true
    type?: true
    invitationCode?: true
    createtime?: true
  }

  export type InvitationCodeCountAggregateInputType = {
    id?: true
    cid?: true
    themeId?: true
    type?: true
    invitationCode?: true
    createtime?: true
    _all?: true
  }

  export type InvitationCodeAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which InvitationCode to aggregate.
     */
    where?: InvitationCodeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of InvitationCodes to fetch.
     */
    orderBy?: InvitationCodeOrderByWithRelationInput | InvitationCodeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: InvitationCodeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` InvitationCodes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` InvitationCodes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned InvitationCodes
    **/
    _count?: true | InvitationCodeCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: InvitationCodeAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: InvitationCodeSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: InvitationCodeMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: InvitationCodeMaxAggregateInputType
  }

  export type GetInvitationCodeAggregateType<T extends InvitationCodeAggregateArgs> = {
        [P in keyof T & keyof AggregateInvitationCode]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateInvitationCode[P]>
      : GetScalarType<T[P], AggregateInvitationCode[P]>
  }




  export type InvitationCodeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: InvitationCodeWhereInput
    orderBy?: InvitationCodeOrderByWithAggregationInput | InvitationCodeOrderByWithAggregationInput[]
    by: InvitationCodeScalarFieldEnum[] | InvitationCodeScalarFieldEnum
    having?: InvitationCodeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: InvitationCodeCountAggregateInputType | true
    _avg?: InvitationCodeAvgAggregateInputType
    _sum?: InvitationCodeSumAggregateInputType
    _min?: InvitationCodeMinAggregateInputType
    _max?: InvitationCodeMaxAggregateInputType
  }

  export type InvitationCodeGroupByOutputType = {
    id: string
    cid: string | null
    themeId: string | null
    type: number | null
    invitationCode: string | null
    createtime: Date | null
    _count: InvitationCodeCountAggregateOutputType | null
    _avg: InvitationCodeAvgAggregateOutputType | null
    _sum: InvitationCodeSumAggregateOutputType | null
    _min: InvitationCodeMinAggregateOutputType | null
    _max: InvitationCodeMaxAggregateOutputType | null
  }

  type GetInvitationCodeGroupByPayload<T extends InvitationCodeGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<InvitationCodeGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof InvitationCodeGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], InvitationCodeGroupByOutputType[P]>
            : GetScalarType<T[P], InvitationCodeGroupByOutputType[P]>
        }
      >
    >


  export type InvitationCodeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    cid?: boolean
    themeId?: boolean
    type?: boolean
    invitationCode?: boolean
    createtime?: boolean
  }, ExtArgs["result"]["invitationCode"]>


  export type InvitationCodeSelectScalar = {
    id?: boolean
    cid?: boolean
    themeId?: boolean
    type?: boolean
    invitationCode?: boolean
    createtime?: boolean
  }


  export type $InvitationCodePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "InvitationCode"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      cid: string | null
      themeId: string | null
      type: number | null
      invitationCode: string | null
      createtime: Date | null
    }, ExtArgs["result"]["invitationCode"]>
    composites: {}
  }

  type InvitationCodeGetPayload<S extends boolean | null | undefined | InvitationCodeDefaultArgs> = $Result.GetResult<Prisma.$InvitationCodePayload, S>

  type InvitationCodeCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<InvitationCodeFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: InvitationCodeCountAggregateInputType | true
    }

  export interface InvitationCodeDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['InvitationCode'], meta: { name: 'InvitationCode' } }
    /**
     * Find zero or one InvitationCode that matches the filter.
     * @param {InvitationCodeFindUniqueArgs} args - Arguments to find a InvitationCode
     * @example
     * // Get one InvitationCode
     * const invitationCode = await prisma.invitationCode.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends InvitationCodeFindUniqueArgs>(args: SelectSubset<T, InvitationCodeFindUniqueArgs<ExtArgs>>): Prisma__InvitationCodeClient<$Result.GetResult<Prisma.$InvitationCodePayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one InvitationCode that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {InvitationCodeFindUniqueOrThrowArgs} args - Arguments to find a InvitationCode
     * @example
     * // Get one InvitationCode
     * const invitationCode = await prisma.invitationCode.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends InvitationCodeFindUniqueOrThrowArgs>(args: SelectSubset<T, InvitationCodeFindUniqueOrThrowArgs<ExtArgs>>): Prisma__InvitationCodeClient<$Result.GetResult<Prisma.$InvitationCodePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first InvitationCode that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {InvitationCodeFindFirstArgs} args - Arguments to find a InvitationCode
     * @example
     * // Get one InvitationCode
     * const invitationCode = await prisma.invitationCode.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends InvitationCodeFindFirstArgs>(args?: SelectSubset<T, InvitationCodeFindFirstArgs<ExtArgs>>): Prisma__InvitationCodeClient<$Result.GetResult<Prisma.$InvitationCodePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first InvitationCode that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {InvitationCodeFindFirstOrThrowArgs} args - Arguments to find a InvitationCode
     * @example
     * // Get one InvitationCode
     * const invitationCode = await prisma.invitationCode.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends InvitationCodeFindFirstOrThrowArgs>(args?: SelectSubset<T, InvitationCodeFindFirstOrThrowArgs<ExtArgs>>): Prisma__InvitationCodeClient<$Result.GetResult<Prisma.$InvitationCodePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more InvitationCodes that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {InvitationCodeFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all InvitationCodes
     * const invitationCodes = await prisma.invitationCode.findMany()
     * 
     * // Get first 10 InvitationCodes
     * const invitationCodes = await prisma.invitationCode.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const invitationCodeWithIdOnly = await prisma.invitationCode.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends InvitationCodeFindManyArgs>(args?: SelectSubset<T, InvitationCodeFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$InvitationCodePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a InvitationCode.
     * @param {InvitationCodeCreateArgs} args - Arguments to create a InvitationCode.
     * @example
     * // Create one InvitationCode
     * const InvitationCode = await prisma.invitationCode.create({
     *   data: {
     *     // ... data to create a InvitationCode
     *   }
     * })
     * 
     */
    create<T extends InvitationCodeCreateArgs>(args: SelectSubset<T, InvitationCodeCreateArgs<ExtArgs>>): Prisma__InvitationCodeClient<$Result.GetResult<Prisma.$InvitationCodePayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many InvitationCodes.
     * @param {InvitationCodeCreateManyArgs} args - Arguments to create many InvitationCodes.
     * @example
     * // Create many InvitationCodes
     * const invitationCode = await prisma.invitationCode.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends InvitationCodeCreateManyArgs>(args?: SelectSubset<T, InvitationCodeCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a InvitationCode.
     * @param {InvitationCodeDeleteArgs} args - Arguments to delete one InvitationCode.
     * @example
     * // Delete one InvitationCode
     * const InvitationCode = await prisma.invitationCode.delete({
     *   where: {
     *     // ... filter to delete one InvitationCode
     *   }
     * })
     * 
     */
    delete<T extends InvitationCodeDeleteArgs>(args: SelectSubset<T, InvitationCodeDeleteArgs<ExtArgs>>): Prisma__InvitationCodeClient<$Result.GetResult<Prisma.$InvitationCodePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one InvitationCode.
     * @param {InvitationCodeUpdateArgs} args - Arguments to update one InvitationCode.
     * @example
     * // Update one InvitationCode
     * const invitationCode = await prisma.invitationCode.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends InvitationCodeUpdateArgs>(args: SelectSubset<T, InvitationCodeUpdateArgs<ExtArgs>>): Prisma__InvitationCodeClient<$Result.GetResult<Prisma.$InvitationCodePayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more InvitationCodes.
     * @param {InvitationCodeDeleteManyArgs} args - Arguments to filter InvitationCodes to delete.
     * @example
     * // Delete a few InvitationCodes
     * const { count } = await prisma.invitationCode.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends InvitationCodeDeleteManyArgs>(args?: SelectSubset<T, InvitationCodeDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more InvitationCodes.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {InvitationCodeUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many InvitationCodes
     * const invitationCode = await prisma.invitationCode.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends InvitationCodeUpdateManyArgs>(args: SelectSubset<T, InvitationCodeUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one InvitationCode.
     * @param {InvitationCodeUpsertArgs} args - Arguments to update or create a InvitationCode.
     * @example
     * // Update or create a InvitationCode
     * const invitationCode = await prisma.invitationCode.upsert({
     *   create: {
     *     // ... data to create a InvitationCode
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the InvitationCode we want to update
     *   }
     * })
     */
    upsert<T extends InvitationCodeUpsertArgs>(args: SelectSubset<T, InvitationCodeUpsertArgs<ExtArgs>>): Prisma__InvitationCodeClient<$Result.GetResult<Prisma.$InvitationCodePayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of InvitationCodes.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {InvitationCodeCountArgs} args - Arguments to filter InvitationCodes to count.
     * @example
     * // Count the number of InvitationCodes
     * const count = await prisma.invitationCode.count({
     *   where: {
     *     // ... the filter for the InvitationCodes we want to count
     *   }
     * })
    **/
    count<T extends InvitationCodeCountArgs>(
      args?: Subset<T, InvitationCodeCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], InvitationCodeCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a InvitationCode.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {InvitationCodeAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends InvitationCodeAggregateArgs>(args: Subset<T, InvitationCodeAggregateArgs>): Prisma.PrismaPromise<GetInvitationCodeAggregateType<T>>

    /**
     * Group by InvitationCode.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {InvitationCodeGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends InvitationCodeGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: InvitationCodeGroupByArgs['orderBy'] }
        : { orderBy?: InvitationCodeGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, InvitationCodeGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetInvitationCodeGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the InvitationCode model
   */
  readonly fields: InvitationCodeFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for InvitationCode.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__InvitationCodeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the InvitationCode model
   */ 
  interface InvitationCodeFieldRefs {
    readonly id: FieldRef<"InvitationCode", 'String'>
    readonly cid: FieldRef<"InvitationCode", 'String'>
    readonly themeId: FieldRef<"InvitationCode", 'String'>
    readonly type: FieldRef<"InvitationCode", 'Int'>
    readonly invitationCode: FieldRef<"InvitationCode", 'String'>
    readonly createtime: FieldRef<"InvitationCode", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * InvitationCode findUnique
   */
  export type InvitationCodeFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InvitationCode
     */
    select?: InvitationCodeSelect<ExtArgs> | null
    /**
     * Filter, which InvitationCode to fetch.
     */
    where: InvitationCodeWhereUniqueInput
  }

  /**
   * InvitationCode findUniqueOrThrow
   */
  export type InvitationCodeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InvitationCode
     */
    select?: InvitationCodeSelect<ExtArgs> | null
    /**
     * Filter, which InvitationCode to fetch.
     */
    where: InvitationCodeWhereUniqueInput
  }

  /**
   * InvitationCode findFirst
   */
  export type InvitationCodeFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InvitationCode
     */
    select?: InvitationCodeSelect<ExtArgs> | null
    /**
     * Filter, which InvitationCode to fetch.
     */
    where?: InvitationCodeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of InvitationCodes to fetch.
     */
    orderBy?: InvitationCodeOrderByWithRelationInput | InvitationCodeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for InvitationCodes.
     */
    cursor?: InvitationCodeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` InvitationCodes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` InvitationCodes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of InvitationCodes.
     */
    distinct?: InvitationCodeScalarFieldEnum | InvitationCodeScalarFieldEnum[]
  }

  /**
   * InvitationCode findFirstOrThrow
   */
  export type InvitationCodeFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InvitationCode
     */
    select?: InvitationCodeSelect<ExtArgs> | null
    /**
     * Filter, which InvitationCode to fetch.
     */
    where?: InvitationCodeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of InvitationCodes to fetch.
     */
    orderBy?: InvitationCodeOrderByWithRelationInput | InvitationCodeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for InvitationCodes.
     */
    cursor?: InvitationCodeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` InvitationCodes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` InvitationCodes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of InvitationCodes.
     */
    distinct?: InvitationCodeScalarFieldEnum | InvitationCodeScalarFieldEnum[]
  }

  /**
   * InvitationCode findMany
   */
  export type InvitationCodeFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InvitationCode
     */
    select?: InvitationCodeSelect<ExtArgs> | null
    /**
     * Filter, which InvitationCodes to fetch.
     */
    where?: InvitationCodeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of InvitationCodes to fetch.
     */
    orderBy?: InvitationCodeOrderByWithRelationInput | InvitationCodeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing InvitationCodes.
     */
    cursor?: InvitationCodeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` InvitationCodes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` InvitationCodes.
     */
    skip?: number
    distinct?: InvitationCodeScalarFieldEnum | InvitationCodeScalarFieldEnum[]
  }

  /**
   * InvitationCode create
   */
  export type InvitationCodeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InvitationCode
     */
    select?: InvitationCodeSelect<ExtArgs> | null
    /**
     * The data needed to create a InvitationCode.
     */
    data: XOR<InvitationCodeCreateInput, InvitationCodeUncheckedCreateInput>
  }

  /**
   * InvitationCode createMany
   */
  export type InvitationCodeCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many InvitationCodes.
     */
    data: InvitationCodeCreateManyInput | InvitationCodeCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * InvitationCode update
   */
  export type InvitationCodeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InvitationCode
     */
    select?: InvitationCodeSelect<ExtArgs> | null
    /**
     * The data needed to update a InvitationCode.
     */
    data: XOR<InvitationCodeUpdateInput, InvitationCodeUncheckedUpdateInput>
    /**
     * Choose, which InvitationCode to update.
     */
    where: InvitationCodeWhereUniqueInput
  }

  /**
   * InvitationCode updateMany
   */
  export type InvitationCodeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update InvitationCodes.
     */
    data: XOR<InvitationCodeUpdateManyMutationInput, InvitationCodeUncheckedUpdateManyInput>
    /**
     * Filter which InvitationCodes to update
     */
    where?: InvitationCodeWhereInput
  }

  /**
   * InvitationCode upsert
   */
  export type InvitationCodeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InvitationCode
     */
    select?: InvitationCodeSelect<ExtArgs> | null
    /**
     * The filter to search for the InvitationCode to update in case it exists.
     */
    where: InvitationCodeWhereUniqueInput
    /**
     * In case the InvitationCode found by the `where` argument doesn't exist, create a new InvitationCode with this data.
     */
    create: XOR<InvitationCodeCreateInput, InvitationCodeUncheckedCreateInput>
    /**
     * In case the InvitationCode was found with the provided `where` argument, update it with this data.
     */
    update: XOR<InvitationCodeUpdateInput, InvitationCodeUncheckedUpdateInput>
  }

  /**
   * InvitationCode delete
   */
  export type InvitationCodeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InvitationCode
     */
    select?: InvitationCodeSelect<ExtArgs> | null
    /**
     * Filter which InvitationCode to delete.
     */
    where: InvitationCodeWhereUniqueInput
  }

  /**
   * InvitationCode deleteMany
   */
  export type InvitationCodeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which InvitationCodes to delete
     */
    where?: InvitationCodeWhereInput
  }

  /**
   * InvitationCode without action
   */
  export type InvitationCodeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the InvitationCode
     */
    select?: InvitationCodeSelect<ExtArgs> | null
  }


  /**
   * Model ai_agent_park_session
   */

  export type AggregateAi_agent_park_session = {
    _count: Ai_agent_park_sessionCountAggregateOutputType | null
    _avg: Ai_agent_park_sessionAvgAggregateOutputType | null
    _sum: Ai_agent_park_sessionSumAggregateOutputType | null
    _min: Ai_agent_park_sessionMinAggregateOutputType | null
    _max: Ai_agent_park_sessionMaxAggregateOutputType | null
  }

  export type Ai_agent_park_sessionAvgAggregateOutputType = {
    isCocoNote: number | null
  }

  export type Ai_agent_park_sessionSumAggregateOutputType = {
    isCocoNote: number | null
  }

  export type Ai_agent_park_sessionMinAggregateOutputType = {
    id: string | null
    session_name: string | null
    user_id: string | null
    isCocoNote: number | null
    createtime: Date | null
    work_area_text: string | null
    scene: string | null
  }

  export type Ai_agent_park_sessionMaxAggregateOutputType = {
    id: string | null
    session_name: string | null
    user_id: string | null
    isCocoNote: number | null
    createtime: Date | null
    work_area_text: string | null
    scene: string | null
  }

  export type Ai_agent_park_sessionCountAggregateOutputType = {
    id: number
    session_name: number
    user_id: number
    isCocoNote: number
    createtime: number
    work_area_text: number
    scene: number
    _all: number
  }


  export type Ai_agent_park_sessionAvgAggregateInputType = {
    isCocoNote?: true
  }

  export type Ai_agent_park_sessionSumAggregateInputType = {
    isCocoNote?: true
  }

  export type Ai_agent_park_sessionMinAggregateInputType = {
    id?: true
    session_name?: true
    user_id?: true
    isCocoNote?: true
    createtime?: true
    work_area_text?: true
    scene?: true
  }

  export type Ai_agent_park_sessionMaxAggregateInputType = {
    id?: true
    session_name?: true
    user_id?: true
    isCocoNote?: true
    createtime?: true
    work_area_text?: true
    scene?: true
  }

  export type Ai_agent_park_sessionCountAggregateInputType = {
    id?: true
    session_name?: true
    user_id?: true
    isCocoNote?: true
    createtime?: true
    work_area_text?: true
    scene?: true
    _all?: true
  }

  export type Ai_agent_park_sessionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ai_agent_park_session to aggregate.
     */
    where?: ai_agent_park_sessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ai_agent_park_sessions to fetch.
     */
    orderBy?: ai_agent_park_sessionOrderByWithRelationInput | ai_agent_park_sessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ai_agent_park_sessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ai_agent_park_sessions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ai_agent_park_sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ai_agent_park_sessions
    **/
    _count?: true | Ai_agent_park_sessionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Ai_agent_park_sessionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Ai_agent_park_sessionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Ai_agent_park_sessionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Ai_agent_park_sessionMaxAggregateInputType
  }

  export type GetAi_agent_park_sessionAggregateType<T extends Ai_agent_park_sessionAggregateArgs> = {
        [P in keyof T & keyof AggregateAi_agent_park_session]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateAi_agent_park_session[P]>
      : GetScalarType<T[P], AggregateAi_agent_park_session[P]>
  }




  export type ai_agent_park_sessionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ai_agent_park_sessionWhereInput
    orderBy?: ai_agent_park_sessionOrderByWithAggregationInput | ai_agent_park_sessionOrderByWithAggregationInput[]
    by: Ai_agent_park_sessionScalarFieldEnum[] | Ai_agent_park_sessionScalarFieldEnum
    having?: ai_agent_park_sessionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Ai_agent_park_sessionCountAggregateInputType | true
    _avg?: Ai_agent_park_sessionAvgAggregateInputType
    _sum?: Ai_agent_park_sessionSumAggregateInputType
    _min?: Ai_agent_park_sessionMinAggregateInputType
    _max?: Ai_agent_park_sessionMaxAggregateInputType
  }

  export type Ai_agent_park_sessionGroupByOutputType = {
    id: string
    session_name: string | null
    user_id: string | null
    isCocoNote: number | null
    createtime: Date | null
    work_area_text: string | null
    scene: string | null
    _count: Ai_agent_park_sessionCountAggregateOutputType | null
    _avg: Ai_agent_park_sessionAvgAggregateOutputType | null
    _sum: Ai_agent_park_sessionSumAggregateOutputType | null
    _min: Ai_agent_park_sessionMinAggregateOutputType | null
    _max: Ai_agent_park_sessionMaxAggregateOutputType | null
  }

  type GetAi_agent_park_sessionGroupByPayload<T extends ai_agent_park_sessionGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Ai_agent_park_sessionGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Ai_agent_park_sessionGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Ai_agent_park_sessionGroupByOutputType[P]>
            : GetScalarType<T[P], Ai_agent_park_sessionGroupByOutputType[P]>
        }
      >
    >


  export type ai_agent_park_sessionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    session_name?: boolean
    user_id?: boolean
    isCocoNote?: boolean
    createtime?: boolean
    work_area_text?: boolean
    scene?: boolean
  }, ExtArgs["result"]["ai_agent_park_session"]>


  export type ai_agent_park_sessionSelectScalar = {
    id?: boolean
    session_name?: boolean
    user_id?: boolean
    isCocoNote?: boolean
    createtime?: boolean
    work_area_text?: boolean
    scene?: boolean
  }


  export type $ai_agent_park_sessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ai_agent_park_session"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      session_name: string | null
      user_id: string | null
      isCocoNote: number | null
      createtime: Date | null
      work_area_text: string | null
      scene: string | null
    }, ExtArgs["result"]["ai_agent_park_session"]>
    composites: {}
  }

  type ai_agent_park_sessionGetPayload<S extends boolean | null | undefined | ai_agent_park_sessionDefaultArgs> = $Result.GetResult<Prisma.$ai_agent_park_sessionPayload, S>

  type ai_agent_park_sessionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ai_agent_park_sessionFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Ai_agent_park_sessionCountAggregateInputType | true
    }

  export interface ai_agent_park_sessionDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['ai_agent_park_session'], meta: { name: 'ai_agent_park_session' } }
    /**
     * Find zero or one Ai_agent_park_session that matches the filter.
     * @param {ai_agent_park_sessionFindUniqueArgs} args - Arguments to find a Ai_agent_park_session
     * @example
     * // Get one Ai_agent_park_session
     * const ai_agent_park_session = await prisma.ai_agent_park_session.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends ai_agent_park_sessionFindUniqueArgs>(args: SelectSubset<T, ai_agent_park_sessionFindUniqueArgs<ExtArgs>>): Prisma__ai_agent_park_sessionClient<$Result.GetResult<Prisma.$ai_agent_park_sessionPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Ai_agent_park_session that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {ai_agent_park_sessionFindUniqueOrThrowArgs} args - Arguments to find a Ai_agent_park_session
     * @example
     * // Get one Ai_agent_park_session
     * const ai_agent_park_session = await prisma.ai_agent_park_session.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends ai_agent_park_sessionFindUniqueOrThrowArgs>(args: SelectSubset<T, ai_agent_park_sessionFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ai_agent_park_sessionClient<$Result.GetResult<Prisma.$ai_agent_park_sessionPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Ai_agent_park_session that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ai_agent_park_sessionFindFirstArgs} args - Arguments to find a Ai_agent_park_session
     * @example
     * // Get one Ai_agent_park_session
     * const ai_agent_park_session = await prisma.ai_agent_park_session.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ai_agent_park_sessionFindFirstArgs>(args?: SelectSubset<T, ai_agent_park_sessionFindFirstArgs<ExtArgs>>): Prisma__ai_agent_park_sessionClient<$Result.GetResult<Prisma.$ai_agent_park_sessionPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Ai_agent_park_session that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ai_agent_park_sessionFindFirstOrThrowArgs} args - Arguments to find a Ai_agent_park_session
     * @example
     * // Get one Ai_agent_park_session
     * const ai_agent_park_session = await prisma.ai_agent_park_session.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ai_agent_park_sessionFindFirstOrThrowArgs>(args?: SelectSubset<T, ai_agent_park_sessionFindFirstOrThrowArgs<ExtArgs>>): Prisma__ai_agent_park_sessionClient<$Result.GetResult<Prisma.$ai_agent_park_sessionPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Ai_agent_park_sessions that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ai_agent_park_sessionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Ai_agent_park_sessions
     * const ai_agent_park_sessions = await prisma.ai_agent_park_session.findMany()
     * 
     * // Get first 10 Ai_agent_park_sessions
     * const ai_agent_park_sessions = await prisma.ai_agent_park_session.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const ai_agent_park_sessionWithIdOnly = await prisma.ai_agent_park_session.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ai_agent_park_sessionFindManyArgs>(args?: SelectSubset<T, ai_agent_park_sessionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ai_agent_park_sessionPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Ai_agent_park_session.
     * @param {ai_agent_park_sessionCreateArgs} args - Arguments to create a Ai_agent_park_session.
     * @example
     * // Create one Ai_agent_park_session
     * const Ai_agent_park_session = await prisma.ai_agent_park_session.create({
     *   data: {
     *     // ... data to create a Ai_agent_park_session
     *   }
     * })
     * 
     */
    create<T extends ai_agent_park_sessionCreateArgs>(args: SelectSubset<T, ai_agent_park_sessionCreateArgs<ExtArgs>>): Prisma__ai_agent_park_sessionClient<$Result.GetResult<Prisma.$ai_agent_park_sessionPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Ai_agent_park_sessions.
     * @param {ai_agent_park_sessionCreateManyArgs} args - Arguments to create many Ai_agent_park_sessions.
     * @example
     * // Create many Ai_agent_park_sessions
     * const ai_agent_park_session = await prisma.ai_agent_park_session.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends ai_agent_park_sessionCreateManyArgs>(args?: SelectSubset<T, ai_agent_park_sessionCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Ai_agent_park_session.
     * @param {ai_agent_park_sessionDeleteArgs} args - Arguments to delete one Ai_agent_park_session.
     * @example
     * // Delete one Ai_agent_park_session
     * const Ai_agent_park_session = await prisma.ai_agent_park_session.delete({
     *   where: {
     *     // ... filter to delete one Ai_agent_park_session
     *   }
     * })
     * 
     */
    delete<T extends ai_agent_park_sessionDeleteArgs>(args: SelectSubset<T, ai_agent_park_sessionDeleteArgs<ExtArgs>>): Prisma__ai_agent_park_sessionClient<$Result.GetResult<Prisma.$ai_agent_park_sessionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Ai_agent_park_session.
     * @param {ai_agent_park_sessionUpdateArgs} args - Arguments to update one Ai_agent_park_session.
     * @example
     * // Update one Ai_agent_park_session
     * const ai_agent_park_session = await prisma.ai_agent_park_session.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ai_agent_park_sessionUpdateArgs>(args: SelectSubset<T, ai_agent_park_sessionUpdateArgs<ExtArgs>>): Prisma__ai_agent_park_sessionClient<$Result.GetResult<Prisma.$ai_agent_park_sessionPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Ai_agent_park_sessions.
     * @param {ai_agent_park_sessionDeleteManyArgs} args - Arguments to filter Ai_agent_park_sessions to delete.
     * @example
     * // Delete a few Ai_agent_park_sessions
     * const { count } = await prisma.ai_agent_park_session.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends ai_agent_park_sessionDeleteManyArgs>(args?: SelectSubset<T, ai_agent_park_sessionDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Ai_agent_park_sessions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ai_agent_park_sessionUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Ai_agent_park_sessions
     * const ai_agent_park_session = await prisma.ai_agent_park_session.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends ai_agent_park_sessionUpdateManyArgs>(args: SelectSubset<T, ai_agent_park_sessionUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Ai_agent_park_session.
     * @param {ai_agent_park_sessionUpsertArgs} args - Arguments to update or create a Ai_agent_park_session.
     * @example
     * // Update or create a Ai_agent_park_session
     * const ai_agent_park_session = await prisma.ai_agent_park_session.upsert({
     *   create: {
     *     // ... data to create a Ai_agent_park_session
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Ai_agent_park_session we want to update
     *   }
     * })
     */
    upsert<T extends ai_agent_park_sessionUpsertArgs>(args: SelectSubset<T, ai_agent_park_sessionUpsertArgs<ExtArgs>>): Prisma__ai_agent_park_sessionClient<$Result.GetResult<Prisma.$ai_agent_park_sessionPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Ai_agent_park_sessions.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ai_agent_park_sessionCountArgs} args - Arguments to filter Ai_agent_park_sessions to count.
     * @example
     * // Count the number of Ai_agent_park_sessions
     * const count = await prisma.ai_agent_park_session.count({
     *   where: {
     *     // ... the filter for the Ai_agent_park_sessions we want to count
     *   }
     * })
    **/
    count<T extends ai_agent_park_sessionCountArgs>(
      args?: Subset<T, ai_agent_park_sessionCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Ai_agent_park_sessionCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Ai_agent_park_session.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Ai_agent_park_sessionAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Ai_agent_park_sessionAggregateArgs>(args: Subset<T, Ai_agent_park_sessionAggregateArgs>): Prisma.PrismaPromise<GetAi_agent_park_sessionAggregateType<T>>

    /**
     * Group by Ai_agent_park_session.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ai_agent_park_sessionGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends ai_agent_park_sessionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ai_agent_park_sessionGroupByArgs['orderBy'] }
        : { orderBy?: ai_agent_park_sessionGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, ai_agent_park_sessionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAi_agent_park_sessionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the ai_agent_park_session model
   */
  readonly fields: ai_agent_park_sessionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for ai_agent_park_session.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__ai_agent_park_sessionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the ai_agent_park_session model
   */ 
  interface ai_agent_park_sessionFieldRefs {
    readonly id: FieldRef<"ai_agent_park_session", 'String'>
    readonly session_name: FieldRef<"ai_agent_park_session", 'String'>
    readonly user_id: FieldRef<"ai_agent_park_session", 'String'>
    readonly isCocoNote: FieldRef<"ai_agent_park_session", 'Int'>
    readonly createtime: FieldRef<"ai_agent_park_session", 'DateTime'>
    readonly work_area_text: FieldRef<"ai_agent_park_session", 'String'>
    readonly scene: FieldRef<"ai_agent_park_session", 'String'>
  }
    

  // Custom InputTypes
  /**
   * ai_agent_park_session findUnique
   */
  export type ai_agent_park_sessionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ai_agent_park_session
     */
    select?: ai_agent_park_sessionSelect<ExtArgs> | null
    /**
     * Filter, which ai_agent_park_session to fetch.
     */
    where: ai_agent_park_sessionWhereUniqueInput
  }

  /**
   * ai_agent_park_session findUniqueOrThrow
   */
  export type ai_agent_park_sessionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ai_agent_park_session
     */
    select?: ai_agent_park_sessionSelect<ExtArgs> | null
    /**
     * Filter, which ai_agent_park_session to fetch.
     */
    where: ai_agent_park_sessionWhereUniqueInput
  }

  /**
   * ai_agent_park_session findFirst
   */
  export type ai_agent_park_sessionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ai_agent_park_session
     */
    select?: ai_agent_park_sessionSelect<ExtArgs> | null
    /**
     * Filter, which ai_agent_park_session to fetch.
     */
    where?: ai_agent_park_sessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ai_agent_park_sessions to fetch.
     */
    orderBy?: ai_agent_park_sessionOrderByWithRelationInput | ai_agent_park_sessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ai_agent_park_sessions.
     */
    cursor?: ai_agent_park_sessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ai_agent_park_sessions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ai_agent_park_sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ai_agent_park_sessions.
     */
    distinct?: Ai_agent_park_sessionScalarFieldEnum | Ai_agent_park_sessionScalarFieldEnum[]
  }

  /**
   * ai_agent_park_session findFirstOrThrow
   */
  export type ai_agent_park_sessionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ai_agent_park_session
     */
    select?: ai_agent_park_sessionSelect<ExtArgs> | null
    /**
     * Filter, which ai_agent_park_session to fetch.
     */
    where?: ai_agent_park_sessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ai_agent_park_sessions to fetch.
     */
    orderBy?: ai_agent_park_sessionOrderByWithRelationInput | ai_agent_park_sessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ai_agent_park_sessions.
     */
    cursor?: ai_agent_park_sessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ai_agent_park_sessions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ai_agent_park_sessions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ai_agent_park_sessions.
     */
    distinct?: Ai_agent_park_sessionScalarFieldEnum | Ai_agent_park_sessionScalarFieldEnum[]
  }

  /**
   * ai_agent_park_session findMany
   */
  export type ai_agent_park_sessionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ai_agent_park_session
     */
    select?: ai_agent_park_sessionSelect<ExtArgs> | null
    /**
     * Filter, which ai_agent_park_sessions to fetch.
     */
    where?: ai_agent_park_sessionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ai_agent_park_sessions to fetch.
     */
    orderBy?: ai_agent_park_sessionOrderByWithRelationInput | ai_agent_park_sessionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ai_agent_park_sessions.
     */
    cursor?: ai_agent_park_sessionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ai_agent_park_sessions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ai_agent_park_sessions.
     */
    skip?: number
    distinct?: Ai_agent_park_sessionScalarFieldEnum | Ai_agent_park_sessionScalarFieldEnum[]
  }

  /**
   * ai_agent_park_session create
   */
  export type ai_agent_park_sessionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ai_agent_park_session
     */
    select?: ai_agent_park_sessionSelect<ExtArgs> | null
    /**
     * The data needed to create a ai_agent_park_session.
     */
    data: XOR<ai_agent_park_sessionCreateInput, ai_agent_park_sessionUncheckedCreateInput>
  }

  /**
   * ai_agent_park_session createMany
   */
  export type ai_agent_park_sessionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many ai_agent_park_sessions.
     */
    data: ai_agent_park_sessionCreateManyInput | ai_agent_park_sessionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * ai_agent_park_session update
   */
  export type ai_agent_park_sessionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ai_agent_park_session
     */
    select?: ai_agent_park_sessionSelect<ExtArgs> | null
    /**
     * The data needed to update a ai_agent_park_session.
     */
    data: XOR<ai_agent_park_sessionUpdateInput, ai_agent_park_sessionUncheckedUpdateInput>
    /**
     * Choose, which ai_agent_park_session to update.
     */
    where: ai_agent_park_sessionWhereUniqueInput
  }

  /**
   * ai_agent_park_session updateMany
   */
  export type ai_agent_park_sessionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ai_agent_park_sessions.
     */
    data: XOR<ai_agent_park_sessionUpdateManyMutationInput, ai_agent_park_sessionUncheckedUpdateManyInput>
    /**
     * Filter which ai_agent_park_sessions to update
     */
    where?: ai_agent_park_sessionWhereInput
  }

  /**
   * ai_agent_park_session upsert
   */
  export type ai_agent_park_sessionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ai_agent_park_session
     */
    select?: ai_agent_park_sessionSelect<ExtArgs> | null
    /**
     * The filter to search for the ai_agent_park_session to update in case it exists.
     */
    where: ai_agent_park_sessionWhereUniqueInput
    /**
     * In case the ai_agent_park_session found by the `where` argument doesn't exist, create a new ai_agent_park_session with this data.
     */
    create: XOR<ai_agent_park_sessionCreateInput, ai_agent_park_sessionUncheckedCreateInput>
    /**
     * In case the ai_agent_park_session was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ai_agent_park_sessionUpdateInput, ai_agent_park_sessionUncheckedUpdateInput>
  }

  /**
   * ai_agent_park_session delete
   */
  export type ai_agent_park_sessionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ai_agent_park_session
     */
    select?: ai_agent_park_sessionSelect<ExtArgs> | null
    /**
     * Filter which ai_agent_park_session to delete.
     */
    where: ai_agent_park_sessionWhereUniqueInput
  }

  /**
   * ai_agent_park_session deleteMany
   */
  export type ai_agent_park_sessionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ai_agent_park_sessions to delete
     */
    where?: ai_agent_park_sessionWhereInput
  }

  /**
   * ai_agent_park_session without action
   */
  export type ai_agent_park_sessionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ai_agent_park_session
     */
    select?: ai_agent_park_sessionSelect<ExtArgs> | null
  }


  /**
   * Model classroom_ob_comment
   */

  export type AggregateClassroom_ob_comment = {
    _count: Classroom_ob_commentCountAggregateOutputType | null
    _avg: Classroom_ob_commentAvgAggregateOutputType | null
    _sum: Classroom_ob_commentSumAggregateOutputType | null
    _min: Classroom_ob_commentMinAggregateOutputType | null
    _max: Classroom_ob_commentMaxAggregateOutputType | null
  }

  export type Classroom_ob_commentAvgAggregateOutputType = {
    audit_status: number | null
  }

  export type Classroom_ob_commentSumAggregateOutputType = {
    audit_status: number | null
  }

  export type Classroom_ob_commentMinAggregateOutputType = {
    id: string | null
    module_id: string | null
    module_name: string | null
    nickname: string | null
    commentContent: string | null
    audit_status: number | null
    t_id: string | null
    create_time: Date | null
  }

  export type Classroom_ob_commentMaxAggregateOutputType = {
    id: string | null
    module_id: string | null
    module_name: string | null
    nickname: string | null
    commentContent: string | null
    audit_status: number | null
    t_id: string | null
    create_time: Date | null
  }

  export type Classroom_ob_commentCountAggregateOutputType = {
    id: number
    module_id: number
    module_name: number
    nickname: number
    commentContent: number
    audit_status: number
    t_id: number
    create_time: number
    _all: number
  }


  export type Classroom_ob_commentAvgAggregateInputType = {
    audit_status?: true
  }

  export type Classroom_ob_commentSumAggregateInputType = {
    audit_status?: true
  }

  export type Classroom_ob_commentMinAggregateInputType = {
    id?: true
    module_id?: true
    module_name?: true
    nickname?: true
    commentContent?: true
    audit_status?: true
    t_id?: true
    create_time?: true
  }

  export type Classroom_ob_commentMaxAggregateInputType = {
    id?: true
    module_id?: true
    module_name?: true
    nickname?: true
    commentContent?: true
    audit_status?: true
    t_id?: true
    create_time?: true
  }

  export type Classroom_ob_commentCountAggregateInputType = {
    id?: true
    module_id?: true
    module_name?: true
    nickname?: true
    commentContent?: true
    audit_status?: true
    t_id?: true
    create_time?: true
    _all?: true
  }

  export type Classroom_ob_commentAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which classroom_ob_comment to aggregate.
     */
    where?: classroom_ob_commentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of classroom_ob_comments to fetch.
     */
    orderBy?: classroom_ob_commentOrderByWithRelationInput | classroom_ob_commentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: classroom_ob_commentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` classroom_ob_comments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` classroom_ob_comments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned classroom_ob_comments
    **/
    _count?: true | Classroom_ob_commentCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Classroom_ob_commentAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Classroom_ob_commentSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Classroom_ob_commentMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Classroom_ob_commentMaxAggregateInputType
  }

  export type GetClassroom_ob_commentAggregateType<T extends Classroom_ob_commentAggregateArgs> = {
        [P in keyof T & keyof AggregateClassroom_ob_comment]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateClassroom_ob_comment[P]>
      : GetScalarType<T[P], AggregateClassroom_ob_comment[P]>
  }




  export type classroom_ob_commentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: classroom_ob_commentWhereInput
    orderBy?: classroom_ob_commentOrderByWithAggregationInput | classroom_ob_commentOrderByWithAggregationInput[]
    by: Classroom_ob_commentScalarFieldEnum[] | Classroom_ob_commentScalarFieldEnum
    having?: classroom_ob_commentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Classroom_ob_commentCountAggregateInputType | true
    _avg?: Classroom_ob_commentAvgAggregateInputType
    _sum?: Classroom_ob_commentSumAggregateInputType
    _min?: Classroom_ob_commentMinAggregateInputType
    _max?: Classroom_ob_commentMaxAggregateInputType
  }

  export type Classroom_ob_commentGroupByOutputType = {
    id: string
    module_id: string
    module_name: string | null
    nickname: string | null
    commentContent: string | null
    audit_status: number
    t_id: string | null
    create_time: Date | null
    _count: Classroom_ob_commentCountAggregateOutputType | null
    _avg: Classroom_ob_commentAvgAggregateOutputType | null
    _sum: Classroom_ob_commentSumAggregateOutputType | null
    _min: Classroom_ob_commentMinAggregateOutputType | null
    _max: Classroom_ob_commentMaxAggregateOutputType | null
  }

  type GetClassroom_ob_commentGroupByPayload<T extends classroom_ob_commentGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Classroom_ob_commentGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Classroom_ob_commentGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Classroom_ob_commentGroupByOutputType[P]>
            : GetScalarType<T[P], Classroom_ob_commentGroupByOutputType[P]>
        }
      >
    >


  export type classroom_ob_commentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    module_id?: boolean
    module_name?: boolean
    nickname?: boolean
    commentContent?: boolean
    audit_status?: boolean
    t_id?: boolean
    create_time?: boolean
  }, ExtArgs["result"]["classroom_ob_comment"]>


  export type classroom_ob_commentSelectScalar = {
    id?: boolean
    module_id?: boolean
    module_name?: boolean
    nickname?: boolean
    commentContent?: boolean
    audit_status?: boolean
    t_id?: boolean
    create_time?: boolean
  }


  export type $classroom_ob_commentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "classroom_ob_comment"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      module_id: string
      module_name: string | null
      nickname: string | null
      commentContent: string | null
      audit_status: number
      t_id: string | null
      create_time: Date | null
    }, ExtArgs["result"]["classroom_ob_comment"]>
    composites: {}
  }

  type classroom_ob_commentGetPayload<S extends boolean | null | undefined | classroom_ob_commentDefaultArgs> = $Result.GetResult<Prisma.$classroom_ob_commentPayload, S>

  type classroom_ob_commentCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<classroom_ob_commentFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Classroom_ob_commentCountAggregateInputType | true
    }

  export interface classroom_ob_commentDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['classroom_ob_comment'], meta: { name: 'classroom_ob_comment' } }
    /**
     * Find zero or one Classroom_ob_comment that matches the filter.
     * @param {classroom_ob_commentFindUniqueArgs} args - Arguments to find a Classroom_ob_comment
     * @example
     * // Get one Classroom_ob_comment
     * const classroom_ob_comment = await prisma.classroom_ob_comment.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends classroom_ob_commentFindUniqueArgs>(args: SelectSubset<T, classroom_ob_commentFindUniqueArgs<ExtArgs>>): Prisma__classroom_ob_commentClient<$Result.GetResult<Prisma.$classroom_ob_commentPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Classroom_ob_comment that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {classroom_ob_commentFindUniqueOrThrowArgs} args - Arguments to find a Classroom_ob_comment
     * @example
     * // Get one Classroom_ob_comment
     * const classroom_ob_comment = await prisma.classroom_ob_comment.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends classroom_ob_commentFindUniqueOrThrowArgs>(args: SelectSubset<T, classroom_ob_commentFindUniqueOrThrowArgs<ExtArgs>>): Prisma__classroom_ob_commentClient<$Result.GetResult<Prisma.$classroom_ob_commentPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Classroom_ob_comment that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_ob_commentFindFirstArgs} args - Arguments to find a Classroom_ob_comment
     * @example
     * // Get one Classroom_ob_comment
     * const classroom_ob_comment = await prisma.classroom_ob_comment.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends classroom_ob_commentFindFirstArgs>(args?: SelectSubset<T, classroom_ob_commentFindFirstArgs<ExtArgs>>): Prisma__classroom_ob_commentClient<$Result.GetResult<Prisma.$classroom_ob_commentPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Classroom_ob_comment that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_ob_commentFindFirstOrThrowArgs} args - Arguments to find a Classroom_ob_comment
     * @example
     * // Get one Classroom_ob_comment
     * const classroom_ob_comment = await prisma.classroom_ob_comment.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends classroom_ob_commentFindFirstOrThrowArgs>(args?: SelectSubset<T, classroom_ob_commentFindFirstOrThrowArgs<ExtArgs>>): Prisma__classroom_ob_commentClient<$Result.GetResult<Prisma.$classroom_ob_commentPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Classroom_ob_comments that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_ob_commentFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Classroom_ob_comments
     * const classroom_ob_comments = await prisma.classroom_ob_comment.findMany()
     * 
     * // Get first 10 Classroom_ob_comments
     * const classroom_ob_comments = await prisma.classroom_ob_comment.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const classroom_ob_commentWithIdOnly = await prisma.classroom_ob_comment.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends classroom_ob_commentFindManyArgs>(args?: SelectSubset<T, classroom_ob_commentFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$classroom_ob_commentPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Classroom_ob_comment.
     * @param {classroom_ob_commentCreateArgs} args - Arguments to create a Classroom_ob_comment.
     * @example
     * // Create one Classroom_ob_comment
     * const Classroom_ob_comment = await prisma.classroom_ob_comment.create({
     *   data: {
     *     // ... data to create a Classroom_ob_comment
     *   }
     * })
     * 
     */
    create<T extends classroom_ob_commentCreateArgs>(args: SelectSubset<T, classroom_ob_commentCreateArgs<ExtArgs>>): Prisma__classroom_ob_commentClient<$Result.GetResult<Prisma.$classroom_ob_commentPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Classroom_ob_comments.
     * @param {classroom_ob_commentCreateManyArgs} args - Arguments to create many Classroom_ob_comments.
     * @example
     * // Create many Classroom_ob_comments
     * const classroom_ob_comment = await prisma.classroom_ob_comment.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends classroom_ob_commentCreateManyArgs>(args?: SelectSubset<T, classroom_ob_commentCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Classroom_ob_comment.
     * @param {classroom_ob_commentDeleteArgs} args - Arguments to delete one Classroom_ob_comment.
     * @example
     * // Delete one Classroom_ob_comment
     * const Classroom_ob_comment = await prisma.classroom_ob_comment.delete({
     *   where: {
     *     // ... filter to delete one Classroom_ob_comment
     *   }
     * })
     * 
     */
    delete<T extends classroom_ob_commentDeleteArgs>(args: SelectSubset<T, classroom_ob_commentDeleteArgs<ExtArgs>>): Prisma__classroom_ob_commentClient<$Result.GetResult<Prisma.$classroom_ob_commentPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Classroom_ob_comment.
     * @param {classroom_ob_commentUpdateArgs} args - Arguments to update one Classroom_ob_comment.
     * @example
     * // Update one Classroom_ob_comment
     * const classroom_ob_comment = await prisma.classroom_ob_comment.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends classroom_ob_commentUpdateArgs>(args: SelectSubset<T, classroom_ob_commentUpdateArgs<ExtArgs>>): Prisma__classroom_ob_commentClient<$Result.GetResult<Prisma.$classroom_ob_commentPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Classroom_ob_comments.
     * @param {classroom_ob_commentDeleteManyArgs} args - Arguments to filter Classroom_ob_comments to delete.
     * @example
     * // Delete a few Classroom_ob_comments
     * const { count } = await prisma.classroom_ob_comment.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends classroom_ob_commentDeleteManyArgs>(args?: SelectSubset<T, classroom_ob_commentDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Classroom_ob_comments.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_ob_commentUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Classroom_ob_comments
     * const classroom_ob_comment = await prisma.classroom_ob_comment.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends classroom_ob_commentUpdateManyArgs>(args: SelectSubset<T, classroom_ob_commentUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Classroom_ob_comment.
     * @param {classroom_ob_commentUpsertArgs} args - Arguments to update or create a Classroom_ob_comment.
     * @example
     * // Update or create a Classroom_ob_comment
     * const classroom_ob_comment = await prisma.classroom_ob_comment.upsert({
     *   create: {
     *     // ... data to create a Classroom_ob_comment
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Classroom_ob_comment we want to update
     *   }
     * })
     */
    upsert<T extends classroom_ob_commentUpsertArgs>(args: SelectSubset<T, classroom_ob_commentUpsertArgs<ExtArgs>>): Prisma__classroom_ob_commentClient<$Result.GetResult<Prisma.$classroom_ob_commentPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Classroom_ob_comments.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_ob_commentCountArgs} args - Arguments to filter Classroom_ob_comments to count.
     * @example
     * // Count the number of Classroom_ob_comments
     * const count = await prisma.classroom_ob_comment.count({
     *   where: {
     *     // ... the filter for the Classroom_ob_comments we want to count
     *   }
     * })
    **/
    count<T extends classroom_ob_commentCountArgs>(
      args?: Subset<T, classroom_ob_commentCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Classroom_ob_commentCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Classroom_ob_comment.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Classroom_ob_commentAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Classroom_ob_commentAggregateArgs>(args: Subset<T, Classroom_ob_commentAggregateArgs>): Prisma.PrismaPromise<GetClassroom_ob_commentAggregateType<T>>

    /**
     * Group by Classroom_ob_comment.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_ob_commentGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends classroom_ob_commentGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: classroom_ob_commentGroupByArgs['orderBy'] }
        : { orderBy?: classroom_ob_commentGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, classroom_ob_commentGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetClassroom_ob_commentGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the classroom_ob_comment model
   */
  readonly fields: classroom_ob_commentFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for classroom_ob_comment.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__classroom_ob_commentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the classroom_ob_comment model
   */ 
  interface classroom_ob_commentFieldRefs {
    readonly id: FieldRef<"classroom_ob_comment", 'String'>
    readonly module_id: FieldRef<"classroom_ob_comment", 'String'>
    readonly module_name: FieldRef<"classroom_ob_comment", 'String'>
    readonly nickname: FieldRef<"classroom_ob_comment", 'String'>
    readonly commentContent: FieldRef<"classroom_ob_comment", 'String'>
    readonly audit_status: FieldRef<"classroom_ob_comment", 'Int'>
    readonly t_id: FieldRef<"classroom_ob_comment", 'String'>
    readonly create_time: FieldRef<"classroom_ob_comment", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * classroom_ob_comment findUnique
   */
  export type classroom_ob_commentFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_ob_comment
     */
    select?: classroom_ob_commentSelect<ExtArgs> | null
    /**
     * Filter, which classroom_ob_comment to fetch.
     */
    where: classroom_ob_commentWhereUniqueInput
  }

  /**
   * classroom_ob_comment findUniqueOrThrow
   */
  export type classroom_ob_commentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_ob_comment
     */
    select?: classroom_ob_commentSelect<ExtArgs> | null
    /**
     * Filter, which classroom_ob_comment to fetch.
     */
    where: classroom_ob_commentWhereUniqueInput
  }

  /**
   * classroom_ob_comment findFirst
   */
  export type classroom_ob_commentFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_ob_comment
     */
    select?: classroom_ob_commentSelect<ExtArgs> | null
    /**
     * Filter, which classroom_ob_comment to fetch.
     */
    where?: classroom_ob_commentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of classroom_ob_comments to fetch.
     */
    orderBy?: classroom_ob_commentOrderByWithRelationInput | classroom_ob_commentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for classroom_ob_comments.
     */
    cursor?: classroom_ob_commentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` classroom_ob_comments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` classroom_ob_comments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of classroom_ob_comments.
     */
    distinct?: Classroom_ob_commentScalarFieldEnum | Classroom_ob_commentScalarFieldEnum[]
  }

  /**
   * classroom_ob_comment findFirstOrThrow
   */
  export type classroom_ob_commentFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_ob_comment
     */
    select?: classroom_ob_commentSelect<ExtArgs> | null
    /**
     * Filter, which classroom_ob_comment to fetch.
     */
    where?: classroom_ob_commentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of classroom_ob_comments to fetch.
     */
    orderBy?: classroom_ob_commentOrderByWithRelationInput | classroom_ob_commentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for classroom_ob_comments.
     */
    cursor?: classroom_ob_commentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` classroom_ob_comments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` classroom_ob_comments.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of classroom_ob_comments.
     */
    distinct?: Classroom_ob_commentScalarFieldEnum | Classroom_ob_commentScalarFieldEnum[]
  }

  /**
   * classroom_ob_comment findMany
   */
  export type classroom_ob_commentFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_ob_comment
     */
    select?: classroom_ob_commentSelect<ExtArgs> | null
    /**
     * Filter, which classroom_ob_comments to fetch.
     */
    where?: classroom_ob_commentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of classroom_ob_comments to fetch.
     */
    orderBy?: classroom_ob_commentOrderByWithRelationInput | classroom_ob_commentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing classroom_ob_comments.
     */
    cursor?: classroom_ob_commentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` classroom_ob_comments from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` classroom_ob_comments.
     */
    skip?: number
    distinct?: Classroom_ob_commentScalarFieldEnum | Classroom_ob_commentScalarFieldEnum[]
  }

  /**
   * classroom_ob_comment create
   */
  export type classroom_ob_commentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_ob_comment
     */
    select?: classroom_ob_commentSelect<ExtArgs> | null
    /**
     * The data needed to create a classroom_ob_comment.
     */
    data: XOR<classroom_ob_commentCreateInput, classroom_ob_commentUncheckedCreateInput>
  }

  /**
   * classroom_ob_comment createMany
   */
  export type classroom_ob_commentCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many classroom_ob_comments.
     */
    data: classroom_ob_commentCreateManyInput | classroom_ob_commentCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * classroom_ob_comment update
   */
  export type classroom_ob_commentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_ob_comment
     */
    select?: classroom_ob_commentSelect<ExtArgs> | null
    /**
     * The data needed to update a classroom_ob_comment.
     */
    data: XOR<classroom_ob_commentUpdateInput, classroom_ob_commentUncheckedUpdateInput>
    /**
     * Choose, which classroom_ob_comment to update.
     */
    where: classroom_ob_commentWhereUniqueInput
  }

  /**
   * classroom_ob_comment updateMany
   */
  export type classroom_ob_commentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update classroom_ob_comments.
     */
    data: XOR<classroom_ob_commentUpdateManyMutationInput, classroom_ob_commentUncheckedUpdateManyInput>
    /**
     * Filter which classroom_ob_comments to update
     */
    where?: classroom_ob_commentWhereInput
  }

  /**
   * classroom_ob_comment upsert
   */
  export type classroom_ob_commentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_ob_comment
     */
    select?: classroom_ob_commentSelect<ExtArgs> | null
    /**
     * The filter to search for the classroom_ob_comment to update in case it exists.
     */
    where: classroom_ob_commentWhereUniqueInput
    /**
     * In case the classroom_ob_comment found by the `where` argument doesn't exist, create a new classroom_ob_comment with this data.
     */
    create: XOR<classroom_ob_commentCreateInput, classroom_ob_commentUncheckedCreateInput>
    /**
     * In case the classroom_ob_comment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<classroom_ob_commentUpdateInput, classroom_ob_commentUncheckedUpdateInput>
  }

  /**
   * classroom_ob_comment delete
   */
  export type classroom_ob_commentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_ob_comment
     */
    select?: classroom_ob_commentSelect<ExtArgs> | null
    /**
     * Filter which classroom_ob_comment to delete.
     */
    where: classroom_ob_commentWhereUniqueInput
  }

  /**
   * classroom_ob_comment deleteMany
   */
  export type classroom_ob_commentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which classroom_ob_comments to delete
     */
    where?: classroom_ob_commentWhereInput
  }

  /**
   * classroom_ob_comment without action
   */
  export type classroom_ob_commentDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_ob_comment
     */
    select?: classroom_ob_commentSelect<ExtArgs> | null
  }


  /**
   * Model classroom_observation
   */

  export type AggregateClassroom_observation = {
    _count: Classroom_observationCountAggregateOutputType | null
    _avg: Classroom_observationAvgAggregateOutputType | null
    _sum: Classroom_observationSumAggregateOutputType | null
    _min: Classroom_observationMinAggregateOutputType | null
    _max: Classroom_observationMaxAggregateOutputType | null
  }

  export type Classroom_observationAvgAggregateOutputType = {
    Type: number | null
    tIndex: number | null
    like_num: number | null
    isdel: number | null
  }

  export type Classroom_observationSumAggregateOutputType = {
    Type: number | null
    tIndex: number | null
    like_num: number | null
    isdel: number | null
  }

  export type Classroom_observationMinAggregateOutputType = {
    id: string | null
    jsonData: string | null
    Type: number | null
    tIndex: number | null
    tId: string | null
    createtime: Date | null
    like_num: number | null
    like_data: string | null
    userid: string | null
    isdel: number | null
    limitData: string | null
  }

  export type Classroom_observationMaxAggregateOutputType = {
    id: string | null
    jsonData: string | null
    Type: number | null
    tIndex: number | null
    tId: string | null
    createtime: Date | null
    like_num: number | null
    like_data: string | null
    userid: string | null
    isdel: number | null
    limitData: string | null
  }

  export type Classroom_observationCountAggregateOutputType = {
    id: number
    jsonData: number
    Type: number
    tIndex: number
    tId: number
    createtime: number
    like_num: number
    like_data: number
    userid: number
    isdel: number
    limitData: number
    _all: number
  }


  export type Classroom_observationAvgAggregateInputType = {
    Type?: true
    tIndex?: true
    like_num?: true
    isdel?: true
  }

  export type Classroom_observationSumAggregateInputType = {
    Type?: true
    tIndex?: true
    like_num?: true
    isdel?: true
  }

  export type Classroom_observationMinAggregateInputType = {
    id?: true
    jsonData?: true
    Type?: true
    tIndex?: true
    tId?: true
    createtime?: true
    like_num?: true
    like_data?: true
    userid?: true
    isdel?: true
    limitData?: true
  }

  export type Classroom_observationMaxAggregateInputType = {
    id?: true
    jsonData?: true
    Type?: true
    tIndex?: true
    tId?: true
    createtime?: true
    like_num?: true
    like_data?: true
    userid?: true
    isdel?: true
    limitData?: true
  }

  export type Classroom_observationCountAggregateInputType = {
    id?: true
    jsonData?: true
    Type?: true
    tIndex?: true
    tId?: true
    createtime?: true
    like_num?: true
    like_data?: true
    userid?: true
    isdel?: true
    limitData?: true
    _all?: true
  }

  export type Classroom_observationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which classroom_observation to aggregate.
     */
    where?: classroom_observationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of classroom_observations to fetch.
     */
    orderBy?: classroom_observationOrderByWithRelationInput | classroom_observationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: classroom_observationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` classroom_observations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` classroom_observations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned classroom_observations
    **/
    _count?: true | Classroom_observationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Classroom_observationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Classroom_observationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Classroom_observationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Classroom_observationMaxAggregateInputType
  }

  export type GetClassroom_observationAggregateType<T extends Classroom_observationAggregateArgs> = {
        [P in keyof T & keyof AggregateClassroom_observation]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateClassroom_observation[P]>
      : GetScalarType<T[P], AggregateClassroom_observation[P]>
  }




  export type classroom_observationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: classroom_observationWhereInput
    orderBy?: classroom_observationOrderByWithAggregationInput | classroom_observationOrderByWithAggregationInput[]
    by: Classroom_observationScalarFieldEnum[] | Classroom_observationScalarFieldEnum
    having?: classroom_observationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Classroom_observationCountAggregateInputType | true
    _avg?: Classroom_observationAvgAggregateInputType
    _sum?: Classroom_observationSumAggregateInputType
    _min?: Classroom_observationMinAggregateInputType
    _max?: Classroom_observationMaxAggregateInputType
  }

  export type Classroom_observationGroupByOutputType = {
    id: string
    jsonData: string | null
    Type: number | null
    tIndex: number | null
    tId: string | null
    createtime: Date | null
    like_num: number
    like_data: string | null
    userid: string | null
    isdel: number | null
    limitData: string | null
    _count: Classroom_observationCountAggregateOutputType | null
    _avg: Classroom_observationAvgAggregateOutputType | null
    _sum: Classroom_observationSumAggregateOutputType | null
    _min: Classroom_observationMinAggregateOutputType | null
    _max: Classroom_observationMaxAggregateOutputType | null
  }

  type GetClassroom_observationGroupByPayload<T extends classroom_observationGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Classroom_observationGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Classroom_observationGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Classroom_observationGroupByOutputType[P]>
            : GetScalarType<T[P], Classroom_observationGroupByOutputType[P]>
        }
      >
    >


  export type classroom_observationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jsonData?: boolean
    Type?: boolean
    tIndex?: boolean
    tId?: boolean
    createtime?: boolean
    like_num?: boolean
    like_data?: boolean
    userid?: boolean
    isdel?: boolean
    limitData?: boolean
  }, ExtArgs["result"]["classroom_observation"]>


  export type classroom_observationSelectScalar = {
    id?: boolean
    jsonData?: boolean
    Type?: boolean
    tIndex?: boolean
    tId?: boolean
    createtime?: boolean
    like_num?: boolean
    like_data?: boolean
    userid?: boolean
    isdel?: boolean
    limitData?: boolean
  }


  export type $classroom_observationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "classroom_observation"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      jsonData: string | null
      Type: number | null
      tIndex: number | null
      tId: string | null
      createtime: Date | null
      like_num: number
      like_data: string | null
      userid: string | null
      isdel: number | null
      limitData: string | null
    }, ExtArgs["result"]["classroom_observation"]>
    composites: {}
  }

  type classroom_observationGetPayload<S extends boolean | null | undefined | classroom_observationDefaultArgs> = $Result.GetResult<Prisma.$classroom_observationPayload, S>

  type classroom_observationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<classroom_observationFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Classroom_observationCountAggregateInputType | true
    }

  export interface classroom_observationDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['classroom_observation'], meta: { name: 'classroom_observation' } }
    /**
     * Find zero or one Classroom_observation that matches the filter.
     * @param {classroom_observationFindUniqueArgs} args - Arguments to find a Classroom_observation
     * @example
     * // Get one Classroom_observation
     * const classroom_observation = await prisma.classroom_observation.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends classroom_observationFindUniqueArgs>(args: SelectSubset<T, classroom_observationFindUniqueArgs<ExtArgs>>): Prisma__classroom_observationClient<$Result.GetResult<Prisma.$classroom_observationPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Classroom_observation that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {classroom_observationFindUniqueOrThrowArgs} args - Arguments to find a Classroom_observation
     * @example
     * // Get one Classroom_observation
     * const classroom_observation = await prisma.classroom_observation.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends classroom_observationFindUniqueOrThrowArgs>(args: SelectSubset<T, classroom_observationFindUniqueOrThrowArgs<ExtArgs>>): Prisma__classroom_observationClient<$Result.GetResult<Prisma.$classroom_observationPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Classroom_observation that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_observationFindFirstArgs} args - Arguments to find a Classroom_observation
     * @example
     * // Get one Classroom_observation
     * const classroom_observation = await prisma.classroom_observation.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends classroom_observationFindFirstArgs>(args?: SelectSubset<T, classroom_observationFindFirstArgs<ExtArgs>>): Prisma__classroom_observationClient<$Result.GetResult<Prisma.$classroom_observationPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Classroom_observation that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_observationFindFirstOrThrowArgs} args - Arguments to find a Classroom_observation
     * @example
     * // Get one Classroom_observation
     * const classroom_observation = await prisma.classroom_observation.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends classroom_observationFindFirstOrThrowArgs>(args?: SelectSubset<T, classroom_observationFindFirstOrThrowArgs<ExtArgs>>): Prisma__classroom_observationClient<$Result.GetResult<Prisma.$classroom_observationPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Classroom_observations that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_observationFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Classroom_observations
     * const classroom_observations = await prisma.classroom_observation.findMany()
     * 
     * // Get first 10 Classroom_observations
     * const classroom_observations = await prisma.classroom_observation.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const classroom_observationWithIdOnly = await prisma.classroom_observation.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends classroom_observationFindManyArgs>(args?: SelectSubset<T, classroom_observationFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$classroom_observationPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Classroom_observation.
     * @param {classroom_observationCreateArgs} args - Arguments to create a Classroom_observation.
     * @example
     * // Create one Classroom_observation
     * const Classroom_observation = await prisma.classroom_observation.create({
     *   data: {
     *     // ... data to create a Classroom_observation
     *   }
     * })
     * 
     */
    create<T extends classroom_observationCreateArgs>(args: SelectSubset<T, classroom_observationCreateArgs<ExtArgs>>): Prisma__classroom_observationClient<$Result.GetResult<Prisma.$classroom_observationPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Classroom_observations.
     * @param {classroom_observationCreateManyArgs} args - Arguments to create many Classroom_observations.
     * @example
     * // Create many Classroom_observations
     * const classroom_observation = await prisma.classroom_observation.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends classroom_observationCreateManyArgs>(args?: SelectSubset<T, classroom_observationCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Classroom_observation.
     * @param {classroom_observationDeleteArgs} args - Arguments to delete one Classroom_observation.
     * @example
     * // Delete one Classroom_observation
     * const Classroom_observation = await prisma.classroom_observation.delete({
     *   where: {
     *     // ... filter to delete one Classroom_observation
     *   }
     * })
     * 
     */
    delete<T extends classroom_observationDeleteArgs>(args: SelectSubset<T, classroom_observationDeleteArgs<ExtArgs>>): Prisma__classroom_observationClient<$Result.GetResult<Prisma.$classroom_observationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Classroom_observation.
     * @param {classroom_observationUpdateArgs} args - Arguments to update one Classroom_observation.
     * @example
     * // Update one Classroom_observation
     * const classroom_observation = await prisma.classroom_observation.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends classroom_observationUpdateArgs>(args: SelectSubset<T, classroom_observationUpdateArgs<ExtArgs>>): Prisma__classroom_observationClient<$Result.GetResult<Prisma.$classroom_observationPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Classroom_observations.
     * @param {classroom_observationDeleteManyArgs} args - Arguments to filter Classroom_observations to delete.
     * @example
     * // Delete a few Classroom_observations
     * const { count } = await prisma.classroom_observation.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends classroom_observationDeleteManyArgs>(args?: SelectSubset<T, classroom_observationDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Classroom_observations.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_observationUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Classroom_observations
     * const classroom_observation = await prisma.classroom_observation.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends classroom_observationUpdateManyArgs>(args: SelectSubset<T, classroom_observationUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Classroom_observation.
     * @param {classroom_observationUpsertArgs} args - Arguments to update or create a Classroom_observation.
     * @example
     * // Update or create a Classroom_observation
     * const classroom_observation = await prisma.classroom_observation.upsert({
     *   create: {
     *     // ... data to create a Classroom_observation
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Classroom_observation we want to update
     *   }
     * })
     */
    upsert<T extends classroom_observationUpsertArgs>(args: SelectSubset<T, classroom_observationUpsertArgs<ExtArgs>>): Prisma__classroom_observationClient<$Result.GetResult<Prisma.$classroom_observationPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Classroom_observations.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_observationCountArgs} args - Arguments to filter Classroom_observations to count.
     * @example
     * // Count the number of Classroom_observations
     * const count = await prisma.classroom_observation.count({
     *   where: {
     *     // ... the filter for the Classroom_observations we want to count
     *   }
     * })
    **/
    count<T extends classroom_observationCountArgs>(
      args?: Subset<T, classroom_observationCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Classroom_observationCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Classroom_observation.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Classroom_observationAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Classroom_observationAggregateArgs>(args: Subset<T, Classroom_observationAggregateArgs>): Prisma.PrismaPromise<GetClassroom_observationAggregateType<T>>

    /**
     * Group by Classroom_observation.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {classroom_observationGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends classroom_observationGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: classroom_observationGroupByArgs['orderBy'] }
        : { orderBy?: classroom_observationGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, classroom_observationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetClassroom_observationGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the classroom_observation model
   */
  readonly fields: classroom_observationFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for classroom_observation.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__classroom_observationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the classroom_observation model
   */ 
  interface classroom_observationFieldRefs {
    readonly id: FieldRef<"classroom_observation", 'String'>
    readonly jsonData: FieldRef<"classroom_observation", 'String'>
    readonly Type: FieldRef<"classroom_observation", 'Int'>
    readonly tIndex: FieldRef<"classroom_observation", 'Int'>
    readonly tId: FieldRef<"classroom_observation", 'String'>
    readonly createtime: FieldRef<"classroom_observation", 'DateTime'>
    readonly like_num: FieldRef<"classroom_observation", 'Int'>
    readonly like_data: FieldRef<"classroom_observation", 'String'>
    readonly userid: FieldRef<"classroom_observation", 'String'>
    readonly isdel: FieldRef<"classroom_observation", 'Int'>
    readonly limitData: FieldRef<"classroom_observation", 'String'>
  }
    

  // Custom InputTypes
  /**
   * classroom_observation findUnique
   */
  export type classroom_observationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_observation
     */
    select?: classroom_observationSelect<ExtArgs> | null
    /**
     * Filter, which classroom_observation to fetch.
     */
    where: classroom_observationWhereUniqueInput
  }

  /**
   * classroom_observation findUniqueOrThrow
   */
  export type classroom_observationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_observation
     */
    select?: classroom_observationSelect<ExtArgs> | null
    /**
     * Filter, which classroom_observation to fetch.
     */
    where: classroom_observationWhereUniqueInput
  }

  /**
   * classroom_observation findFirst
   */
  export type classroom_observationFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_observation
     */
    select?: classroom_observationSelect<ExtArgs> | null
    /**
     * Filter, which classroom_observation to fetch.
     */
    where?: classroom_observationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of classroom_observations to fetch.
     */
    orderBy?: classroom_observationOrderByWithRelationInput | classroom_observationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for classroom_observations.
     */
    cursor?: classroom_observationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` classroom_observations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` classroom_observations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of classroom_observations.
     */
    distinct?: Classroom_observationScalarFieldEnum | Classroom_observationScalarFieldEnum[]
  }

  /**
   * classroom_observation findFirstOrThrow
   */
  export type classroom_observationFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_observation
     */
    select?: classroom_observationSelect<ExtArgs> | null
    /**
     * Filter, which classroom_observation to fetch.
     */
    where?: classroom_observationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of classroom_observations to fetch.
     */
    orderBy?: classroom_observationOrderByWithRelationInput | classroom_observationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for classroom_observations.
     */
    cursor?: classroom_observationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` classroom_observations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` classroom_observations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of classroom_observations.
     */
    distinct?: Classroom_observationScalarFieldEnum | Classroom_observationScalarFieldEnum[]
  }

  /**
   * classroom_observation findMany
   */
  export type classroom_observationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_observation
     */
    select?: classroom_observationSelect<ExtArgs> | null
    /**
     * Filter, which classroom_observations to fetch.
     */
    where?: classroom_observationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of classroom_observations to fetch.
     */
    orderBy?: classroom_observationOrderByWithRelationInput | classroom_observationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing classroom_observations.
     */
    cursor?: classroom_observationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` classroom_observations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` classroom_observations.
     */
    skip?: number
    distinct?: Classroom_observationScalarFieldEnum | Classroom_observationScalarFieldEnum[]
  }

  /**
   * classroom_observation create
   */
  export type classroom_observationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_observation
     */
    select?: classroom_observationSelect<ExtArgs> | null
    /**
     * The data needed to create a classroom_observation.
     */
    data: XOR<classroom_observationCreateInput, classroom_observationUncheckedCreateInput>
  }

  /**
   * classroom_observation createMany
   */
  export type classroom_observationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many classroom_observations.
     */
    data: classroom_observationCreateManyInput | classroom_observationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * classroom_observation update
   */
  export type classroom_observationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_observation
     */
    select?: classroom_observationSelect<ExtArgs> | null
    /**
     * The data needed to update a classroom_observation.
     */
    data: XOR<classroom_observationUpdateInput, classroom_observationUncheckedUpdateInput>
    /**
     * Choose, which classroom_observation to update.
     */
    where: classroom_observationWhereUniqueInput
  }

  /**
   * classroom_observation updateMany
   */
  export type classroom_observationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update classroom_observations.
     */
    data: XOR<classroom_observationUpdateManyMutationInput, classroom_observationUncheckedUpdateManyInput>
    /**
     * Filter which classroom_observations to update
     */
    where?: classroom_observationWhereInput
  }

  /**
   * classroom_observation upsert
   */
  export type classroom_observationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_observation
     */
    select?: classroom_observationSelect<ExtArgs> | null
    /**
     * The filter to search for the classroom_observation to update in case it exists.
     */
    where: classroom_observationWhereUniqueInput
    /**
     * In case the classroom_observation found by the `where` argument doesn't exist, create a new classroom_observation with this data.
     */
    create: XOR<classroom_observationCreateInput, classroom_observationUncheckedCreateInput>
    /**
     * In case the classroom_observation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<classroom_observationUpdateInput, classroom_observationUncheckedUpdateInput>
  }

  /**
   * classroom_observation delete
   */
  export type classroom_observationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_observation
     */
    select?: classroom_observationSelect<ExtArgs> | null
    /**
     * Filter which classroom_observation to delete.
     */
    where: classroom_observationWhereUniqueInput
  }

  /**
   * classroom_observation deleteMany
   */
  export type classroom_observationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which classroom_observations to delete
     */
    where?: classroom_observationWhereInput
  }

  /**
   * classroom_observation without action
   */
  export type classroom_observationDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the classroom_observation
     */
    select?: classroom_observationSelect<ExtArgs> | null
  }


  /**
   * Model course_resource
   */

  export type AggregateCourse_resource = {
    _count: Course_resourceCountAggregateOutputType | null
    _min: Course_resourceMinAggregateOutputType | null
    _max: Course_resourceMaxAggregateOutputType | null
  }

  export type Course_resourceMinAggregateOutputType = {
    id: string | null
    subject: string | null
    grade: string | null
    textbook: string | null
    book_type: string | null
    unit: string | null
    period: string | null
    unit_content: string | null
    course_content: string | null
  }

  export type Course_resourceMaxAggregateOutputType = {
    id: string | null
    subject: string | null
    grade: string | null
    textbook: string | null
    book_type: string | null
    unit: string | null
    period: string | null
    unit_content: string | null
    course_content: string | null
  }

  export type Course_resourceCountAggregateOutputType = {
    id: number
    subject: number
    grade: number
    textbook: number
    book_type: number
    unit: number
    period: number
    unit_content: number
    course_content: number
    _all: number
  }


  export type Course_resourceMinAggregateInputType = {
    id?: true
    subject?: true
    grade?: true
    textbook?: true
    book_type?: true
    unit?: true
    period?: true
    unit_content?: true
    course_content?: true
  }

  export type Course_resourceMaxAggregateInputType = {
    id?: true
    subject?: true
    grade?: true
    textbook?: true
    book_type?: true
    unit?: true
    period?: true
    unit_content?: true
    course_content?: true
  }

  export type Course_resourceCountAggregateInputType = {
    id?: true
    subject?: true
    grade?: true
    textbook?: true
    book_type?: true
    unit?: true
    period?: true
    unit_content?: true
    course_content?: true
    _all?: true
  }

  export type Course_resourceAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which course_resource to aggregate.
     */
    where?: course_resourceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of course_resources to fetch.
     */
    orderBy?: course_resourceOrderByWithRelationInput | course_resourceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: course_resourceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` course_resources from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` course_resources.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned course_resources
    **/
    _count?: true | Course_resourceCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Course_resourceMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Course_resourceMaxAggregateInputType
  }

  export type GetCourse_resourceAggregateType<T extends Course_resourceAggregateArgs> = {
        [P in keyof T & keyof AggregateCourse_resource]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateCourse_resource[P]>
      : GetScalarType<T[P], AggregateCourse_resource[P]>
  }




  export type course_resourceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: course_resourceWhereInput
    orderBy?: course_resourceOrderByWithAggregationInput | course_resourceOrderByWithAggregationInput[]
    by: Course_resourceScalarFieldEnum[] | Course_resourceScalarFieldEnum
    having?: course_resourceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Course_resourceCountAggregateInputType | true
    _min?: Course_resourceMinAggregateInputType
    _max?: Course_resourceMaxAggregateInputType
  }

  export type Course_resourceGroupByOutputType = {
    id: string
    subject: string | null
    grade: string | null
    textbook: string | null
    book_type: string | null
    unit: string | null
    period: string | null
    unit_content: string | null
    course_content: string | null
    _count: Course_resourceCountAggregateOutputType | null
    _min: Course_resourceMinAggregateOutputType | null
    _max: Course_resourceMaxAggregateOutputType | null
  }

  type GetCourse_resourceGroupByPayload<T extends course_resourceGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Course_resourceGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Course_resourceGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Course_resourceGroupByOutputType[P]>
            : GetScalarType<T[P], Course_resourceGroupByOutputType[P]>
        }
      >
    >


  export type course_resourceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    subject?: boolean
    grade?: boolean
    textbook?: boolean
    book_type?: boolean
    unit?: boolean
    period?: boolean
    unit_content?: boolean
    course_content?: boolean
  }, ExtArgs["result"]["course_resource"]>


  export type course_resourceSelectScalar = {
    id?: boolean
    subject?: boolean
    grade?: boolean
    textbook?: boolean
    book_type?: boolean
    unit?: boolean
    period?: boolean
    unit_content?: boolean
    course_content?: boolean
  }


  export type $course_resourcePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "course_resource"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      subject: string | null
      grade: string | null
      textbook: string | null
      book_type: string | null
      unit: string | null
      period: string | null
      unit_content: string | null
      course_content: string | null
    }, ExtArgs["result"]["course_resource"]>
    composites: {}
  }

  type course_resourceGetPayload<S extends boolean | null | undefined | course_resourceDefaultArgs> = $Result.GetResult<Prisma.$course_resourcePayload, S>

  type course_resourceCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<course_resourceFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Course_resourceCountAggregateInputType | true
    }

  export interface course_resourceDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['course_resource'], meta: { name: 'course_resource' } }
    /**
     * Find zero or one Course_resource that matches the filter.
     * @param {course_resourceFindUniqueArgs} args - Arguments to find a Course_resource
     * @example
     * // Get one Course_resource
     * const course_resource = await prisma.course_resource.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends course_resourceFindUniqueArgs>(args: SelectSubset<T, course_resourceFindUniqueArgs<ExtArgs>>): Prisma__course_resourceClient<$Result.GetResult<Prisma.$course_resourcePayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Course_resource that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {course_resourceFindUniqueOrThrowArgs} args - Arguments to find a Course_resource
     * @example
     * // Get one Course_resource
     * const course_resource = await prisma.course_resource.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends course_resourceFindUniqueOrThrowArgs>(args: SelectSubset<T, course_resourceFindUniqueOrThrowArgs<ExtArgs>>): Prisma__course_resourceClient<$Result.GetResult<Prisma.$course_resourcePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Course_resource that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {course_resourceFindFirstArgs} args - Arguments to find a Course_resource
     * @example
     * // Get one Course_resource
     * const course_resource = await prisma.course_resource.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends course_resourceFindFirstArgs>(args?: SelectSubset<T, course_resourceFindFirstArgs<ExtArgs>>): Prisma__course_resourceClient<$Result.GetResult<Prisma.$course_resourcePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Course_resource that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {course_resourceFindFirstOrThrowArgs} args - Arguments to find a Course_resource
     * @example
     * // Get one Course_resource
     * const course_resource = await prisma.course_resource.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends course_resourceFindFirstOrThrowArgs>(args?: SelectSubset<T, course_resourceFindFirstOrThrowArgs<ExtArgs>>): Prisma__course_resourceClient<$Result.GetResult<Prisma.$course_resourcePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Course_resources that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {course_resourceFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Course_resources
     * const course_resources = await prisma.course_resource.findMany()
     * 
     * // Get first 10 Course_resources
     * const course_resources = await prisma.course_resource.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const course_resourceWithIdOnly = await prisma.course_resource.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends course_resourceFindManyArgs>(args?: SelectSubset<T, course_resourceFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$course_resourcePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Course_resource.
     * @param {course_resourceCreateArgs} args - Arguments to create a Course_resource.
     * @example
     * // Create one Course_resource
     * const Course_resource = await prisma.course_resource.create({
     *   data: {
     *     // ... data to create a Course_resource
     *   }
     * })
     * 
     */
    create<T extends course_resourceCreateArgs>(args: SelectSubset<T, course_resourceCreateArgs<ExtArgs>>): Prisma__course_resourceClient<$Result.GetResult<Prisma.$course_resourcePayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Course_resources.
     * @param {course_resourceCreateManyArgs} args - Arguments to create many Course_resources.
     * @example
     * // Create many Course_resources
     * const course_resource = await prisma.course_resource.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends course_resourceCreateManyArgs>(args?: SelectSubset<T, course_resourceCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Course_resource.
     * @param {course_resourceDeleteArgs} args - Arguments to delete one Course_resource.
     * @example
     * // Delete one Course_resource
     * const Course_resource = await prisma.course_resource.delete({
     *   where: {
     *     // ... filter to delete one Course_resource
     *   }
     * })
     * 
     */
    delete<T extends course_resourceDeleteArgs>(args: SelectSubset<T, course_resourceDeleteArgs<ExtArgs>>): Prisma__course_resourceClient<$Result.GetResult<Prisma.$course_resourcePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Course_resource.
     * @param {course_resourceUpdateArgs} args - Arguments to update one Course_resource.
     * @example
     * // Update one Course_resource
     * const course_resource = await prisma.course_resource.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends course_resourceUpdateArgs>(args: SelectSubset<T, course_resourceUpdateArgs<ExtArgs>>): Prisma__course_resourceClient<$Result.GetResult<Prisma.$course_resourcePayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Course_resources.
     * @param {course_resourceDeleteManyArgs} args - Arguments to filter Course_resources to delete.
     * @example
     * // Delete a few Course_resources
     * const { count } = await prisma.course_resource.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends course_resourceDeleteManyArgs>(args?: SelectSubset<T, course_resourceDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Course_resources.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {course_resourceUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Course_resources
     * const course_resource = await prisma.course_resource.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends course_resourceUpdateManyArgs>(args: SelectSubset<T, course_resourceUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Course_resource.
     * @param {course_resourceUpsertArgs} args - Arguments to update or create a Course_resource.
     * @example
     * // Update or create a Course_resource
     * const course_resource = await prisma.course_resource.upsert({
     *   create: {
     *     // ... data to create a Course_resource
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Course_resource we want to update
     *   }
     * })
     */
    upsert<T extends course_resourceUpsertArgs>(args: SelectSubset<T, course_resourceUpsertArgs<ExtArgs>>): Prisma__course_resourceClient<$Result.GetResult<Prisma.$course_resourcePayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Course_resources.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {course_resourceCountArgs} args - Arguments to filter Course_resources to count.
     * @example
     * // Count the number of Course_resources
     * const count = await prisma.course_resource.count({
     *   where: {
     *     // ... the filter for the Course_resources we want to count
     *   }
     * })
    **/
    count<T extends course_resourceCountArgs>(
      args?: Subset<T, course_resourceCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Course_resourceCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Course_resource.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Course_resourceAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Course_resourceAggregateArgs>(args: Subset<T, Course_resourceAggregateArgs>): Prisma.PrismaPromise<GetCourse_resourceAggregateType<T>>

    /**
     * Group by Course_resource.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {course_resourceGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends course_resourceGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: course_resourceGroupByArgs['orderBy'] }
        : { orderBy?: course_resourceGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, course_resourceGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCourse_resourceGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the course_resource model
   */
  readonly fields: course_resourceFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for course_resource.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__course_resourceClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the course_resource model
   */ 
  interface course_resourceFieldRefs {
    readonly id: FieldRef<"course_resource", 'String'>
    readonly subject: FieldRef<"course_resource", 'String'>
    readonly grade: FieldRef<"course_resource", 'String'>
    readonly textbook: FieldRef<"course_resource", 'String'>
    readonly book_type: FieldRef<"course_resource", 'String'>
    readonly unit: FieldRef<"course_resource", 'String'>
    readonly period: FieldRef<"course_resource", 'String'>
    readonly unit_content: FieldRef<"course_resource", 'String'>
    readonly course_content: FieldRef<"course_resource", 'String'>
  }
    

  // Custom InputTypes
  /**
   * course_resource findUnique
   */
  export type course_resourceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the course_resource
     */
    select?: course_resourceSelect<ExtArgs> | null
    /**
     * Filter, which course_resource to fetch.
     */
    where: course_resourceWhereUniqueInput
  }

  /**
   * course_resource findUniqueOrThrow
   */
  export type course_resourceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the course_resource
     */
    select?: course_resourceSelect<ExtArgs> | null
    /**
     * Filter, which course_resource to fetch.
     */
    where: course_resourceWhereUniqueInput
  }

  /**
   * course_resource findFirst
   */
  export type course_resourceFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the course_resource
     */
    select?: course_resourceSelect<ExtArgs> | null
    /**
     * Filter, which course_resource to fetch.
     */
    where?: course_resourceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of course_resources to fetch.
     */
    orderBy?: course_resourceOrderByWithRelationInput | course_resourceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for course_resources.
     */
    cursor?: course_resourceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` course_resources from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` course_resources.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of course_resources.
     */
    distinct?: Course_resourceScalarFieldEnum | Course_resourceScalarFieldEnum[]
  }

  /**
   * course_resource findFirstOrThrow
   */
  export type course_resourceFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the course_resource
     */
    select?: course_resourceSelect<ExtArgs> | null
    /**
     * Filter, which course_resource to fetch.
     */
    where?: course_resourceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of course_resources to fetch.
     */
    orderBy?: course_resourceOrderByWithRelationInput | course_resourceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for course_resources.
     */
    cursor?: course_resourceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` course_resources from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` course_resources.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of course_resources.
     */
    distinct?: Course_resourceScalarFieldEnum | Course_resourceScalarFieldEnum[]
  }

  /**
   * course_resource findMany
   */
  export type course_resourceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the course_resource
     */
    select?: course_resourceSelect<ExtArgs> | null
    /**
     * Filter, which course_resources to fetch.
     */
    where?: course_resourceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of course_resources to fetch.
     */
    orderBy?: course_resourceOrderByWithRelationInput | course_resourceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing course_resources.
     */
    cursor?: course_resourceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` course_resources from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` course_resources.
     */
    skip?: number
    distinct?: Course_resourceScalarFieldEnum | Course_resourceScalarFieldEnum[]
  }

  /**
   * course_resource create
   */
  export type course_resourceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the course_resource
     */
    select?: course_resourceSelect<ExtArgs> | null
    /**
     * The data needed to create a course_resource.
     */
    data: XOR<course_resourceCreateInput, course_resourceUncheckedCreateInput>
  }

  /**
   * course_resource createMany
   */
  export type course_resourceCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many course_resources.
     */
    data: course_resourceCreateManyInput | course_resourceCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * course_resource update
   */
  export type course_resourceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the course_resource
     */
    select?: course_resourceSelect<ExtArgs> | null
    /**
     * The data needed to update a course_resource.
     */
    data: XOR<course_resourceUpdateInput, course_resourceUncheckedUpdateInput>
    /**
     * Choose, which course_resource to update.
     */
    where: course_resourceWhereUniqueInput
  }

  /**
   * course_resource updateMany
   */
  export type course_resourceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update course_resources.
     */
    data: XOR<course_resourceUpdateManyMutationInput, course_resourceUncheckedUpdateManyInput>
    /**
     * Filter which course_resources to update
     */
    where?: course_resourceWhereInput
  }

  /**
   * course_resource upsert
   */
  export type course_resourceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the course_resource
     */
    select?: course_resourceSelect<ExtArgs> | null
    /**
     * The filter to search for the course_resource to update in case it exists.
     */
    where: course_resourceWhereUniqueInput
    /**
     * In case the course_resource found by the `where` argument doesn't exist, create a new course_resource with this data.
     */
    create: XOR<course_resourceCreateInput, course_resourceUncheckedCreateInput>
    /**
     * In case the course_resource was found with the provided `where` argument, update it with this data.
     */
    update: XOR<course_resourceUpdateInput, course_resourceUncheckedUpdateInput>
  }

  /**
   * course_resource delete
   */
  export type course_resourceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the course_resource
     */
    select?: course_resourceSelect<ExtArgs> | null
    /**
     * Filter which course_resource to delete.
     */
    where: course_resourceWhereUniqueInput
  }

  /**
   * course_resource deleteMany
   */
  export type course_resourceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which course_resources to delete
     */
    where?: course_resourceWhereInput
  }

  /**
   * course_resource without action
   */
  export type course_resourceDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the course_resource
     */
    select?: course_resourceSelect<ExtArgs> | null
  }


  /**
   * Model knowledge_construction_doc
   */

  export type AggregateKnowledge_construction_doc = {
    _count: Knowledge_construction_docCountAggregateOutputType | null
    _min: Knowledge_construction_docMinAggregateOutputType | null
    _max: Knowledge_construction_docMaxAggregateOutputType | null
  }

  export type Knowledge_construction_docMinAggregateOutputType = {
    id: string | null
    muti_id: string | null
    user_id: string | null
    session_id: string | null
    content: string | null
    create_time: Date | null
  }

  export type Knowledge_construction_docMaxAggregateOutputType = {
    id: string | null
    muti_id: string | null
    user_id: string | null
    session_id: string | null
    content: string | null
    create_time: Date | null
  }

  export type Knowledge_construction_docCountAggregateOutputType = {
    id: number
    muti_id: number
    user_id: number
    session_id: number
    content: number
    create_time: number
    _all: number
  }


  export type Knowledge_construction_docMinAggregateInputType = {
    id?: true
    muti_id?: true
    user_id?: true
    session_id?: true
    content?: true
    create_time?: true
  }

  export type Knowledge_construction_docMaxAggregateInputType = {
    id?: true
    muti_id?: true
    user_id?: true
    session_id?: true
    content?: true
    create_time?: true
  }

  export type Knowledge_construction_docCountAggregateInputType = {
    id?: true
    muti_id?: true
    user_id?: true
    session_id?: true
    content?: true
    create_time?: true
    _all?: true
  }

  export type Knowledge_construction_docAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which knowledge_construction_doc to aggregate.
     */
    where?: knowledge_construction_docWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of knowledge_construction_docs to fetch.
     */
    orderBy?: knowledge_construction_docOrderByWithRelationInput | knowledge_construction_docOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: knowledge_construction_docWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` knowledge_construction_docs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` knowledge_construction_docs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned knowledge_construction_docs
    **/
    _count?: true | Knowledge_construction_docCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Knowledge_construction_docMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Knowledge_construction_docMaxAggregateInputType
  }

  export type GetKnowledge_construction_docAggregateType<T extends Knowledge_construction_docAggregateArgs> = {
        [P in keyof T & keyof AggregateKnowledge_construction_doc]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateKnowledge_construction_doc[P]>
      : GetScalarType<T[P], AggregateKnowledge_construction_doc[P]>
  }




  export type knowledge_construction_docGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: knowledge_construction_docWhereInput
    orderBy?: knowledge_construction_docOrderByWithAggregationInput | knowledge_construction_docOrderByWithAggregationInput[]
    by: Knowledge_construction_docScalarFieldEnum[] | Knowledge_construction_docScalarFieldEnum
    having?: knowledge_construction_docScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Knowledge_construction_docCountAggregateInputType | true
    _min?: Knowledge_construction_docMinAggregateInputType
    _max?: Knowledge_construction_docMaxAggregateInputType
  }

  export type Knowledge_construction_docGroupByOutputType = {
    id: string
    muti_id: string | null
    user_id: string | null
    session_id: string | null
    content: string | null
    create_time: Date | null
    _count: Knowledge_construction_docCountAggregateOutputType | null
    _min: Knowledge_construction_docMinAggregateOutputType | null
    _max: Knowledge_construction_docMaxAggregateOutputType | null
  }

  type GetKnowledge_construction_docGroupByPayload<T extends knowledge_construction_docGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Knowledge_construction_docGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Knowledge_construction_docGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Knowledge_construction_docGroupByOutputType[P]>
            : GetScalarType<T[P], Knowledge_construction_docGroupByOutputType[P]>
        }
      >
    >


  export type knowledge_construction_docSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    muti_id?: boolean
    user_id?: boolean
    session_id?: boolean
    content?: boolean
    create_time?: boolean
  }, ExtArgs["result"]["knowledge_construction_doc"]>


  export type knowledge_construction_docSelectScalar = {
    id?: boolean
    muti_id?: boolean
    user_id?: boolean
    session_id?: boolean
    content?: boolean
    create_time?: boolean
  }


  export type $knowledge_construction_docPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "knowledge_construction_doc"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      muti_id: string | null
      user_id: string | null
      session_id: string | null
      content: string | null
      create_time: Date | null
    }, ExtArgs["result"]["knowledge_construction_doc"]>
    composites: {}
  }

  type knowledge_construction_docGetPayload<S extends boolean | null | undefined | knowledge_construction_docDefaultArgs> = $Result.GetResult<Prisma.$knowledge_construction_docPayload, S>

  type knowledge_construction_docCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<knowledge_construction_docFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Knowledge_construction_docCountAggregateInputType | true
    }

  export interface knowledge_construction_docDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['knowledge_construction_doc'], meta: { name: 'knowledge_construction_doc' } }
    /**
     * Find zero or one Knowledge_construction_doc that matches the filter.
     * @param {knowledge_construction_docFindUniqueArgs} args - Arguments to find a Knowledge_construction_doc
     * @example
     * // Get one Knowledge_construction_doc
     * const knowledge_construction_doc = await prisma.knowledge_construction_doc.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends knowledge_construction_docFindUniqueArgs>(args: SelectSubset<T, knowledge_construction_docFindUniqueArgs<ExtArgs>>): Prisma__knowledge_construction_docClient<$Result.GetResult<Prisma.$knowledge_construction_docPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Knowledge_construction_doc that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {knowledge_construction_docFindUniqueOrThrowArgs} args - Arguments to find a Knowledge_construction_doc
     * @example
     * // Get one Knowledge_construction_doc
     * const knowledge_construction_doc = await prisma.knowledge_construction_doc.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends knowledge_construction_docFindUniqueOrThrowArgs>(args: SelectSubset<T, knowledge_construction_docFindUniqueOrThrowArgs<ExtArgs>>): Prisma__knowledge_construction_docClient<$Result.GetResult<Prisma.$knowledge_construction_docPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Knowledge_construction_doc that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {knowledge_construction_docFindFirstArgs} args - Arguments to find a Knowledge_construction_doc
     * @example
     * // Get one Knowledge_construction_doc
     * const knowledge_construction_doc = await prisma.knowledge_construction_doc.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends knowledge_construction_docFindFirstArgs>(args?: SelectSubset<T, knowledge_construction_docFindFirstArgs<ExtArgs>>): Prisma__knowledge_construction_docClient<$Result.GetResult<Prisma.$knowledge_construction_docPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Knowledge_construction_doc that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {knowledge_construction_docFindFirstOrThrowArgs} args - Arguments to find a Knowledge_construction_doc
     * @example
     * // Get one Knowledge_construction_doc
     * const knowledge_construction_doc = await prisma.knowledge_construction_doc.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends knowledge_construction_docFindFirstOrThrowArgs>(args?: SelectSubset<T, knowledge_construction_docFindFirstOrThrowArgs<ExtArgs>>): Prisma__knowledge_construction_docClient<$Result.GetResult<Prisma.$knowledge_construction_docPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Knowledge_construction_docs that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {knowledge_construction_docFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Knowledge_construction_docs
     * const knowledge_construction_docs = await prisma.knowledge_construction_doc.findMany()
     * 
     * // Get first 10 Knowledge_construction_docs
     * const knowledge_construction_docs = await prisma.knowledge_construction_doc.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const knowledge_construction_docWithIdOnly = await prisma.knowledge_construction_doc.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends knowledge_construction_docFindManyArgs>(args?: SelectSubset<T, knowledge_construction_docFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$knowledge_construction_docPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Knowledge_construction_doc.
     * @param {knowledge_construction_docCreateArgs} args - Arguments to create a Knowledge_construction_doc.
     * @example
     * // Create one Knowledge_construction_doc
     * const Knowledge_construction_doc = await prisma.knowledge_construction_doc.create({
     *   data: {
     *     // ... data to create a Knowledge_construction_doc
     *   }
     * })
     * 
     */
    create<T extends knowledge_construction_docCreateArgs>(args: SelectSubset<T, knowledge_construction_docCreateArgs<ExtArgs>>): Prisma__knowledge_construction_docClient<$Result.GetResult<Prisma.$knowledge_construction_docPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Knowledge_construction_docs.
     * @param {knowledge_construction_docCreateManyArgs} args - Arguments to create many Knowledge_construction_docs.
     * @example
     * // Create many Knowledge_construction_docs
     * const knowledge_construction_doc = await prisma.knowledge_construction_doc.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends knowledge_construction_docCreateManyArgs>(args?: SelectSubset<T, knowledge_construction_docCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Knowledge_construction_doc.
     * @param {knowledge_construction_docDeleteArgs} args - Arguments to delete one Knowledge_construction_doc.
     * @example
     * // Delete one Knowledge_construction_doc
     * const Knowledge_construction_doc = await prisma.knowledge_construction_doc.delete({
     *   where: {
     *     // ... filter to delete one Knowledge_construction_doc
     *   }
     * })
     * 
     */
    delete<T extends knowledge_construction_docDeleteArgs>(args: SelectSubset<T, knowledge_construction_docDeleteArgs<ExtArgs>>): Prisma__knowledge_construction_docClient<$Result.GetResult<Prisma.$knowledge_construction_docPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Knowledge_construction_doc.
     * @param {knowledge_construction_docUpdateArgs} args - Arguments to update one Knowledge_construction_doc.
     * @example
     * // Update one Knowledge_construction_doc
     * const knowledge_construction_doc = await prisma.knowledge_construction_doc.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends knowledge_construction_docUpdateArgs>(args: SelectSubset<T, knowledge_construction_docUpdateArgs<ExtArgs>>): Prisma__knowledge_construction_docClient<$Result.GetResult<Prisma.$knowledge_construction_docPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Knowledge_construction_docs.
     * @param {knowledge_construction_docDeleteManyArgs} args - Arguments to filter Knowledge_construction_docs to delete.
     * @example
     * // Delete a few Knowledge_construction_docs
     * const { count } = await prisma.knowledge_construction_doc.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends knowledge_construction_docDeleteManyArgs>(args?: SelectSubset<T, knowledge_construction_docDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Knowledge_construction_docs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {knowledge_construction_docUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Knowledge_construction_docs
     * const knowledge_construction_doc = await prisma.knowledge_construction_doc.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends knowledge_construction_docUpdateManyArgs>(args: SelectSubset<T, knowledge_construction_docUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Knowledge_construction_doc.
     * @param {knowledge_construction_docUpsertArgs} args - Arguments to update or create a Knowledge_construction_doc.
     * @example
     * // Update or create a Knowledge_construction_doc
     * const knowledge_construction_doc = await prisma.knowledge_construction_doc.upsert({
     *   create: {
     *     // ... data to create a Knowledge_construction_doc
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Knowledge_construction_doc we want to update
     *   }
     * })
     */
    upsert<T extends knowledge_construction_docUpsertArgs>(args: SelectSubset<T, knowledge_construction_docUpsertArgs<ExtArgs>>): Prisma__knowledge_construction_docClient<$Result.GetResult<Prisma.$knowledge_construction_docPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Knowledge_construction_docs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {knowledge_construction_docCountArgs} args - Arguments to filter Knowledge_construction_docs to count.
     * @example
     * // Count the number of Knowledge_construction_docs
     * const count = await prisma.knowledge_construction_doc.count({
     *   where: {
     *     // ... the filter for the Knowledge_construction_docs we want to count
     *   }
     * })
    **/
    count<T extends knowledge_construction_docCountArgs>(
      args?: Subset<T, knowledge_construction_docCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Knowledge_construction_docCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Knowledge_construction_doc.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Knowledge_construction_docAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Knowledge_construction_docAggregateArgs>(args: Subset<T, Knowledge_construction_docAggregateArgs>): Prisma.PrismaPromise<GetKnowledge_construction_docAggregateType<T>>

    /**
     * Group by Knowledge_construction_doc.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {knowledge_construction_docGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends knowledge_construction_docGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: knowledge_construction_docGroupByArgs['orderBy'] }
        : { orderBy?: knowledge_construction_docGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, knowledge_construction_docGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetKnowledge_construction_docGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the knowledge_construction_doc model
   */
  readonly fields: knowledge_construction_docFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for knowledge_construction_doc.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__knowledge_construction_docClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the knowledge_construction_doc model
   */ 
  interface knowledge_construction_docFieldRefs {
    readonly id: FieldRef<"knowledge_construction_doc", 'String'>
    readonly muti_id: FieldRef<"knowledge_construction_doc", 'String'>
    readonly user_id: FieldRef<"knowledge_construction_doc", 'String'>
    readonly session_id: FieldRef<"knowledge_construction_doc", 'String'>
    readonly content: FieldRef<"knowledge_construction_doc", 'String'>
    readonly create_time: FieldRef<"knowledge_construction_doc", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * knowledge_construction_doc findUnique
   */
  export type knowledge_construction_docFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the knowledge_construction_doc
     */
    select?: knowledge_construction_docSelect<ExtArgs> | null
    /**
     * Filter, which knowledge_construction_doc to fetch.
     */
    where: knowledge_construction_docWhereUniqueInput
  }

  /**
   * knowledge_construction_doc findUniqueOrThrow
   */
  export type knowledge_construction_docFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the knowledge_construction_doc
     */
    select?: knowledge_construction_docSelect<ExtArgs> | null
    /**
     * Filter, which knowledge_construction_doc to fetch.
     */
    where: knowledge_construction_docWhereUniqueInput
  }

  /**
   * knowledge_construction_doc findFirst
   */
  export type knowledge_construction_docFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the knowledge_construction_doc
     */
    select?: knowledge_construction_docSelect<ExtArgs> | null
    /**
     * Filter, which knowledge_construction_doc to fetch.
     */
    where?: knowledge_construction_docWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of knowledge_construction_docs to fetch.
     */
    orderBy?: knowledge_construction_docOrderByWithRelationInput | knowledge_construction_docOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for knowledge_construction_docs.
     */
    cursor?: knowledge_construction_docWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` knowledge_construction_docs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` knowledge_construction_docs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of knowledge_construction_docs.
     */
    distinct?: Knowledge_construction_docScalarFieldEnum | Knowledge_construction_docScalarFieldEnum[]
  }

  /**
   * knowledge_construction_doc findFirstOrThrow
   */
  export type knowledge_construction_docFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the knowledge_construction_doc
     */
    select?: knowledge_construction_docSelect<ExtArgs> | null
    /**
     * Filter, which knowledge_construction_doc to fetch.
     */
    where?: knowledge_construction_docWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of knowledge_construction_docs to fetch.
     */
    orderBy?: knowledge_construction_docOrderByWithRelationInput | knowledge_construction_docOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for knowledge_construction_docs.
     */
    cursor?: knowledge_construction_docWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` knowledge_construction_docs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` knowledge_construction_docs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of knowledge_construction_docs.
     */
    distinct?: Knowledge_construction_docScalarFieldEnum | Knowledge_construction_docScalarFieldEnum[]
  }

  /**
   * knowledge_construction_doc findMany
   */
  export type knowledge_construction_docFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the knowledge_construction_doc
     */
    select?: knowledge_construction_docSelect<ExtArgs> | null
    /**
     * Filter, which knowledge_construction_docs to fetch.
     */
    where?: knowledge_construction_docWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of knowledge_construction_docs to fetch.
     */
    orderBy?: knowledge_construction_docOrderByWithRelationInput | knowledge_construction_docOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing knowledge_construction_docs.
     */
    cursor?: knowledge_construction_docWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` knowledge_construction_docs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` knowledge_construction_docs.
     */
    skip?: number
    distinct?: Knowledge_construction_docScalarFieldEnum | Knowledge_construction_docScalarFieldEnum[]
  }

  /**
   * knowledge_construction_doc create
   */
  export type knowledge_construction_docCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the knowledge_construction_doc
     */
    select?: knowledge_construction_docSelect<ExtArgs> | null
    /**
     * The data needed to create a knowledge_construction_doc.
     */
    data: XOR<knowledge_construction_docCreateInput, knowledge_construction_docUncheckedCreateInput>
  }

  /**
   * knowledge_construction_doc createMany
   */
  export type knowledge_construction_docCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many knowledge_construction_docs.
     */
    data: knowledge_construction_docCreateManyInput | knowledge_construction_docCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * knowledge_construction_doc update
   */
  export type knowledge_construction_docUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the knowledge_construction_doc
     */
    select?: knowledge_construction_docSelect<ExtArgs> | null
    /**
     * The data needed to update a knowledge_construction_doc.
     */
    data: XOR<knowledge_construction_docUpdateInput, knowledge_construction_docUncheckedUpdateInput>
    /**
     * Choose, which knowledge_construction_doc to update.
     */
    where: knowledge_construction_docWhereUniqueInput
  }

  /**
   * knowledge_construction_doc updateMany
   */
  export type knowledge_construction_docUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update knowledge_construction_docs.
     */
    data: XOR<knowledge_construction_docUpdateManyMutationInput, knowledge_construction_docUncheckedUpdateManyInput>
    /**
     * Filter which knowledge_construction_docs to update
     */
    where?: knowledge_construction_docWhereInput
  }

  /**
   * knowledge_construction_doc upsert
   */
  export type knowledge_construction_docUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the knowledge_construction_doc
     */
    select?: knowledge_construction_docSelect<ExtArgs> | null
    /**
     * The filter to search for the knowledge_construction_doc to update in case it exists.
     */
    where: knowledge_construction_docWhereUniqueInput
    /**
     * In case the knowledge_construction_doc found by the `where` argument doesn't exist, create a new knowledge_construction_doc with this data.
     */
    create: XOR<knowledge_construction_docCreateInput, knowledge_construction_docUncheckedCreateInput>
    /**
     * In case the knowledge_construction_doc was found with the provided `where` argument, update it with this data.
     */
    update: XOR<knowledge_construction_docUpdateInput, knowledge_construction_docUncheckedUpdateInput>
  }

  /**
   * knowledge_construction_doc delete
   */
  export type knowledge_construction_docDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the knowledge_construction_doc
     */
    select?: knowledge_construction_docSelect<ExtArgs> | null
    /**
     * Filter which knowledge_construction_doc to delete.
     */
    where: knowledge_construction_docWhereUniqueInput
  }

  /**
   * knowledge_construction_doc deleteMany
   */
  export type knowledge_construction_docDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which knowledge_construction_docs to delete
     */
    where?: knowledge_construction_docWhereInput
  }

  /**
   * knowledge_construction_doc without action
   */
  export type knowledge_construction_docDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the knowledge_construction_doc
     */
    select?: knowledge_construction_docSelect<ExtArgs> | null
  }


  /**
   * Model meeting_trick
   */

  export type AggregateMeeting_trick = {
    _count: Meeting_trickCountAggregateOutputType | null
    _min: Meeting_trickMinAggregateOutputType | null
    _max: Meeting_trickMaxAggregateOutputType | null
  }

  export type Meeting_trickMinAggregateOutputType = {
    id: string | null
    createtime: Date | null
    userid: string | null
    meeting_name: string | null
    meeting_original: string | null
    meeting_minutes: string | null
    audio_url: string | null
    duration: string | null
    ab: string | null
  }

  export type Meeting_trickMaxAggregateOutputType = {
    id: string | null
    createtime: Date | null
    userid: string | null
    meeting_name: string | null
    meeting_original: string | null
    meeting_minutes: string | null
    audio_url: string | null
    duration: string | null
    ab: string | null
  }

  export type Meeting_trickCountAggregateOutputType = {
    id: number
    createtime: number
    userid: number
    meeting_name: number
    meeting_original: number
    meeting_minutes: number
    audio_url: number
    duration: number
    ab: number
    _all: number
  }


  export type Meeting_trickMinAggregateInputType = {
    id?: true
    createtime?: true
    userid?: true
    meeting_name?: true
    meeting_original?: true
    meeting_minutes?: true
    audio_url?: true
    duration?: true
    ab?: true
  }

  export type Meeting_trickMaxAggregateInputType = {
    id?: true
    createtime?: true
    userid?: true
    meeting_name?: true
    meeting_original?: true
    meeting_minutes?: true
    audio_url?: true
    duration?: true
    ab?: true
  }

  export type Meeting_trickCountAggregateInputType = {
    id?: true
    createtime?: true
    userid?: true
    meeting_name?: true
    meeting_original?: true
    meeting_minutes?: true
    audio_url?: true
    duration?: true
    ab?: true
    _all?: true
  }

  export type Meeting_trickAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which meeting_trick to aggregate.
     */
    where?: meeting_trickWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of meeting_tricks to fetch.
     */
    orderBy?: meeting_trickOrderByWithRelationInput | meeting_trickOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: meeting_trickWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` meeting_tricks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` meeting_tricks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned meeting_tricks
    **/
    _count?: true | Meeting_trickCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Meeting_trickMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Meeting_trickMaxAggregateInputType
  }

  export type GetMeeting_trickAggregateType<T extends Meeting_trickAggregateArgs> = {
        [P in keyof T & keyof AggregateMeeting_trick]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMeeting_trick[P]>
      : GetScalarType<T[P], AggregateMeeting_trick[P]>
  }




  export type meeting_trickGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: meeting_trickWhereInput
    orderBy?: meeting_trickOrderByWithAggregationInput | meeting_trickOrderByWithAggregationInput[]
    by: Meeting_trickScalarFieldEnum[] | Meeting_trickScalarFieldEnum
    having?: meeting_trickScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Meeting_trickCountAggregateInputType | true
    _min?: Meeting_trickMinAggregateInputType
    _max?: Meeting_trickMaxAggregateInputType
  }

  export type Meeting_trickGroupByOutputType = {
    id: string
    createtime: Date | null
    userid: string | null
    meeting_name: string | null
    meeting_original: string | null
    meeting_minutes: string | null
    audio_url: string | null
    duration: string | null
    ab: string | null
    _count: Meeting_trickCountAggregateOutputType | null
    _min: Meeting_trickMinAggregateOutputType | null
    _max: Meeting_trickMaxAggregateOutputType | null
  }

  type GetMeeting_trickGroupByPayload<T extends meeting_trickGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Meeting_trickGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Meeting_trickGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Meeting_trickGroupByOutputType[P]>
            : GetScalarType<T[P], Meeting_trickGroupByOutputType[P]>
        }
      >
    >


  export type meeting_trickSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    createtime?: boolean
    userid?: boolean
    meeting_name?: boolean
    meeting_original?: boolean
    meeting_minutes?: boolean
    audio_url?: boolean
    duration?: boolean
    ab?: boolean
  }, ExtArgs["result"]["meeting_trick"]>


  export type meeting_trickSelectScalar = {
    id?: boolean
    createtime?: boolean
    userid?: boolean
    meeting_name?: boolean
    meeting_original?: boolean
    meeting_minutes?: boolean
    audio_url?: boolean
    duration?: boolean
    ab?: boolean
  }


  export type $meeting_trickPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "meeting_trick"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      createtime: Date | null
      userid: string | null
      meeting_name: string | null
      meeting_original: string | null
      meeting_minutes: string | null
      audio_url: string | null
      duration: string | null
      ab: string | null
    }, ExtArgs["result"]["meeting_trick"]>
    composites: {}
  }

  type meeting_trickGetPayload<S extends boolean | null | undefined | meeting_trickDefaultArgs> = $Result.GetResult<Prisma.$meeting_trickPayload, S>

  type meeting_trickCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<meeting_trickFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Meeting_trickCountAggregateInputType | true
    }

  export interface meeting_trickDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['meeting_trick'], meta: { name: 'meeting_trick' } }
    /**
     * Find zero or one Meeting_trick that matches the filter.
     * @param {meeting_trickFindUniqueArgs} args - Arguments to find a Meeting_trick
     * @example
     * // Get one Meeting_trick
     * const meeting_trick = await prisma.meeting_trick.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends meeting_trickFindUniqueArgs>(args: SelectSubset<T, meeting_trickFindUniqueArgs<ExtArgs>>): Prisma__meeting_trickClient<$Result.GetResult<Prisma.$meeting_trickPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Meeting_trick that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {meeting_trickFindUniqueOrThrowArgs} args - Arguments to find a Meeting_trick
     * @example
     * // Get one Meeting_trick
     * const meeting_trick = await prisma.meeting_trick.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends meeting_trickFindUniqueOrThrowArgs>(args: SelectSubset<T, meeting_trickFindUniqueOrThrowArgs<ExtArgs>>): Prisma__meeting_trickClient<$Result.GetResult<Prisma.$meeting_trickPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Meeting_trick that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trickFindFirstArgs} args - Arguments to find a Meeting_trick
     * @example
     * // Get one Meeting_trick
     * const meeting_trick = await prisma.meeting_trick.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends meeting_trickFindFirstArgs>(args?: SelectSubset<T, meeting_trickFindFirstArgs<ExtArgs>>): Prisma__meeting_trickClient<$Result.GetResult<Prisma.$meeting_trickPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Meeting_trick that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trickFindFirstOrThrowArgs} args - Arguments to find a Meeting_trick
     * @example
     * // Get one Meeting_trick
     * const meeting_trick = await prisma.meeting_trick.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends meeting_trickFindFirstOrThrowArgs>(args?: SelectSubset<T, meeting_trickFindFirstOrThrowArgs<ExtArgs>>): Prisma__meeting_trickClient<$Result.GetResult<Prisma.$meeting_trickPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Meeting_tricks that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trickFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Meeting_tricks
     * const meeting_tricks = await prisma.meeting_trick.findMany()
     * 
     * // Get first 10 Meeting_tricks
     * const meeting_tricks = await prisma.meeting_trick.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const meeting_trickWithIdOnly = await prisma.meeting_trick.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends meeting_trickFindManyArgs>(args?: SelectSubset<T, meeting_trickFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$meeting_trickPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Meeting_trick.
     * @param {meeting_trickCreateArgs} args - Arguments to create a Meeting_trick.
     * @example
     * // Create one Meeting_trick
     * const Meeting_trick = await prisma.meeting_trick.create({
     *   data: {
     *     // ... data to create a Meeting_trick
     *   }
     * })
     * 
     */
    create<T extends meeting_trickCreateArgs>(args: SelectSubset<T, meeting_trickCreateArgs<ExtArgs>>): Prisma__meeting_trickClient<$Result.GetResult<Prisma.$meeting_trickPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Meeting_tricks.
     * @param {meeting_trickCreateManyArgs} args - Arguments to create many Meeting_tricks.
     * @example
     * // Create many Meeting_tricks
     * const meeting_trick = await prisma.meeting_trick.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends meeting_trickCreateManyArgs>(args?: SelectSubset<T, meeting_trickCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Meeting_trick.
     * @param {meeting_trickDeleteArgs} args - Arguments to delete one Meeting_trick.
     * @example
     * // Delete one Meeting_trick
     * const Meeting_trick = await prisma.meeting_trick.delete({
     *   where: {
     *     // ... filter to delete one Meeting_trick
     *   }
     * })
     * 
     */
    delete<T extends meeting_trickDeleteArgs>(args: SelectSubset<T, meeting_trickDeleteArgs<ExtArgs>>): Prisma__meeting_trickClient<$Result.GetResult<Prisma.$meeting_trickPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Meeting_trick.
     * @param {meeting_trickUpdateArgs} args - Arguments to update one Meeting_trick.
     * @example
     * // Update one Meeting_trick
     * const meeting_trick = await prisma.meeting_trick.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends meeting_trickUpdateArgs>(args: SelectSubset<T, meeting_trickUpdateArgs<ExtArgs>>): Prisma__meeting_trickClient<$Result.GetResult<Prisma.$meeting_trickPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Meeting_tricks.
     * @param {meeting_trickDeleteManyArgs} args - Arguments to filter Meeting_tricks to delete.
     * @example
     * // Delete a few Meeting_tricks
     * const { count } = await prisma.meeting_trick.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends meeting_trickDeleteManyArgs>(args?: SelectSubset<T, meeting_trickDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Meeting_tricks.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trickUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Meeting_tricks
     * const meeting_trick = await prisma.meeting_trick.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends meeting_trickUpdateManyArgs>(args: SelectSubset<T, meeting_trickUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Meeting_trick.
     * @param {meeting_trickUpsertArgs} args - Arguments to update or create a Meeting_trick.
     * @example
     * // Update or create a Meeting_trick
     * const meeting_trick = await prisma.meeting_trick.upsert({
     *   create: {
     *     // ... data to create a Meeting_trick
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Meeting_trick we want to update
     *   }
     * })
     */
    upsert<T extends meeting_trickUpsertArgs>(args: SelectSubset<T, meeting_trickUpsertArgs<ExtArgs>>): Prisma__meeting_trickClient<$Result.GetResult<Prisma.$meeting_trickPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Meeting_tricks.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trickCountArgs} args - Arguments to filter Meeting_tricks to count.
     * @example
     * // Count the number of Meeting_tricks
     * const count = await prisma.meeting_trick.count({
     *   where: {
     *     // ... the filter for the Meeting_tricks we want to count
     *   }
     * })
    **/
    count<T extends meeting_trickCountArgs>(
      args?: Subset<T, meeting_trickCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Meeting_trickCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Meeting_trick.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Meeting_trickAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Meeting_trickAggregateArgs>(args: Subset<T, Meeting_trickAggregateArgs>): Prisma.PrismaPromise<GetMeeting_trickAggregateType<T>>

    /**
     * Group by Meeting_trick.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trickGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends meeting_trickGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: meeting_trickGroupByArgs['orderBy'] }
        : { orderBy?: meeting_trickGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, meeting_trickGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMeeting_trickGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the meeting_trick model
   */
  readonly fields: meeting_trickFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for meeting_trick.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__meeting_trickClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the meeting_trick model
   */ 
  interface meeting_trickFieldRefs {
    readonly id: FieldRef<"meeting_trick", 'String'>
    readonly createtime: FieldRef<"meeting_trick", 'DateTime'>
    readonly userid: FieldRef<"meeting_trick", 'String'>
    readonly meeting_name: FieldRef<"meeting_trick", 'String'>
    readonly meeting_original: FieldRef<"meeting_trick", 'String'>
    readonly meeting_minutes: FieldRef<"meeting_trick", 'String'>
    readonly audio_url: FieldRef<"meeting_trick", 'String'>
    readonly duration: FieldRef<"meeting_trick", 'String'>
    readonly ab: FieldRef<"meeting_trick", 'String'>
  }
    

  // Custom InputTypes
  /**
   * meeting_trick findUnique
   */
  export type meeting_trickFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick
     */
    select?: meeting_trickSelect<ExtArgs> | null
    /**
     * Filter, which meeting_trick to fetch.
     */
    where: meeting_trickWhereUniqueInput
  }

  /**
   * meeting_trick findUniqueOrThrow
   */
  export type meeting_trickFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick
     */
    select?: meeting_trickSelect<ExtArgs> | null
    /**
     * Filter, which meeting_trick to fetch.
     */
    where: meeting_trickWhereUniqueInput
  }

  /**
   * meeting_trick findFirst
   */
  export type meeting_trickFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick
     */
    select?: meeting_trickSelect<ExtArgs> | null
    /**
     * Filter, which meeting_trick to fetch.
     */
    where?: meeting_trickWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of meeting_tricks to fetch.
     */
    orderBy?: meeting_trickOrderByWithRelationInput | meeting_trickOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for meeting_tricks.
     */
    cursor?: meeting_trickWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` meeting_tricks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` meeting_tricks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of meeting_tricks.
     */
    distinct?: Meeting_trickScalarFieldEnum | Meeting_trickScalarFieldEnum[]
  }

  /**
   * meeting_trick findFirstOrThrow
   */
  export type meeting_trickFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick
     */
    select?: meeting_trickSelect<ExtArgs> | null
    /**
     * Filter, which meeting_trick to fetch.
     */
    where?: meeting_trickWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of meeting_tricks to fetch.
     */
    orderBy?: meeting_trickOrderByWithRelationInput | meeting_trickOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for meeting_tricks.
     */
    cursor?: meeting_trickWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` meeting_tricks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` meeting_tricks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of meeting_tricks.
     */
    distinct?: Meeting_trickScalarFieldEnum | Meeting_trickScalarFieldEnum[]
  }

  /**
   * meeting_trick findMany
   */
  export type meeting_trickFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick
     */
    select?: meeting_trickSelect<ExtArgs> | null
    /**
     * Filter, which meeting_tricks to fetch.
     */
    where?: meeting_trickWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of meeting_tricks to fetch.
     */
    orderBy?: meeting_trickOrderByWithRelationInput | meeting_trickOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing meeting_tricks.
     */
    cursor?: meeting_trickWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` meeting_tricks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` meeting_tricks.
     */
    skip?: number
    distinct?: Meeting_trickScalarFieldEnum | Meeting_trickScalarFieldEnum[]
  }

  /**
   * meeting_trick create
   */
  export type meeting_trickCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick
     */
    select?: meeting_trickSelect<ExtArgs> | null
    /**
     * The data needed to create a meeting_trick.
     */
    data: XOR<meeting_trickCreateInput, meeting_trickUncheckedCreateInput>
  }

  /**
   * meeting_trick createMany
   */
  export type meeting_trickCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many meeting_tricks.
     */
    data: meeting_trickCreateManyInput | meeting_trickCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * meeting_trick update
   */
  export type meeting_trickUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick
     */
    select?: meeting_trickSelect<ExtArgs> | null
    /**
     * The data needed to update a meeting_trick.
     */
    data: XOR<meeting_trickUpdateInput, meeting_trickUncheckedUpdateInput>
    /**
     * Choose, which meeting_trick to update.
     */
    where: meeting_trickWhereUniqueInput
  }

  /**
   * meeting_trick updateMany
   */
  export type meeting_trickUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update meeting_tricks.
     */
    data: XOR<meeting_trickUpdateManyMutationInput, meeting_trickUncheckedUpdateManyInput>
    /**
     * Filter which meeting_tricks to update
     */
    where?: meeting_trickWhereInput
  }

  /**
   * meeting_trick upsert
   */
  export type meeting_trickUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick
     */
    select?: meeting_trickSelect<ExtArgs> | null
    /**
     * The filter to search for the meeting_trick to update in case it exists.
     */
    where: meeting_trickWhereUniqueInput
    /**
     * In case the meeting_trick found by the `where` argument doesn't exist, create a new meeting_trick with this data.
     */
    create: XOR<meeting_trickCreateInput, meeting_trickUncheckedCreateInput>
    /**
     * In case the meeting_trick was found with the provided `where` argument, update it with this data.
     */
    update: XOR<meeting_trickUpdateInput, meeting_trickUncheckedUpdateInput>
  }

  /**
   * meeting_trick delete
   */
  export type meeting_trickDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick
     */
    select?: meeting_trickSelect<ExtArgs> | null
    /**
     * Filter which meeting_trick to delete.
     */
    where: meeting_trickWhereUniqueInput
  }

  /**
   * meeting_trick deleteMany
   */
  export type meeting_trickDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which meeting_tricks to delete
     */
    where?: meeting_trickWhereInput
  }

  /**
   * meeting_trick without action
   */
  export type meeting_trickDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick
     */
    select?: meeting_trickSelect<ExtArgs> | null
  }


  /**
   * Model meeting_trick_chat
   */

  export type AggregateMeeting_trick_chat = {
    _count: Meeting_trick_chatCountAggregateOutputType | null
    _min: Meeting_trick_chatMinAggregateOutputType | null
    _max: Meeting_trick_chatMaxAggregateOutputType | null
  }

  export type Meeting_trick_chatMinAggregateOutputType = {
    id: string | null
    meeting_id: string | null
    createtime: Date | null
    user_content: string | null
    ai_content: string | null
  }

  export type Meeting_trick_chatMaxAggregateOutputType = {
    id: string | null
    meeting_id: string | null
    createtime: Date | null
    user_content: string | null
    ai_content: string | null
  }

  export type Meeting_trick_chatCountAggregateOutputType = {
    id: number
    meeting_id: number
    createtime: number
    user_content: number
    ai_content: number
    _all: number
  }


  export type Meeting_trick_chatMinAggregateInputType = {
    id?: true
    meeting_id?: true
    createtime?: true
    user_content?: true
    ai_content?: true
  }

  export type Meeting_trick_chatMaxAggregateInputType = {
    id?: true
    meeting_id?: true
    createtime?: true
    user_content?: true
    ai_content?: true
  }

  export type Meeting_trick_chatCountAggregateInputType = {
    id?: true
    meeting_id?: true
    createtime?: true
    user_content?: true
    ai_content?: true
    _all?: true
  }

  export type Meeting_trick_chatAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which meeting_trick_chat to aggregate.
     */
    where?: meeting_trick_chatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of meeting_trick_chats to fetch.
     */
    orderBy?: meeting_trick_chatOrderByWithRelationInput | meeting_trick_chatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: meeting_trick_chatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` meeting_trick_chats from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` meeting_trick_chats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned meeting_trick_chats
    **/
    _count?: true | Meeting_trick_chatCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Meeting_trick_chatMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Meeting_trick_chatMaxAggregateInputType
  }

  export type GetMeeting_trick_chatAggregateType<T extends Meeting_trick_chatAggregateArgs> = {
        [P in keyof T & keyof AggregateMeeting_trick_chat]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMeeting_trick_chat[P]>
      : GetScalarType<T[P], AggregateMeeting_trick_chat[P]>
  }




  export type meeting_trick_chatGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: meeting_trick_chatWhereInput
    orderBy?: meeting_trick_chatOrderByWithAggregationInput | meeting_trick_chatOrderByWithAggregationInput[]
    by: Meeting_trick_chatScalarFieldEnum[] | Meeting_trick_chatScalarFieldEnum
    having?: meeting_trick_chatScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Meeting_trick_chatCountAggregateInputType | true
    _min?: Meeting_trick_chatMinAggregateInputType
    _max?: Meeting_trick_chatMaxAggregateInputType
  }

  export type Meeting_trick_chatGroupByOutputType = {
    id: string
    meeting_id: string | null
    createtime: Date | null
    user_content: string | null
    ai_content: string | null
    _count: Meeting_trick_chatCountAggregateOutputType | null
    _min: Meeting_trick_chatMinAggregateOutputType | null
    _max: Meeting_trick_chatMaxAggregateOutputType | null
  }

  type GetMeeting_trick_chatGroupByPayload<T extends meeting_trick_chatGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Meeting_trick_chatGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Meeting_trick_chatGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Meeting_trick_chatGroupByOutputType[P]>
            : GetScalarType<T[P], Meeting_trick_chatGroupByOutputType[P]>
        }
      >
    >


  export type meeting_trick_chatSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    meeting_id?: boolean
    createtime?: boolean
    user_content?: boolean
    ai_content?: boolean
  }, ExtArgs["result"]["meeting_trick_chat"]>


  export type meeting_trick_chatSelectScalar = {
    id?: boolean
    meeting_id?: boolean
    createtime?: boolean
    user_content?: boolean
    ai_content?: boolean
  }


  export type $meeting_trick_chatPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "meeting_trick_chat"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      meeting_id: string | null
      createtime: Date | null
      user_content: string | null
      ai_content: string | null
    }, ExtArgs["result"]["meeting_trick_chat"]>
    composites: {}
  }

  type meeting_trick_chatGetPayload<S extends boolean | null | undefined | meeting_trick_chatDefaultArgs> = $Result.GetResult<Prisma.$meeting_trick_chatPayload, S>

  type meeting_trick_chatCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<meeting_trick_chatFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Meeting_trick_chatCountAggregateInputType | true
    }

  export interface meeting_trick_chatDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['meeting_trick_chat'], meta: { name: 'meeting_trick_chat' } }
    /**
     * Find zero or one Meeting_trick_chat that matches the filter.
     * @param {meeting_trick_chatFindUniqueArgs} args - Arguments to find a Meeting_trick_chat
     * @example
     * // Get one Meeting_trick_chat
     * const meeting_trick_chat = await prisma.meeting_trick_chat.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends meeting_trick_chatFindUniqueArgs>(args: SelectSubset<T, meeting_trick_chatFindUniqueArgs<ExtArgs>>): Prisma__meeting_trick_chatClient<$Result.GetResult<Prisma.$meeting_trick_chatPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Meeting_trick_chat that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {meeting_trick_chatFindUniqueOrThrowArgs} args - Arguments to find a Meeting_trick_chat
     * @example
     * // Get one Meeting_trick_chat
     * const meeting_trick_chat = await prisma.meeting_trick_chat.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends meeting_trick_chatFindUniqueOrThrowArgs>(args: SelectSubset<T, meeting_trick_chatFindUniqueOrThrowArgs<ExtArgs>>): Prisma__meeting_trick_chatClient<$Result.GetResult<Prisma.$meeting_trick_chatPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Meeting_trick_chat that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trick_chatFindFirstArgs} args - Arguments to find a Meeting_trick_chat
     * @example
     * // Get one Meeting_trick_chat
     * const meeting_trick_chat = await prisma.meeting_trick_chat.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends meeting_trick_chatFindFirstArgs>(args?: SelectSubset<T, meeting_trick_chatFindFirstArgs<ExtArgs>>): Prisma__meeting_trick_chatClient<$Result.GetResult<Prisma.$meeting_trick_chatPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Meeting_trick_chat that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trick_chatFindFirstOrThrowArgs} args - Arguments to find a Meeting_trick_chat
     * @example
     * // Get one Meeting_trick_chat
     * const meeting_trick_chat = await prisma.meeting_trick_chat.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends meeting_trick_chatFindFirstOrThrowArgs>(args?: SelectSubset<T, meeting_trick_chatFindFirstOrThrowArgs<ExtArgs>>): Prisma__meeting_trick_chatClient<$Result.GetResult<Prisma.$meeting_trick_chatPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Meeting_trick_chats that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trick_chatFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Meeting_trick_chats
     * const meeting_trick_chats = await prisma.meeting_trick_chat.findMany()
     * 
     * // Get first 10 Meeting_trick_chats
     * const meeting_trick_chats = await prisma.meeting_trick_chat.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const meeting_trick_chatWithIdOnly = await prisma.meeting_trick_chat.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends meeting_trick_chatFindManyArgs>(args?: SelectSubset<T, meeting_trick_chatFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$meeting_trick_chatPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Meeting_trick_chat.
     * @param {meeting_trick_chatCreateArgs} args - Arguments to create a Meeting_trick_chat.
     * @example
     * // Create one Meeting_trick_chat
     * const Meeting_trick_chat = await prisma.meeting_trick_chat.create({
     *   data: {
     *     // ... data to create a Meeting_trick_chat
     *   }
     * })
     * 
     */
    create<T extends meeting_trick_chatCreateArgs>(args: SelectSubset<T, meeting_trick_chatCreateArgs<ExtArgs>>): Prisma__meeting_trick_chatClient<$Result.GetResult<Prisma.$meeting_trick_chatPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Meeting_trick_chats.
     * @param {meeting_trick_chatCreateManyArgs} args - Arguments to create many Meeting_trick_chats.
     * @example
     * // Create many Meeting_trick_chats
     * const meeting_trick_chat = await prisma.meeting_trick_chat.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends meeting_trick_chatCreateManyArgs>(args?: SelectSubset<T, meeting_trick_chatCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Meeting_trick_chat.
     * @param {meeting_trick_chatDeleteArgs} args - Arguments to delete one Meeting_trick_chat.
     * @example
     * // Delete one Meeting_trick_chat
     * const Meeting_trick_chat = await prisma.meeting_trick_chat.delete({
     *   where: {
     *     // ... filter to delete one Meeting_trick_chat
     *   }
     * })
     * 
     */
    delete<T extends meeting_trick_chatDeleteArgs>(args: SelectSubset<T, meeting_trick_chatDeleteArgs<ExtArgs>>): Prisma__meeting_trick_chatClient<$Result.GetResult<Prisma.$meeting_trick_chatPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Meeting_trick_chat.
     * @param {meeting_trick_chatUpdateArgs} args - Arguments to update one Meeting_trick_chat.
     * @example
     * // Update one Meeting_trick_chat
     * const meeting_trick_chat = await prisma.meeting_trick_chat.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends meeting_trick_chatUpdateArgs>(args: SelectSubset<T, meeting_trick_chatUpdateArgs<ExtArgs>>): Prisma__meeting_trick_chatClient<$Result.GetResult<Prisma.$meeting_trick_chatPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Meeting_trick_chats.
     * @param {meeting_trick_chatDeleteManyArgs} args - Arguments to filter Meeting_trick_chats to delete.
     * @example
     * // Delete a few Meeting_trick_chats
     * const { count } = await prisma.meeting_trick_chat.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends meeting_trick_chatDeleteManyArgs>(args?: SelectSubset<T, meeting_trick_chatDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Meeting_trick_chats.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trick_chatUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Meeting_trick_chats
     * const meeting_trick_chat = await prisma.meeting_trick_chat.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends meeting_trick_chatUpdateManyArgs>(args: SelectSubset<T, meeting_trick_chatUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Meeting_trick_chat.
     * @param {meeting_trick_chatUpsertArgs} args - Arguments to update or create a Meeting_trick_chat.
     * @example
     * // Update or create a Meeting_trick_chat
     * const meeting_trick_chat = await prisma.meeting_trick_chat.upsert({
     *   create: {
     *     // ... data to create a Meeting_trick_chat
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Meeting_trick_chat we want to update
     *   }
     * })
     */
    upsert<T extends meeting_trick_chatUpsertArgs>(args: SelectSubset<T, meeting_trick_chatUpsertArgs<ExtArgs>>): Prisma__meeting_trick_chatClient<$Result.GetResult<Prisma.$meeting_trick_chatPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Meeting_trick_chats.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trick_chatCountArgs} args - Arguments to filter Meeting_trick_chats to count.
     * @example
     * // Count the number of Meeting_trick_chats
     * const count = await prisma.meeting_trick_chat.count({
     *   where: {
     *     // ... the filter for the Meeting_trick_chats we want to count
     *   }
     * })
    **/
    count<T extends meeting_trick_chatCountArgs>(
      args?: Subset<T, meeting_trick_chatCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Meeting_trick_chatCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Meeting_trick_chat.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Meeting_trick_chatAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Meeting_trick_chatAggregateArgs>(args: Subset<T, Meeting_trick_chatAggregateArgs>): Prisma.PrismaPromise<GetMeeting_trick_chatAggregateType<T>>

    /**
     * Group by Meeting_trick_chat.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {meeting_trick_chatGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends meeting_trick_chatGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: meeting_trick_chatGroupByArgs['orderBy'] }
        : { orderBy?: meeting_trick_chatGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, meeting_trick_chatGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMeeting_trick_chatGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the meeting_trick_chat model
   */
  readonly fields: meeting_trick_chatFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for meeting_trick_chat.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__meeting_trick_chatClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the meeting_trick_chat model
   */ 
  interface meeting_trick_chatFieldRefs {
    readonly id: FieldRef<"meeting_trick_chat", 'String'>
    readonly meeting_id: FieldRef<"meeting_trick_chat", 'String'>
    readonly createtime: FieldRef<"meeting_trick_chat", 'DateTime'>
    readonly user_content: FieldRef<"meeting_trick_chat", 'String'>
    readonly ai_content: FieldRef<"meeting_trick_chat", 'String'>
  }
    

  // Custom InputTypes
  /**
   * meeting_trick_chat findUnique
   */
  export type meeting_trick_chatFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick_chat
     */
    select?: meeting_trick_chatSelect<ExtArgs> | null
    /**
     * Filter, which meeting_trick_chat to fetch.
     */
    where: meeting_trick_chatWhereUniqueInput
  }

  /**
   * meeting_trick_chat findUniqueOrThrow
   */
  export type meeting_trick_chatFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick_chat
     */
    select?: meeting_trick_chatSelect<ExtArgs> | null
    /**
     * Filter, which meeting_trick_chat to fetch.
     */
    where: meeting_trick_chatWhereUniqueInput
  }

  /**
   * meeting_trick_chat findFirst
   */
  export type meeting_trick_chatFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick_chat
     */
    select?: meeting_trick_chatSelect<ExtArgs> | null
    /**
     * Filter, which meeting_trick_chat to fetch.
     */
    where?: meeting_trick_chatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of meeting_trick_chats to fetch.
     */
    orderBy?: meeting_trick_chatOrderByWithRelationInput | meeting_trick_chatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for meeting_trick_chats.
     */
    cursor?: meeting_trick_chatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` meeting_trick_chats from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` meeting_trick_chats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of meeting_trick_chats.
     */
    distinct?: Meeting_trick_chatScalarFieldEnum | Meeting_trick_chatScalarFieldEnum[]
  }

  /**
   * meeting_trick_chat findFirstOrThrow
   */
  export type meeting_trick_chatFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick_chat
     */
    select?: meeting_trick_chatSelect<ExtArgs> | null
    /**
     * Filter, which meeting_trick_chat to fetch.
     */
    where?: meeting_trick_chatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of meeting_trick_chats to fetch.
     */
    orderBy?: meeting_trick_chatOrderByWithRelationInput | meeting_trick_chatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for meeting_trick_chats.
     */
    cursor?: meeting_trick_chatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` meeting_trick_chats from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` meeting_trick_chats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of meeting_trick_chats.
     */
    distinct?: Meeting_trick_chatScalarFieldEnum | Meeting_trick_chatScalarFieldEnum[]
  }

  /**
   * meeting_trick_chat findMany
   */
  export type meeting_trick_chatFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick_chat
     */
    select?: meeting_trick_chatSelect<ExtArgs> | null
    /**
     * Filter, which meeting_trick_chats to fetch.
     */
    where?: meeting_trick_chatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of meeting_trick_chats to fetch.
     */
    orderBy?: meeting_trick_chatOrderByWithRelationInput | meeting_trick_chatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing meeting_trick_chats.
     */
    cursor?: meeting_trick_chatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` meeting_trick_chats from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` meeting_trick_chats.
     */
    skip?: number
    distinct?: Meeting_trick_chatScalarFieldEnum | Meeting_trick_chatScalarFieldEnum[]
  }

  /**
   * meeting_trick_chat create
   */
  export type meeting_trick_chatCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick_chat
     */
    select?: meeting_trick_chatSelect<ExtArgs> | null
    /**
     * The data needed to create a meeting_trick_chat.
     */
    data: XOR<meeting_trick_chatCreateInput, meeting_trick_chatUncheckedCreateInput>
  }

  /**
   * meeting_trick_chat createMany
   */
  export type meeting_trick_chatCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many meeting_trick_chats.
     */
    data: meeting_trick_chatCreateManyInput | meeting_trick_chatCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * meeting_trick_chat update
   */
  export type meeting_trick_chatUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick_chat
     */
    select?: meeting_trick_chatSelect<ExtArgs> | null
    /**
     * The data needed to update a meeting_trick_chat.
     */
    data: XOR<meeting_trick_chatUpdateInput, meeting_trick_chatUncheckedUpdateInput>
    /**
     * Choose, which meeting_trick_chat to update.
     */
    where: meeting_trick_chatWhereUniqueInput
  }

  /**
   * meeting_trick_chat updateMany
   */
  export type meeting_trick_chatUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update meeting_trick_chats.
     */
    data: XOR<meeting_trick_chatUpdateManyMutationInput, meeting_trick_chatUncheckedUpdateManyInput>
    /**
     * Filter which meeting_trick_chats to update
     */
    where?: meeting_trick_chatWhereInput
  }

  /**
   * meeting_trick_chat upsert
   */
  export type meeting_trick_chatUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick_chat
     */
    select?: meeting_trick_chatSelect<ExtArgs> | null
    /**
     * The filter to search for the meeting_trick_chat to update in case it exists.
     */
    where: meeting_trick_chatWhereUniqueInput
    /**
     * In case the meeting_trick_chat found by the `where` argument doesn't exist, create a new meeting_trick_chat with this data.
     */
    create: XOR<meeting_trick_chatCreateInput, meeting_trick_chatUncheckedCreateInput>
    /**
     * In case the meeting_trick_chat was found with the provided `where` argument, update it with this data.
     */
    update: XOR<meeting_trick_chatUpdateInput, meeting_trick_chatUncheckedUpdateInput>
  }

  /**
   * meeting_trick_chat delete
   */
  export type meeting_trick_chatDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick_chat
     */
    select?: meeting_trick_chatSelect<ExtArgs> | null
    /**
     * Filter which meeting_trick_chat to delete.
     */
    where: meeting_trick_chatWhereUniqueInput
  }

  /**
   * meeting_trick_chat deleteMany
   */
  export type meeting_trick_chatDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which meeting_trick_chats to delete
     */
    where?: meeting_trick_chatWhereInput
  }

  /**
   * meeting_trick_chat without action
   */
  export type meeting_trick_chatDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the meeting_trick_chat
     */
    select?: meeting_trick_chatSelect<ExtArgs> | null
  }


  /**
   * Model muti_agent_list
   */

  export type AggregateMuti_agent_list = {
    _count: Muti_agent_listCountAggregateOutputType | null
    _avg: Muti_agent_listAvgAggregateOutputType | null
    _sum: Muti_agent_listSumAggregateOutputType | null
    _min: Muti_agent_listMinAggregateOutputType | null
    _max: Muti_agent_listMaxAggregateOutputType | null
  }

  export type Muti_agent_listAvgAggregateOutputType = {
    knowledge_construction: number | null
  }

  export type Muti_agent_listSumAggregateOutputType = {
    knowledge_construction: number | null
  }

  export type Muti_agent_listMinAggregateOutputType = {
    id: string | null
    userid: string | null
    username: string | null
    muti_name: string | null
    description: string | null
    isPublish: boolean | null
    organizeid: string | null
    content: string | null
    create_time: Date | null
    knowledge_construction: number | null
  }

  export type Muti_agent_listMaxAggregateOutputType = {
    id: string | null
    userid: string | null
    username: string | null
    muti_name: string | null
    description: string | null
    isPublish: boolean | null
    organizeid: string | null
    content: string | null
    create_time: Date | null
    knowledge_construction: number | null
  }

  export type Muti_agent_listCountAggregateOutputType = {
    id: number
    userid: number
    username: number
    muti_name: number
    description: number
    isPublish: number
    organizeid: number
    content: number
    create_time: number
    knowledge_construction: number
    _all: number
  }


  export type Muti_agent_listAvgAggregateInputType = {
    knowledge_construction?: true
  }

  export type Muti_agent_listSumAggregateInputType = {
    knowledge_construction?: true
  }

  export type Muti_agent_listMinAggregateInputType = {
    id?: true
    userid?: true
    username?: true
    muti_name?: true
    description?: true
    isPublish?: true
    organizeid?: true
    content?: true
    create_time?: true
    knowledge_construction?: true
  }

  export type Muti_agent_listMaxAggregateInputType = {
    id?: true
    userid?: true
    username?: true
    muti_name?: true
    description?: true
    isPublish?: true
    organizeid?: true
    content?: true
    create_time?: true
    knowledge_construction?: true
  }

  export type Muti_agent_listCountAggregateInputType = {
    id?: true
    userid?: true
    username?: true
    muti_name?: true
    description?: true
    isPublish?: true
    organizeid?: true
    content?: true
    create_time?: true
    knowledge_construction?: true
    _all?: true
  }

  export type Muti_agent_listAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which muti_agent_list to aggregate.
     */
    where?: muti_agent_listWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of muti_agent_lists to fetch.
     */
    orderBy?: muti_agent_listOrderByWithRelationInput | muti_agent_listOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: muti_agent_listWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` muti_agent_lists from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` muti_agent_lists.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned muti_agent_lists
    **/
    _count?: true | Muti_agent_listCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: Muti_agent_listAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: Muti_agent_listSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Muti_agent_listMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Muti_agent_listMaxAggregateInputType
  }

  export type GetMuti_agent_listAggregateType<T extends Muti_agent_listAggregateArgs> = {
        [P in keyof T & keyof AggregateMuti_agent_list]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMuti_agent_list[P]>
      : GetScalarType<T[P], AggregateMuti_agent_list[P]>
  }




  export type muti_agent_listGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: muti_agent_listWhereInput
    orderBy?: muti_agent_listOrderByWithAggregationInput | muti_agent_listOrderByWithAggregationInput[]
    by: Muti_agent_listScalarFieldEnum[] | Muti_agent_listScalarFieldEnum
    having?: muti_agent_listScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Muti_agent_listCountAggregateInputType | true
    _avg?: Muti_agent_listAvgAggregateInputType
    _sum?: Muti_agent_listSumAggregateInputType
    _min?: Muti_agent_listMinAggregateInputType
    _max?: Muti_agent_listMaxAggregateInputType
  }

  export type Muti_agent_listGroupByOutputType = {
    id: string
    userid: string | null
    username: string | null
    muti_name: string | null
    description: string | null
    isPublish: boolean | null
    organizeid: string | null
    content: string | null
    create_time: Date | null
    knowledge_construction: number | null
    _count: Muti_agent_listCountAggregateOutputType | null
    _avg: Muti_agent_listAvgAggregateOutputType | null
    _sum: Muti_agent_listSumAggregateOutputType | null
    _min: Muti_agent_listMinAggregateOutputType | null
    _max: Muti_agent_listMaxAggregateOutputType | null
  }

  type GetMuti_agent_listGroupByPayload<T extends muti_agent_listGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Muti_agent_listGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Muti_agent_listGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Muti_agent_listGroupByOutputType[P]>
            : GetScalarType<T[P], Muti_agent_listGroupByOutputType[P]>
        }
      >
    >


  export type muti_agent_listSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    userid?: boolean
    username?: boolean
    muti_name?: boolean
    description?: boolean
    isPublish?: boolean
    organizeid?: boolean
    content?: boolean
    create_time?: boolean
    knowledge_construction?: boolean
  }, ExtArgs["result"]["muti_agent_list"]>


  export type muti_agent_listSelectScalar = {
    id?: boolean
    userid?: boolean
    username?: boolean
    muti_name?: boolean
    description?: boolean
    isPublish?: boolean
    organizeid?: boolean
    content?: boolean
    create_time?: boolean
    knowledge_construction?: boolean
  }


  export type $muti_agent_listPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "muti_agent_list"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      userid: string | null
      username: string | null
      muti_name: string | null
      description: string | null
      isPublish: boolean | null
      organizeid: string | null
      content: string | null
      create_time: Date | null
      knowledge_construction: number | null
    }, ExtArgs["result"]["muti_agent_list"]>
    composites: {}
  }

  type muti_agent_listGetPayload<S extends boolean | null | undefined | muti_agent_listDefaultArgs> = $Result.GetResult<Prisma.$muti_agent_listPayload, S>

  type muti_agent_listCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<muti_agent_listFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Muti_agent_listCountAggregateInputType | true
    }

  export interface muti_agent_listDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['muti_agent_list'], meta: { name: 'muti_agent_list' } }
    /**
     * Find zero or one Muti_agent_list that matches the filter.
     * @param {muti_agent_listFindUniqueArgs} args - Arguments to find a Muti_agent_list
     * @example
     * // Get one Muti_agent_list
     * const muti_agent_list = await prisma.muti_agent_list.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends muti_agent_listFindUniqueArgs>(args: SelectSubset<T, muti_agent_listFindUniqueArgs<ExtArgs>>): Prisma__muti_agent_listClient<$Result.GetResult<Prisma.$muti_agent_listPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Muti_agent_list that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {muti_agent_listFindUniqueOrThrowArgs} args - Arguments to find a Muti_agent_list
     * @example
     * // Get one Muti_agent_list
     * const muti_agent_list = await prisma.muti_agent_list.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends muti_agent_listFindUniqueOrThrowArgs>(args: SelectSubset<T, muti_agent_listFindUniqueOrThrowArgs<ExtArgs>>): Prisma__muti_agent_listClient<$Result.GetResult<Prisma.$muti_agent_listPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Muti_agent_list that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {muti_agent_listFindFirstArgs} args - Arguments to find a Muti_agent_list
     * @example
     * // Get one Muti_agent_list
     * const muti_agent_list = await prisma.muti_agent_list.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends muti_agent_listFindFirstArgs>(args?: SelectSubset<T, muti_agent_listFindFirstArgs<ExtArgs>>): Prisma__muti_agent_listClient<$Result.GetResult<Prisma.$muti_agent_listPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Muti_agent_list that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {muti_agent_listFindFirstOrThrowArgs} args - Arguments to find a Muti_agent_list
     * @example
     * // Get one Muti_agent_list
     * const muti_agent_list = await prisma.muti_agent_list.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends muti_agent_listFindFirstOrThrowArgs>(args?: SelectSubset<T, muti_agent_listFindFirstOrThrowArgs<ExtArgs>>): Prisma__muti_agent_listClient<$Result.GetResult<Prisma.$muti_agent_listPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Muti_agent_lists that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {muti_agent_listFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Muti_agent_lists
     * const muti_agent_lists = await prisma.muti_agent_list.findMany()
     * 
     * // Get first 10 Muti_agent_lists
     * const muti_agent_lists = await prisma.muti_agent_list.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const muti_agent_listWithIdOnly = await prisma.muti_agent_list.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends muti_agent_listFindManyArgs>(args?: SelectSubset<T, muti_agent_listFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$muti_agent_listPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Muti_agent_list.
     * @param {muti_agent_listCreateArgs} args - Arguments to create a Muti_agent_list.
     * @example
     * // Create one Muti_agent_list
     * const Muti_agent_list = await prisma.muti_agent_list.create({
     *   data: {
     *     // ... data to create a Muti_agent_list
     *   }
     * })
     * 
     */
    create<T extends muti_agent_listCreateArgs>(args: SelectSubset<T, muti_agent_listCreateArgs<ExtArgs>>): Prisma__muti_agent_listClient<$Result.GetResult<Prisma.$muti_agent_listPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Muti_agent_lists.
     * @param {muti_agent_listCreateManyArgs} args - Arguments to create many Muti_agent_lists.
     * @example
     * // Create many Muti_agent_lists
     * const muti_agent_list = await prisma.muti_agent_list.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends muti_agent_listCreateManyArgs>(args?: SelectSubset<T, muti_agent_listCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Muti_agent_list.
     * @param {muti_agent_listDeleteArgs} args - Arguments to delete one Muti_agent_list.
     * @example
     * // Delete one Muti_agent_list
     * const Muti_agent_list = await prisma.muti_agent_list.delete({
     *   where: {
     *     // ... filter to delete one Muti_agent_list
     *   }
     * })
     * 
     */
    delete<T extends muti_agent_listDeleteArgs>(args: SelectSubset<T, muti_agent_listDeleteArgs<ExtArgs>>): Prisma__muti_agent_listClient<$Result.GetResult<Prisma.$muti_agent_listPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Muti_agent_list.
     * @param {muti_agent_listUpdateArgs} args - Arguments to update one Muti_agent_list.
     * @example
     * // Update one Muti_agent_list
     * const muti_agent_list = await prisma.muti_agent_list.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends muti_agent_listUpdateArgs>(args: SelectSubset<T, muti_agent_listUpdateArgs<ExtArgs>>): Prisma__muti_agent_listClient<$Result.GetResult<Prisma.$muti_agent_listPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Muti_agent_lists.
     * @param {muti_agent_listDeleteManyArgs} args - Arguments to filter Muti_agent_lists to delete.
     * @example
     * // Delete a few Muti_agent_lists
     * const { count } = await prisma.muti_agent_list.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends muti_agent_listDeleteManyArgs>(args?: SelectSubset<T, muti_agent_listDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Muti_agent_lists.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {muti_agent_listUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Muti_agent_lists
     * const muti_agent_list = await prisma.muti_agent_list.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends muti_agent_listUpdateManyArgs>(args: SelectSubset<T, muti_agent_listUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Muti_agent_list.
     * @param {muti_agent_listUpsertArgs} args - Arguments to update or create a Muti_agent_list.
     * @example
     * // Update or create a Muti_agent_list
     * const muti_agent_list = await prisma.muti_agent_list.upsert({
     *   create: {
     *     // ... data to create a Muti_agent_list
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Muti_agent_list we want to update
     *   }
     * })
     */
    upsert<T extends muti_agent_listUpsertArgs>(args: SelectSubset<T, muti_agent_listUpsertArgs<ExtArgs>>): Prisma__muti_agent_listClient<$Result.GetResult<Prisma.$muti_agent_listPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Muti_agent_lists.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {muti_agent_listCountArgs} args - Arguments to filter Muti_agent_lists to count.
     * @example
     * // Count the number of Muti_agent_lists
     * const count = await prisma.muti_agent_list.count({
     *   where: {
     *     // ... the filter for the Muti_agent_lists we want to count
     *   }
     * })
    **/
    count<T extends muti_agent_listCountArgs>(
      args?: Subset<T, muti_agent_listCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Muti_agent_listCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Muti_agent_list.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Muti_agent_listAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Muti_agent_listAggregateArgs>(args: Subset<T, Muti_agent_listAggregateArgs>): Prisma.PrismaPromise<GetMuti_agent_listAggregateType<T>>

    /**
     * Group by Muti_agent_list.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {muti_agent_listGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends muti_agent_listGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: muti_agent_listGroupByArgs['orderBy'] }
        : { orderBy?: muti_agent_listGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, muti_agent_listGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMuti_agent_listGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the muti_agent_list model
   */
  readonly fields: muti_agent_listFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for muti_agent_list.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__muti_agent_listClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the muti_agent_list model
   */ 
  interface muti_agent_listFieldRefs {
    readonly id: FieldRef<"muti_agent_list", 'String'>
    readonly userid: FieldRef<"muti_agent_list", 'String'>
    readonly username: FieldRef<"muti_agent_list", 'String'>
    readonly muti_name: FieldRef<"muti_agent_list", 'String'>
    readonly description: FieldRef<"muti_agent_list", 'String'>
    readonly isPublish: FieldRef<"muti_agent_list", 'Boolean'>
    readonly organizeid: FieldRef<"muti_agent_list", 'String'>
    readonly content: FieldRef<"muti_agent_list", 'String'>
    readonly create_time: FieldRef<"muti_agent_list", 'DateTime'>
    readonly knowledge_construction: FieldRef<"muti_agent_list", 'Int'>
  }
    

  // Custom InputTypes
  /**
   * muti_agent_list findUnique
   */
  export type muti_agent_listFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the muti_agent_list
     */
    select?: muti_agent_listSelect<ExtArgs> | null
    /**
     * Filter, which muti_agent_list to fetch.
     */
    where: muti_agent_listWhereUniqueInput
  }

  /**
   * muti_agent_list findUniqueOrThrow
   */
  export type muti_agent_listFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the muti_agent_list
     */
    select?: muti_agent_listSelect<ExtArgs> | null
    /**
     * Filter, which muti_agent_list to fetch.
     */
    where: muti_agent_listWhereUniqueInput
  }

  /**
   * muti_agent_list findFirst
   */
  export type muti_agent_listFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the muti_agent_list
     */
    select?: muti_agent_listSelect<ExtArgs> | null
    /**
     * Filter, which muti_agent_list to fetch.
     */
    where?: muti_agent_listWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of muti_agent_lists to fetch.
     */
    orderBy?: muti_agent_listOrderByWithRelationInput | muti_agent_listOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for muti_agent_lists.
     */
    cursor?: muti_agent_listWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` muti_agent_lists from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` muti_agent_lists.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of muti_agent_lists.
     */
    distinct?: Muti_agent_listScalarFieldEnum | Muti_agent_listScalarFieldEnum[]
  }

  /**
   * muti_agent_list findFirstOrThrow
   */
  export type muti_agent_listFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the muti_agent_list
     */
    select?: muti_agent_listSelect<ExtArgs> | null
    /**
     * Filter, which muti_agent_list to fetch.
     */
    where?: muti_agent_listWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of muti_agent_lists to fetch.
     */
    orderBy?: muti_agent_listOrderByWithRelationInput | muti_agent_listOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for muti_agent_lists.
     */
    cursor?: muti_agent_listWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` muti_agent_lists from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` muti_agent_lists.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of muti_agent_lists.
     */
    distinct?: Muti_agent_listScalarFieldEnum | Muti_agent_listScalarFieldEnum[]
  }

  /**
   * muti_agent_list findMany
   */
  export type muti_agent_listFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the muti_agent_list
     */
    select?: muti_agent_listSelect<ExtArgs> | null
    /**
     * Filter, which muti_agent_lists to fetch.
     */
    where?: muti_agent_listWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of muti_agent_lists to fetch.
     */
    orderBy?: muti_agent_listOrderByWithRelationInput | muti_agent_listOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing muti_agent_lists.
     */
    cursor?: muti_agent_listWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` muti_agent_lists from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` muti_agent_lists.
     */
    skip?: number
    distinct?: Muti_agent_listScalarFieldEnum | Muti_agent_listScalarFieldEnum[]
  }

  /**
   * muti_agent_list create
   */
  export type muti_agent_listCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the muti_agent_list
     */
    select?: muti_agent_listSelect<ExtArgs> | null
    /**
     * The data needed to create a muti_agent_list.
     */
    data: XOR<muti_agent_listCreateInput, muti_agent_listUncheckedCreateInput>
  }

  /**
   * muti_agent_list createMany
   */
  export type muti_agent_listCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many muti_agent_lists.
     */
    data: muti_agent_listCreateManyInput | muti_agent_listCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * muti_agent_list update
   */
  export type muti_agent_listUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the muti_agent_list
     */
    select?: muti_agent_listSelect<ExtArgs> | null
    /**
     * The data needed to update a muti_agent_list.
     */
    data: XOR<muti_agent_listUpdateInput, muti_agent_listUncheckedUpdateInput>
    /**
     * Choose, which muti_agent_list to update.
     */
    where: muti_agent_listWhereUniqueInput
  }

  /**
   * muti_agent_list updateMany
   */
  export type muti_agent_listUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update muti_agent_lists.
     */
    data: XOR<muti_agent_listUpdateManyMutationInput, muti_agent_listUncheckedUpdateManyInput>
    /**
     * Filter which muti_agent_lists to update
     */
    where?: muti_agent_listWhereInput
  }

  /**
   * muti_agent_list upsert
   */
  export type muti_agent_listUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the muti_agent_list
     */
    select?: muti_agent_listSelect<ExtArgs> | null
    /**
     * The filter to search for the muti_agent_list to update in case it exists.
     */
    where: muti_agent_listWhereUniqueInput
    /**
     * In case the muti_agent_list found by the `where` argument doesn't exist, create a new muti_agent_list with this data.
     */
    create: XOR<muti_agent_listCreateInput, muti_agent_listUncheckedCreateInput>
    /**
     * In case the muti_agent_list was found with the provided `where` argument, update it with this data.
     */
    update: XOR<muti_agent_listUpdateInput, muti_agent_listUncheckedUpdateInput>
  }

  /**
   * muti_agent_list delete
   */
  export type muti_agent_listDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the muti_agent_list
     */
    select?: muti_agent_listSelect<ExtArgs> | null
    /**
     * Filter which muti_agent_list to delete.
     */
    where: muti_agent_listWhereUniqueInput
  }

  /**
   * muti_agent_list deleteMany
   */
  export type muti_agent_listDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which muti_agent_lists to delete
     */
    where?: muti_agent_listWhereInput
  }

  /**
   * muti_agent_list without action
   */
  export type muti_agent_listDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the muti_agent_list
     */
    select?: muti_agent_listSelect<ExtArgs> | null
  }


  /**
   * Model park_chat_file_list
   */

  export type AggregatePark_chat_file_list = {
    _count: Park_chat_file_listCountAggregateOutputType | null
    _min: Park_chat_file_listMinAggregateOutputType | null
    _max: Park_chat_file_listMaxAggregateOutputType | null
  }

  export type Park_chat_file_listMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    file_names: string | null
    file_ids: string | null
    create_time: Date | null
    file_urls: string | null
  }

  export type Park_chat_file_listMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    file_names: string | null
    file_ids: string | null
    create_time: Date | null
    file_urls: string | null
  }

  export type Park_chat_file_listCountAggregateOutputType = {
    id: number
    user_id: number
    file_names: number
    file_ids: number
    create_time: number
    file_urls: number
    _all: number
  }


  export type Park_chat_file_listMinAggregateInputType = {
    id?: true
    user_id?: true
    file_names?: true
    file_ids?: true
    create_time?: true
    file_urls?: true
  }

  export type Park_chat_file_listMaxAggregateInputType = {
    id?: true
    user_id?: true
    file_names?: true
    file_ids?: true
    create_time?: true
    file_urls?: true
  }

  export type Park_chat_file_listCountAggregateInputType = {
    id?: true
    user_id?: true
    file_names?: true
    file_ids?: true
    create_time?: true
    file_urls?: true
    _all?: true
  }

  export type Park_chat_file_listAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which park_chat_file_list to aggregate.
     */
    where?: park_chat_file_listWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of park_chat_file_lists to fetch.
     */
    orderBy?: park_chat_file_listOrderByWithRelationInput | park_chat_file_listOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: park_chat_file_listWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` park_chat_file_lists from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` park_chat_file_lists.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned park_chat_file_lists
    **/
    _count?: true | Park_chat_file_listCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: Park_chat_file_listMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: Park_chat_file_listMaxAggregateInputType
  }

  export type GetPark_chat_file_listAggregateType<T extends Park_chat_file_listAggregateArgs> = {
        [P in keyof T & keyof AggregatePark_chat_file_list]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregatePark_chat_file_list[P]>
      : GetScalarType<T[P], AggregatePark_chat_file_list[P]>
  }




  export type park_chat_file_listGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: park_chat_file_listWhereInput
    orderBy?: park_chat_file_listOrderByWithAggregationInput | park_chat_file_listOrderByWithAggregationInput[]
    by: Park_chat_file_listScalarFieldEnum[] | Park_chat_file_listScalarFieldEnum
    having?: park_chat_file_listScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: Park_chat_file_listCountAggregateInputType | true
    _min?: Park_chat_file_listMinAggregateInputType
    _max?: Park_chat_file_listMaxAggregateInputType
  }

  export type Park_chat_file_listGroupByOutputType = {
    id: string
    user_id: string | null
    file_names: string
    file_ids: string
    create_time: Date | null
    file_urls: string | null
    _count: Park_chat_file_listCountAggregateOutputType | null
    _min: Park_chat_file_listMinAggregateOutputType | null
    _max: Park_chat_file_listMaxAggregateOutputType | null
  }

  type GetPark_chat_file_listGroupByPayload<T extends park_chat_file_listGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<Park_chat_file_listGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof Park_chat_file_listGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], Park_chat_file_listGroupByOutputType[P]>
            : GetScalarType<T[P], Park_chat_file_listGroupByOutputType[P]>
        }
      >
    >


  export type park_chat_file_listSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    file_names?: boolean
    file_ids?: boolean
    create_time?: boolean
    file_urls?: boolean
  }, ExtArgs["result"]["park_chat_file_list"]>


  export type park_chat_file_listSelectScalar = {
    id?: boolean
    user_id?: boolean
    file_names?: boolean
    file_ids?: boolean
    create_time?: boolean
    file_urls?: boolean
  }


  export type $park_chat_file_listPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "park_chat_file_list"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string | null
      file_names: string
      file_ids: string
      create_time: Date | null
      file_urls: string | null
    }, ExtArgs["result"]["park_chat_file_list"]>
    composites: {}
  }

  type park_chat_file_listGetPayload<S extends boolean | null | undefined | park_chat_file_listDefaultArgs> = $Result.GetResult<Prisma.$park_chat_file_listPayload, S>

  type park_chat_file_listCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<park_chat_file_listFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: Park_chat_file_listCountAggregateInputType | true
    }

  export interface park_chat_file_listDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['park_chat_file_list'], meta: { name: 'park_chat_file_list' } }
    /**
     * Find zero or one Park_chat_file_list that matches the filter.
     * @param {park_chat_file_listFindUniqueArgs} args - Arguments to find a Park_chat_file_list
     * @example
     * // Get one Park_chat_file_list
     * const park_chat_file_list = await prisma.park_chat_file_list.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends park_chat_file_listFindUniqueArgs>(args: SelectSubset<T, park_chat_file_listFindUniqueArgs<ExtArgs>>): Prisma__park_chat_file_listClient<$Result.GetResult<Prisma.$park_chat_file_listPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Park_chat_file_list that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {park_chat_file_listFindUniqueOrThrowArgs} args - Arguments to find a Park_chat_file_list
     * @example
     * // Get one Park_chat_file_list
     * const park_chat_file_list = await prisma.park_chat_file_list.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends park_chat_file_listFindUniqueOrThrowArgs>(args: SelectSubset<T, park_chat_file_listFindUniqueOrThrowArgs<ExtArgs>>): Prisma__park_chat_file_listClient<$Result.GetResult<Prisma.$park_chat_file_listPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Park_chat_file_list that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {park_chat_file_listFindFirstArgs} args - Arguments to find a Park_chat_file_list
     * @example
     * // Get one Park_chat_file_list
     * const park_chat_file_list = await prisma.park_chat_file_list.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends park_chat_file_listFindFirstArgs>(args?: SelectSubset<T, park_chat_file_listFindFirstArgs<ExtArgs>>): Prisma__park_chat_file_listClient<$Result.GetResult<Prisma.$park_chat_file_listPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Park_chat_file_list that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {park_chat_file_listFindFirstOrThrowArgs} args - Arguments to find a Park_chat_file_list
     * @example
     * // Get one Park_chat_file_list
     * const park_chat_file_list = await prisma.park_chat_file_list.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends park_chat_file_listFindFirstOrThrowArgs>(args?: SelectSubset<T, park_chat_file_listFindFirstOrThrowArgs<ExtArgs>>): Prisma__park_chat_file_listClient<$Result.GetResult<Prisma.$park_chat_file_listPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Park_chat_file_lists that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {park_chat_file_listFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Park_chat_file_lists
     * const park_chat_file_lists = await prisma.park_chat_file_list.findMany()
     * 
     * // Get first 10 Park_chat_file_lists
     * const park_chat_file_lists = await prisma.park_chat_file_list.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const park_chat_file_listWithIdOnly = await prisma.park_chat_file_list.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends park_chat_file_listFindManyArgs>(args?: SelectSubset<T, park_chat_file_listFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$park_chat_file_listPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Park_chat_file_list.
     * @param {park_chat_file_listCreateArgs} args - Arguments to create a Park_chat_file_list.
     * @example
     * // Create one Park_chat_file_list
     * const Park_chat_file_list = await prisma.park_chat_file_list.create({
     *   data: {
     *     // ... data to create a Park_chat_file_list
     *   }
     * })
     * 
     */
    create<T extends park_chat_file_listCreateArgs>(args: SelectSubset<T, park_chat_file_listCreateArgs<ExtArgs>>): Prisma__park_chat_file_listClient<$Result.GetResult<Prisma.$park_chat_file_listPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Park_chat_file_lists.
     * @param {park_chat_file_listCreateManyArgs} args - Arguments to create many Park_chat_file_lists.
     * @example
     * // Create many Park_chat_file_lists
     * const park_chat_file_list = await prisma.park_chat_file_list.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends park_chat_file_listCreateManyArgs>(args?: SelectSubset<T, park_chat_file_listCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Park_chat_file_list.
     * @param {park_chat_file_listDeleteArgs} args - Arguments to delete one Park_chat_file_list.
     * @example
     * // Delete one Park_chat_file_list
     * const Park_chat_file_list = await prisma.park_chat_file_list.delete({
     *   where: {
     *     // ... filter to delete one Park_chat_file_list
     *   }
     * })
     * 
     */
    delete<T extends park_chat_file_listDeleteArgs>(args: SelectSubset<T, park_chat_file_listDeleteArgs<ExtArgs>>): Prisma__park_chat_file_listClient<$Result.GetResult<Prisma.$park_chat_file_listPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Park_chat_file_list.
     * @param {park_chat_file_listUpdateArgs} args - Arguments to update one Park_chat_file_list.
     * @example
     * // Update one Park_chat_file_list
     * const park_chat_file_list = await prisma.park_chat_file_list.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends park_chat_file_listUpdateArgs>(args: SelectSubset<T, park_chat_file_listUpdateArgs<ExtArgs>>): Prisma__park_chat_file_listClient<$Result.GetResult<Prisma.$park_chat_file_listPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Park_chat_file_lists.
     * @param {park_chat_file_listDeleteManyArgs} args - Arguments to filter Park_chat_file_lists to delete.
     * @example
     * // Delete a few Park_chat_file_lists
     * const { count } = await prisma.park_chat_file_list.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends park_chat_file_listDeleteManyArgs>(args?: SelectSubset<T, park_chat_file_listDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Park_chat_file_lists.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {park_chat_file_listUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Park_chat_file_lists
     * const park_chat_file_list = await prisma.park_chat_file_list.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends park_chat_file_listUpdateManyArgs>(args: SelectSubset<T, park_chat_file_listUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Park_chat_file_list.
     * @param {park_chat_file_listUpsertArgs} args - Arguments to update or create a Park_chat_file_list.
     * @example
     * // Update or create a Park_chat_file_list
     * const park_chat_file_list = await prisma.park_chat_file_list.upsert({
     *   create: {
     *     // ... data to create a Park_chat_file_list
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Park_chat_file_list we want to update
     *   }
     * })
     */
    upsert<T extends park_chat_file_listUpsertArgs>(args: SelectSubset<T, park_chat_file_listUpsertArgs<ExtArgs>>): Prisma__park_chat_file_listClient<$Result.GetResult<Prisma.$park_chat_file_listPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Park_chat_file_lists.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {park_chat_file_listCountArgs} args - Arguments to filter Park_chat_file_lists to count.
     * @example
     * // Count the number of Park_chat_file_lists
     * const count = await prisma.park_chat_file_list.count({
     *   where: {
     *     // ... the filter for the Park_chat_file_lists we want to count
     *   }
     * })
    **/
    count<T extends park_chat_file_listCountArgs>(
      args?: Subset<T, park_chat_file_listCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], Park_chat_file_listCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Park_chat_file_list.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {Park_chat_file_listAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends Park_chat_file_listAggregateArgs>(args: Subset<T, Park_chat_file_listAggregateArgs>): Prisma.PrismaPromise<GetPark_chat_file_listAggregateType<T>>

    /**
     * Group by Park_chat_file_list.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {park_chat_file_listGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends park_chat_file_listGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: park_chat_file_listGroupByArgs['orderBy'] }
        : { orderBy?: park_chat_file_listGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, park_chat_file_listGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPark_chat_file_listGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the park_chat_file_list model
   */
  readonly fields: park_chat_file_listFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for park_chat_file_list.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__park_chat_file_listClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the park_chat_file_list model
   */ 
  interface park_chat_file_listFieldRefs {
    readonly id: FieldRef<"park_chat_file_list", 'String'>
    readonly user_id: FieldRef<"park_chat_file_list", 'String'>
    readonly file_names: FieldRef<"park_chat_file_list", 'String'>
    readonly file_ids: FieldRef<"park_chat_file_list", 'String'>
    readonly create_time: FieldRef<"park_chat_file_list", 'DateTime'>
    readonly file_urls: FieldRef<"park_chat_file_list", 'String'>
  }
    

  // Custom InputTypes
  /**
   * park_chat_file_list findUnique
   */
  export type park_chat_file_listFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the park_chat_file_list
     */
    select?: park_chat_file_listSelect<ExtArgs> | null
    /**
     * Filter, which park_chat_file_list to fetch.
     */
    where: park_chat_file_listWhereUniqueInput
  }

  /**
   * park_chat_file_list findUniqueOrThrow
   */
  export type park_chat_file_listFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the park_chat_file_list
     */
    select?: park_chat_file_listSelect<ExtArgs> | null
    /**
     * Filter, which park_chat_file_list to fetch.
     */
    where: park_chat_file_listWhereUniqueInput
  }

  /**
   * park_chat_file_list findFirst
   */
  export type park_chat_file_listFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the park_chat_file_list
     */
    select?: park_chat_file_listSelect<ExtArgs> | null
    /**
     * Filter, which park_chat_file_list to fetch.
     */
    where?: park_chat_file_listWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of park_chat_file_lists to fetch.
     */
    orderBy?: park_chat_file_listOrderByWithRelationInput | park_chat_file_listOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for park_chat_file_lists.
     */
    cursor?: park_chat_file_listWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` park_chat_file_lists from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` park_chat_file_lists.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of park_chat_file_lists.
     */
    distinct?: Park_chat_file_listScalarFieldEnum | Park_chat_file_listScalarFieldEnum[]
  }

  /**
   * park_chat_file_list findFirstOrThrow
   */
  export type park_chat_file_listFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the park_chat_file_list
     */
    select?: park_chat_file_listSelect<ExtArgs> | null
    /**
     * Filter, which park_chat_file_list to fetch.
     */
    where?: park_chat_file_listWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of park_chat_file_lists to fetch.
     */
    orderBy?: park_chat_file_listOrderByWithRelationInput | park_chat_file_listOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for park_chat_file_lists.
     */
    cursor?: park_chat_file_listWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` park_chat_file_lists from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` park_chat_file_lists.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of park_chat_file_lists.
     */
    distinct?: Park_chat_file_listScalarFieldEnum | Park_chat_file_listScalarFieldEnum[]
  }

  /**
   * park_chat_file_list findMany
   */
  export type park_chat_file_listFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the park_chat_file_list
     */
    select?: park_chat_file_listSelect<ExtArgs> | null
    /**
     * Filter, which park_chat_file_lists to fetch.
     */
    where?: park_chat_file_listWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of park_chat_file_lists to fetch.
     */
    orderBy?: park_chat_file_listOrderByWithRelationInput | park_chat_file_listOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing park_chat_file_lists.
     */
    cursor?: park_chat_file_listWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` park_chat_file_lists from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` park_chat_file_lists.
     */
    skip?: number
    distinct?: Park_chat_file_listScalarFieldEnum | Park_chat_file_listScalarFieldEnum[]
  }

  /**
   * park_chat_file_list create
   */
  export type park_chat_file_listCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the park_chat_file_list
     */
    select?: park_chat_file_listSelect<ExtArgs> | null
    /**
     * The data needed to create a park_chat_file_list.
     */
    data: XOR<park_chat_file_listCreateInput, park_chat_file_listUncheckedCreateInput>
  }

  /**
   * park_chat_file_list createMany
   */
  export type park_chat_file_listCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many park_chat_file_lists.
     */
    data: park_chat_file_listCreateManyInput | park_chat_file_listCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * park_chat_file_list update
   */
  export type park_chat_file_listUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the park_chat_file_list
     */
    select?: park_chat_file_listSelect<ExtArgs> | null
    /**
     * The data needed to update a park_chat_file_list.
     */
    data: XOR<park_chat_file_listUpdateInput, park_chat_file_listUncheckedUpdateInput>
    /**
     * Choose, which park_chat_file_list to update.
     */
    where: park_chat_file_listWhereUniqueInput
  }

  /**
   * park_chat_file_list updateMany
   */
  export type park_chat_file_listUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update park_chat_file_lists.
     */
    data: XOR<park_chat_file_listUpdateManyMutationInput, park_chat_file_listUncheckedUpdateManyInput>
    /**
     * Filter which park_chat_file_lists to update
     */
    where?: park_chat_file_listWhereInput
  }

  /**
   * park_chat_file_list upsert
   */
  export type park_chat_file_listUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the park_chat_file_list
     */
    select?: park_chat_file_listSelect<ExtArgs> | null
    /**
     * The filter to search for the park_chat_file_list to update in case it exists.
     */
    where: park_chat_file_listWhereUniqueInput
    /**
     * In case the park_chat_file_list found by the `where` argument doesn't exist, create a new park_chat_file_list with this data.
     */
    create: XOR<park_chat_file_listCreateInput, park_chat_file_listUncheckedCreateInput>
    /**
     * In case the park_chat_file_list was found with the provided `where` argument, update it with this data.
     */
    update: XOR<park_chat_file_listUpdateInput, park_chat_file_listUncheckedUpdateInput>
  }

  /**
   * park_chat_file_list delete
   */
  export type park_chat_file_listDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the park_chat_file_list
     */
    select?: park_chat_file_listSelect<ExtArgs> | null
    /**
     * Filter which park_chat_file_list to delete.
     */
    where: park_chat_file_listWhereUniqueInput
  }

  /**
   * park_chat_file_list deleteMany
   */
  export type park_chat_file_listDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which park_chat_file_lists to delete
     */
    where?: park_chat_file_listWhereInput
  }

  /**
   * park_chat_file_list without action
   */
  export type park_chat_file_listDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the park_chat_file_list
     */
    select?: park_chat_file_listSelect<ExtArgs> | null
  }


  /**
   * Model token
   */

  export type AggregateToken = {
    _count: TokenCountAggregateOutputType | null
    _min: TokenMinAggregateOutputType | null
    _max: TokenMaxAggregateOutputType | null
  }

  export type TokenMinAggregateOutputType = {
    id: string | null
    schoolId: string | null
    key: string | null
    createUsername: string | null
    createtime: Date | null
  }

  export type TokenMaxAggregateOutputType = {
    id: string | null
    schoolId: string | null
    key: string | null
    createUsername: string | null
    createtime: Date | null
  }

  export type TokenCountAggregateOutputType = {
    id: number
    schoolId: number
    key: number
    createUsername: number
    createtime: number
    _all: number
  }


  export type TokenMinAggregateInputType = {
    id?: true
    schoolId?: true
    key?: true
    createUsername?: true
    createtime?: true
  }

  export type TokenMaxAggregateInputType = {
    id?: true
    schoolId?: true
    key?: true
    createUsername?: true
    createtime?: true
  }

  export type TokenCountAggregateInputType = {
    id?: true
    schoolId?: true
    key?: true
    createUsername?: true
    createtime?: true
    _all?: true
  }

  export type TokenAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which token to aggregate.
     */
    where?: tokenWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of tokens to fetch.
     */
    orderBy?: tokenOrderByWithRelationInput | tokenOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: tokenWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` tokens from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` tokens.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned tokens
    **/
    _count?: true | TokenCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TokenMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TokenMaxAggregateInputType
  }

  export type GetTokenAggregateType<T extends TokenAggregateArgs> = {
        [P in keyof T & keyof AggregateToken]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateToken[P]>
      : GetScalarType<T[P], AggregateToken[P]>
  }




  export type tokenGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: tokenWhereInput
    orderBy?: tokenOrderByWithAggregationInput | tokenOrderByWithAggregationInput[]
    by: TokenScalarFieldEnum[] | TokenScalarFieldEnum
    having?: tokenScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TokenCountAggregateInputType | true
    _min?: TokenMinAggregateInputType
    _max?: TokenMaxAggregateInputType
  }

  export type TokenGroupByOutputType = {
    id: string
    schoolId: string | null
    key: string | null
    createUsername: string | null
    createtime: Date | null
    _count: TokenCountAggregateOutputType | null
    _min: TokenMinAggregateOutputType | null
    _max: TokenMaxAggregateOutputType | null
  }

  type GetTokenGroupByPayload<T extends tokenGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<TokenGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof TokenGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], TokenGroupByOutputType[P]>
            : GetScalarType<T[P], TokenGroupByOutputType[P]>
        }
      >
    >


  export type tokenSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    schoolId?: boolean
    key?: boolean
    createUsername?: boolean
    createtime?: boolean
  }, ExtArgs["result"]["token"]>


  export type tokenSelectScalar = {
    id?: boolean
    schoolId?: boolean
    key?: boolean
    createUsername?: boolean
    createtime?: boolean
  }


  export type $tokenPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "token"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      schoolId: string | null
      key: string | null
      createUsername: string | null
      createtime: Date | null
    }, ExtArgs["result"]["token"]>
    composites: {}
  }

  type tokenGetPayload<S extends boolean | null | undefined | tokenDefaultArgs> = $Result.GetResult<Prisma.$tokenPayload, S>

  type tokenCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<tokenFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: TokenCountAggregateInputType | true
    }

  export interface tokenDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['token'], meta: { name: 'token' } }
    /**
     * Find zero or one Token that matches the filter.
     * @param {tokenFindUniqueArgs} args - Arguments to find a Token
     * @example
     * // Get one Token
     * const token = await prisma.token.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends tokenFindUniqueArgs>(args: SelectSubset<T, tokenFindUniqueArgs<ExtArgs>>): Prisma__tokenClient<$Result.GetResult<Prisma.$tokenPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Token that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {tokenFindUniqueOrThrowArgs} args - Arguments to find a Token
     * @example
     * // Get one Token
     * const token = await prisma.token.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends tokenFindUniqueOrThrowArgs>(args: SelectSubset<T, tokenFindUniqueOrThrowArgs<ExtArgs>>): Prisma__tokenClient<$Result.GetResult<Prisma.$tokenPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Token that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {tokenFindFirstArgs} args - Arguments to find a Token
     * @example
     * // Get one Token
     * const token = await prisma.token.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends tokenFindFirstArgs>(args?: SelectSubset<T, tokenFindFirstArgs<ExtArgs>>): Prisma__tokenClient<$Result.GetResult<Prisma.$tokenPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Token that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {tokenFindFirstOrThrowArgs} args - Arguments to find a Token
     * @example
     * // Get one Token
     * const token = await prisma.token.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends tokenFindFirstOrThrowArgs>(args?: SelectSubset<T, tokenFindFirstOrThrowArgs<ExtArgs>>): Prisma__tokenClient<$Result.GetResult<Prisma.$tokenPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Tokens that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {tokenFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Tokens
     * const tokens = await prisma.token.findMany()
     * 
     * // Get first 10 Tokens
     * const tokens = await prisma.token.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const tokenWithIdOnly = await prisma.token.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends tokenFindManyArgs>(args?: SelectSubset<T, tokenFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$tokenPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Token.
     * @param {tokenCreateArgs} args - Arguments to create a Token.
     * @example
     * // Create one Token
     * const Token = await prisma.token.create({
     *   data: {
     *     // ... data to create a Token
     *   }
     * })
     * 
     */
    create<T extends tokenCreateArgs>(args: SelectSubset<T, tokenCreateArgs<ExtArgs>>): Prisma__tokenClient<$Result.GetResult<Prisma.$tokenPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Tokens.
     * @param {tokenCreateManyArgs} args - Arguments to create many Tokens.
     * @example
     * // Create many Tokens
     * const token = await prisma.token.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends tokenCreateManyArgs>(args?: SelectSubset<T, tokenCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Token.
     * @param {tokenDeleteArgs} args - Arguments to delete one Token.
     * @example
     * // Delete one Token
     * const Token = await prisma.token.delete({
     *   where: {
     *     // ... filter to delete one Token
     *   }
     * })
     * 
     */
    delete<T extends tokenDeleteArgs>(args: SelectSubset<T, tokenDeleteArgs<ExtArgs>>): Prisma__tokenClient<$Result.GetResult<Prisma.$tokenPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Token.
     * @param {tokenUpdateArgs} args - Arguments to update one Token.
     * @example
     * // Update one Token
     * const token = await prisma.token.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends tokenUpdateArgs>(args: SelectSubset<T, tokenUpdateArgs<ExtArgs>>): Prisma__tokenClient<$Result.GetResult<Prisma.$tokenPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Tokens.
     * @param {tokenDeleteManyArgs} args - Arguments to filter Tokens to delete.
     * @example
     * // Delete a few Tokens
     * const { count } = await prisma.token.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends tokenDeleteManyArgs>(args?: SelectSubset<T, tokenDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Tokens.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {tokenUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Tokens
     * const token = await prisma.token.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends tokenUpdateManyArgs>(args: SelectSubset<T, tokenUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Token.
     * @param {tokenUpsertArgs} args - Arguments to update or create a Token.
     * @example
     * // Update or create a Token
     * const token = await prisma.token.upsert({
     *   create: {
     *     // ... data to create a Token
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Token we want to update
     *   }
     * })
     */
    upsert<T extends tokenUpsertArgs>(args: SelectSubset<T, tokenUpsertArgs<ExtArgs>>): Prisma__tokenClient<$Result.GetResult<Prisma.$tokenPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Tokens.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {tokenCountArgs} args - Arguments to filter Tokens to count.
     * @example
     * // Count the number of Tokens
     * const count = await prisma.token.count({
     *   where: {
     *     // ... the filter for the Tokens we want to count
     *   }
     * })
    **/
    count<T extends tokenCountArgs>(
      args?: Subset<T, tokenCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], TokenCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Token.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TokenAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends TokenAggregateArgs>(args: Subset<T, TokenAggregateArgs>): Prisma.PrismaPromise<GetTokenAggregateType<T>>

    /**
     * Group by Token.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {tokenGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends tokenGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: tokenGroupByArgs['orderBy'] }
        : { orderBy?: tokenGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, tokenGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTokenGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the token model
   */
  readonly fields: tokenFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for token.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__tokenClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the token model
   */ 
  interface tokenFieldRefs {
    readonly id: FieldRef<"token", 'String'>
    readonly schoolId: FieldRef<"token", 'String'>
    readonly key: FieldRef<"token", 'String'>
    readonly createUsername: FieldRef<"token", 'String'>
    readonly createtime: FieldRef<"token", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * token findUnique
   */
  export type tokenFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the token
     */
    select?: tokenSelect<ExtArgs> | null
    /**
     * Filter, which token to fetch.
     */
    where: tokenWhereUniqueInput
  }

  /**
   * token findUniqueOrThrow
   */
  export type tokenFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the token
     */
    select?: tokenSelect<ExtArgs> | null
    /**
     * Filter, which token to fetch.
     */
    where: tokenWhereUniqueInput
  }

  /**
   * token findFirst
   */
  export type tokenFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the token
     */
    select?: tokenSelect<ExtArgs> | null
    /**
     * Filter, which token to fetch.
     */
    where?: tokenWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of tokens to fetch.
     */
    orderBy?: tokenOrderByWithRelationInput | tokenOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for tokens.
     */
    cursor?: tokenWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` tokens from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` tokens.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of tokens.
     */
    distinct?: TokenScalarFieldEnum | TokenScalarFieldEnum[]
  }

  /**
   * token findFirstOrThrow
   */
  export type tokenFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the token
     */
    select?: tokenSelect<ExtArgs> | null
    /**
     * Filter, which token to fetch.
     */
    where?: tokenWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of tokens to fetch.
     */
    orderBy?: tokenOrderByWithRelationInput | tokenOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for tokens.
     */
    cursor?: tokenWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` tokens from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` tokens.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of tokens.
     */
    distinct?: TokenScalarFieldEnum | TokenScalarFieldEnum[]
  }

  /**
   * token findMany
   */
  export type tokenFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the token
     */
    select?: tokenSelect<ExtArgs> | null
    /**
     * Filter, which tokens to fetch.
     */
    where?: tokenWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of tokens to fetch.
     */
    orderBy?: tokenOrderByWithRelationInput | tokenOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing tokens.
     */
    cursor?: tokenWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` tokens from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` tokens.
     */
    skip?: number
    distinct?: TokenScalarFieldEnum | TokenScalarFieldEnum[]
  }

  /**
   * token create
   */
  export type tokenCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the token
     */
    select?: tokenSelect<ExtArgs> | null
    /**
     * The data needed to create a token.
     */
    data: XOR<tokenCreateInput, tokenUncheckedCreateInput>
  }

  /**
   * token createMany
   */
  export type tokenCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many tokens.
     */
    data: tokenCreateManyInput | tokenCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * token update
   */
  export type tokenUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the token
     */
    select?: tokenSelect<ExtArgs> | null
    /**
     * The data needed to update a token.
     */
    data: XOR<tokenUpdateInput, tokenUncheckedUpdateInput>
    /**
     * Choose, which token to update.
     */
    where: tokenWhereUniqueInput
  }

  /**
   * token updateMany
   */
  export type tokenUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update tokens.
     */
    data: XOR<tokenUpdateManyMutationInput, tokenUncheckedUpdateManyInput>
    /**
     * Filter which tokens to update
     */
    where?: tokenWhereInput
  }

  /**
   * token upsert
   */
  export type tokenUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the token
     */
    select?: tokenSelect<ExtArgs> | null
    /**
     * The filter to search for the token to update in case it exists.
     */
    where: tokenWhereUniqueInput
    /**
     * In case the token found by the `where` argument doesn't exist, create a new token with this data.
     */
    create: XOR<tokenCreateInput, tokenUncheckedCreateInput>
    /**
     * In case the token was found with the provided `where` argument, update it with this data.
     */
    update: XOR<tokenUpdateInput, tokenUncheckedUpdateInput>
  }

  /**
   * token delete
   */
  export type tokenDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the token
     */
    select?: tokenSelect<ExtArgs> | null
    /**
     * Filter which token to delete.
     */
    where: tokenWhereUniqueInput
  }

  /**
   * token deleteMany
   */
  export type tokenDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which tokens to delete
     */
    where?: tokenWhereInput
  }

  /**
   * token without action
   */
  export type tokenDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the token
     */
    select?: tokenSelect<ExtArgs> | null
  }


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]


  export const AWS_Policy_RoleScalarFieldEnum: {
    id: 'id',
    assistant_id: 'assistant_id',
    agent_bedrock_policy: 'agent_bedrock_policy',
    agent_kb_schema_policy: 'agent_kb_schema_policy',
    kb_bedrock_policy: 'kb_bedrock_policy',
    kb_aoss_policy: 'kb_aoss_policy',
    kb_s3_policy: 'kb_s3_policy',
    agent_role_name: 'agent_role_name',
    kb_role_name: 'kb_role_name',
    createtime: 'createtime'
  };

  export type AWS_Policy_RoleScalarFieldEnum = (typeof AWS_Policy_RoleScalarFieldEnum)[keyof typeof AWS_Policy_RoleScalarFieldEnum]


  export const Ai_Agent_AssistantsScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    username: 'username',
    agent_sort: 'agent_sort',
    agent_tag: 'agent_tag',
    assistantName: 'assistantName',
    description: 'description',
    prologue: 'prologue',
    headUrl: 'headUrl',
    instructions: 'instructions',
    isRetrieval: 'isRetrieval',
    isCode: 'isCode',
    isGoogle: 'isGoogle',
    isDalleImage: 'isDalleImage',
    functionNames: 'functionNames',
    functionContents: 'functionContents',
    assistant_id: 'assistant_id',
    thread_id: 'thread_id',
    file_ids: 'file_ids',
    file_names: 'file_names',
    isPublish: 'isPublish',
    organize_id: 'organize_id',
    vector_store_id: 'vector_store_id',
    modelType: 'modelType',
    createtime: 'createtime',
    updatetime: 'updatetime',
    a: 'a'
  };

  export type Ai_Agent_AssistantsScalarFieldEnum = (typeof Ai_Agent_AssistantsScalarFieldEnum)[keyof typeof Ai_Agent_AssistantsScalarFieldEnum]


  export const Ai_Agent_ThreadsScalarFieldEnum: {
    id: 'id',
    userId: 'userId',
    assistant_id: 'assistant_id',
    thread_id: 'thread_id',
    createtime: 'createtime',
    session_name: 'session_name'
  };

  export type Ai_Agent_ThreadsScalarFieldEnum = (typeof Ai_Agent_ThreadsScalarFieldEnum)[keyof typeof Ai_Agent_ThreadsScalarFieldEnum]


  export const AssistantScalarFieldEnum: {
    id: 'id',
    uid: 'uid',
    assistant_id: 'assistant_id',
    thread_id: 'thread_id',
    file_ids: 'file_ids',
    vector_store_id: 'vector_store_id',
    createtime: 'createtime'
  };

  export type AssistantScalarFieldEnum = (typeof AssistantScalarFieldEnum)[keyof typeof AssistantScalarFieldEnum]


  export const ChatScalarFieldEnum: {
    id: 'id',
    groupid: 'groupid',
    userid: 'userid',
    username: 'username',
    answer: 'answer',
    problem: 'problem',
    createtime: 'createtime',
    fileid: 'fileid',
    isMindMap: 'isMindMap',
    filename: 'filename',
    session_name: 'session_name',
    scene: 'scene'
  };

  export type ChatScalarFieldEnum = (typeof ChatScalarFieldEnum)[keyof typeof ChatScalarFieldEnum]


  export const DispositionScalarFieldEnum: {
    id: 'id',
    module: 'module',
    disposition_class: 'disposition_class',
    disposition_type: 'disposition_type',
    disposition_style: 'disposition_style',
    disposition_theme: 'disposition_theme',
    user_id: 'user_id',
    create_time: 'create_time'
  };

  export type DispositionScalarFieldEnum = (typeof DispositionScalarFieldEnum)[keyof typeof DispositionScalarFieldEnum]


  export const GroupScalarFieldEnum: {
    id: 'id',
    name: 'name',
    userid: 'userid',
    createtime: 'createtime'
  };

  export type GroupScalarFieldEnum = (typeof GroupScalarFieldEnum)[keyof typeof GroupScalarFieldEnum]


  export const GroupFileScalarFieldEnum: {
    id: 'id',
    userid: 'userid',
    fileurl: 'fileurl',
    filename: 'filename',
    groupid: 'groupid',
    abstract: 'abstract',
    assistantFileId: 'assistantFileId',
    modelType: 'modelType',
    createtime: 'createtime'
  };

  export type GroupFileScalarFieldEnum = (typeof GroupFileScalarFieldEnum)[keyof typeof GroupFileScalarFieldEnum]


  export const InvitationCodeScalarFieldEnum: {
    id: 'id',
    cid: 'cid',
    themeId: 'themeId',
    type: 'type',
    invitationCode: 'invitationCode',
    createtime: 'createtime'
  };

  export type InvitationCodeScalarFieldEnum = (typeof InvitationCodeScalarFieldEnum)[keyof typeof InvitationCodeScalarFieldEnum]


  export const Ai_agent_park_sessionScalarFieldEnum: {
    id: 'id',
    session_name: 'session_name',
    user_id: 'user_id',
    isCocoNote: 'isCocoNote',
    createtime: 'createtime',
    work_area_text: 'work_area_text',
    scene: 'scene'
  };

  export type Ai_agent_park_sessionScalarFieldEnum = (typeof Ai_agent_park_sessionScalarFieldEnum)[keyof typeof Ai_agent_park_sessionScalarFieldEnum]


  export const Classroom_ob_commentScalarFieldEnum: {
    id: 'id',
    module_id: 'module_id',
    module_name: 'module_name',
    nickname: 'nickname',
    commentContent: 'commentContent',
    audit_status: 'audit_status',
    t_id: 't_id',
    create_time: 'create_time'
  };

  export type Classroom_ob_commentScalarFieldEnum = (typeof Classroom_ob_commentScalarFieldEnum)[keyof typeof Classroom_ob_commentScalarFieldEnum]


  export const Classroom_observationScalarFieldEnum: {
    id: 'id',
    jsonData: 'jsonData',
    Type: 'Type',
    tIndex: 'tIndex',
    tId: 'tId',
    createtime: 'createtime',
    like_num: 'like_num',
    like_data: 'like_data',
    userid: 'userid',
    isdel: 'isdel',
    limitData: 'limitData'
  };

  export type Classroom_observationScalarFieldEnum = (typeof Classroom_observationScalarFieldEnum)[keyof typeof Classroom_observationScalarFieldEnum]


  export const Course_resourceScalarFieldEnum: {
    id: 'id',
    subject: 'subject',
    grade: 'grade',
    textbook: 'textbook',
    book_type: 'book_type',
    unit: 'unit',
    period: 'period',
    unit_content: 'unit_content',
    course_content: 'course_content'
  };

  export type Course_resourceScalarFieldEnum = (typeof Course_resourceScalarFieldEnum)[keyof typeof Course_resourceScalarFieldEnum]


  export const Knowledge_construction_docScalarFieldEnum: {
    id: 'id',
    muti_id: 'muti_id',
    user_id: 'user_id',
    session_id: 'session_id',
    content: 'content',
    create_time: 'create_time'
  };

  export type Knowledge_construction_docScalarFieldEnum = (typeof Knowledge_construction_docScalarFieldEnum)[keyof typeof Knowledge_construction_docScalarFieldEnum]


  export const Meeting_trickScalarFieldEnum: {
    id: 'id',
    createtime: 'createtime',
    userid: 'userid',
    meeting_name: 'meeting_name',
    meeting_original: 'meeting_original',
    meeting_minutes: 'meeting_minutes',
    audio_url: 'audio_url',
    duration: 'duration',
    ab: 'ab'
  };

  export type Meeting_trickScalarFieldEnum = (typeof Meeting_trickScalarFieldEnum)[keyof typeof Meeting_trickScalarFieldEnum]


  export const Meeting_trick_chatScalarFieldEnum: {
    id: 'id',
    meeting_id: 'meeting_id',
    createtime: 'createtime',
    user_content: 'user_content',
    ai_content: 'ai_content'
  };

  export type Meeting_trick_chatScalarFieldEnum = (typeof Meeting_trick_chatScalarFieldEnum)[keyof typeof Meeting_trick_chatScalarFieldEnum]


  export const Muti_agent_listScalarFieldEnum: {
    id: 'id',
    userid: 'userid',
    username: 'username',
    muti_name: 'muti_name',
    description: 'description',
    isPublish: 'isPublish',
    organizeid: 'organizeid',
    content: 'content',
    create_time: 'create_time',
    knowledge_construction: 'knowledge_construction'
  };

  export type Muti_agent_listScalarFieldEnum = (typeof Muti_agent_listScalarFieldEnum)[keyof typeof Muti_agent_listScalarFieldEnum]


  export const Park_chat_file_listScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    file_names: 'file_names',
    file_ids: 'file_ids',
    create_time: 'create_time',
    file_urls: 'file_urls'
  };

  export type Park_chat_file_listScalarFieldEnum = (typeof Park_chat_file_listScalarFieldEnum)[keyof typeof Park_chat_file_listScalarFieldEnum]


  export const TokenScalarFieldEnum: {
    id: 'id',
    schoolId: 'schoolId',
    key: 'key',
    createUsername: 'createUsername',
    createtime: 'createtime'
  };

  export type TokenScalarFieldEnum = (typeof TokenScalarFieldEnum)[keyof typeof TokenScalarFieldEnum]


  export const SortOrder: {
    asc: 'asc',
    desc: 'desc'
  };

  export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

  export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]


  /**
   * Field references 
   */


  /**
   * Reference to a field of type 'String'
   */
  export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
    


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * 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 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    
  /**
   * Deep Input Types
   */


  export type AWS_Policy_RoleWhereInput = {
    AND?: AWS_Policy_RoleWhereInput | AWS_Policy_RoleWhereInput[]
    OR?: AWS_Policy_RoleWhereInput[]
    NOT?: AWS_Policy_RoleWhereInput | AWS_Policy_RoleWhereInput[]
    id?: StringFilter<"AWS_Policy_Role"> | string
    assistant_id?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    agent_bedrock_policy?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    agent_kb_schema_policy?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    kb_bedrock_policy?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    kb_aoss_policy?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    kb_s3_policy?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    agent_role_name?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    kb_role_name?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    createtime?: DateTimeNullableFilter<"AWS_Policy_Role"> | Date | string | null
  }

  export type AWS_Policy_RoleOrderByWithRelationInput = {
    id?: SortOrder
    assistant_id?: SortOrderInput | SortOrder
    agent_bedrock_policy?: SortOrderInput | SortOrder
    agent_kb_schema_policy?: SortOrderInput | SortOrder
    kb_bedrock_policy?: SortOrderInput | SortOrder
    kb_aoss_policy?: SortOrderInput | SortOrder
    kb_s3_policy?: SortOrderInput | SortOrder
    agent_role_name?: SortOrderInput | SortOrder
    kb_role_name?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
  }

  export type AWS_Policy_RoleWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AWS_Policy_RoleWhereInput | AWS_Policy_RoleWhereInput[]
    OR?: AWS_Policy_RoleWhereInput[]
    NOT?: AWS_Policy_RoleWhereInput | AWS_Policy_RoleWhereInput[]
    assistant_id?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    agent_bedrock_policy?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    agent_kb_schema_policy?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    kb_bedrock_policy?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    kb_aoss_policy?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    kb_s3_policy?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    agent_role_name?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    kb_role_name?: StringNullableFilter<"AWS_Policy_Role"> | string | null
    createtime?: DateTimeNullableFilter<"AWS_Policy_Role"> | Date | string | null
  }, "id">

  export type AWS_Policy_RoleOrderByWithAggregationInput = {
    id?: SortOrder
    assistant_id?: SortOrderInput | SortOrder
    agent_bedrock_policy?: SortOrderInput | SortOrder
    agent_kb_schema_policy?: SortOrderInput | SortOrder
    kb_bedrock_policy?: SortOrderInput | SortOrder
    kb_aoss_policy?: SortOrderInput | SortOrder
    kb_s3_policy?: SortOrderInput | SortOrder
    agent_role_name?: SortOrderInput | SortOrder
    kb_role_name?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    _count?: AWS_Policy_RoleCountOrderByAggregateInput
    _max?: AWS_Policy_RoleMaxOrderByAggregateInput
    _min?: AWS_Policy_RoleMinOrderByAggregateInput
  }

  export type AWS_Policy_RoleScalarWhereWithAggregatesInput = {
    AND?: AWS_Policy_RoleScalarWhereWithAggregatesInput | AWS_Policy_RoleScalarWhereWithAggregatesInput[]
    OR?: AWS_Policy_RoleScalarWhereWithAggregatesInput[]
    NOT?: AWS_Policy_RoleScalarWhereWithAggregatesInput | AWS_Policy_RoleScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"AWS_Policy_Role"> | string
    assistant_id?: StringNullableWithAggregatesFilter<"AWS_Policy_Role"> | string | null
    agent_bedrock_policy?: StringNullableWithAggregatesFilter<"AWS_Policy_Role"> | string | null
    agent_kb_schema_policy?: StringNullableWithAggregatesFilter<"AWS_Policy_Role"> | string | null
    kb_bedrock_policy?: StringNullableWithAggregatesFilter<"AWS_Policy_Role"> | string | null
    kb_aoss_policy?: StringNullableWithAggregatesFilter<"AWS_Policy_Role"> | string | null
    kb_s3_policy?: StringNullableWithAggregatesFilter<"AWS_Policy_Role"> | string | null
    agent_role_name?: StringNullableWithAggregatesFilter<"AWS_Policy_Role"> | string | null
    kb_role_name?: StringNullableWithAggregatesFilter<"AWS_Policy_Role"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"AWS_Policy_Role"> | Date | string | null
  }

  export type Ai_Agent_AssistantsWhereInput = {
    AND?: Ai_Agent_AssistantsWhereInput | Ai_Agent_AssistantsWhereInput[]
    OR?: Ai_Agent_AssistantsWhereInput[]
    NOT?: Ai_Agent_AssistantsWhereInput | Ai_Agent_AssistantsWhereInput[]
    id?: StringFilter<"Ai_Agent_Assistants"> | string
    userId?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    username?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    agent_sort?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    agent_tag?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    assistantName?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    description?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    prologue?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    headUrl?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    instructions?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    isRetrieval?: BoolNullableFilter<"Ai_Agent_Assistants"> | boolean | null
    isCode?: BoolNullableFilter<"Ai_Agent_Assistants"> | boolean | null
    isGoogle?: BoolNullableFilter<"Ai_Agent_Assistants"> | boolean | null
    isDalleImage?: BoolNullableFilter<"Ai_Agent_Assistants"> | boolean | null
    functionNames?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    functionContents?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    assistant_id?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    thread_id?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    file_ids?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    file_names?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    isPublish?: BoolNullableFilter<"Ai_Agent_Assistants"> | boolean | null
    organize_id?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    vector_store_id?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    modelType?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    createtime?: DateTimeNullableFilter<"Ai_Agent_Assistants"> | Date | string | null
    updatetime?: DateTimeNullableFilter<"Ai_Agent_Assistants"> | Date | string | null
    a?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
  }

  export type Ai_Agent_AssistantsOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrderInput | SortOrder
    username?: SortOrderInput | SortOrder
    agent_sort?: SortOrderInput | SortOrder
    agent_tag?: SortOrderInput | SortOrder
    assistantName?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    prologue?: SortOrderInput | SortOrder
    headUrl?: SortOrderInput | SortOrder
    instructions?: SortOrderInput | SortOrder
    isRetrieval?: SortOrderInput | SortOrder
    isCode?: SortOrderInput | SortOrder
    isGoogle?: SortOrderInput | SortOrder
    isDalleImage?: SortOrderInput | SortOrder
    functionNames?: SortOrderInput | SortOrder
    functionContents?: SortOrderInput | SortOrder
    assistant_id?: SortOrderInput | SortOrder
    thread_id?: SortOrderInput | SortOrder
    file_ids?: SortOrderInput | SortOrder
    file_names?: SortOrderInput | SortOrder
    isPublish?: SortOrderInput | SortOrder
    organize_id?: SortOrderInput | SortOrder
    vector_store_id?: SortOrderInput | SortOrder
    modelType?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    updatetime?: SortOrderInput | SortOrder
    a?: SortOrderInput | SortOrder
  }

  export type Ai_Agent_AssistantsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: Ai_Agent_AssistantsWhereInput | Ai_Agent_AssistantsWhereInput[]
    OR?: Ai_Agent_AssistantsWhereInput[]
    NOT?: Ai_Agent_AssistantsWhereInput | Ai_Agent_AssistantsWhereInput[]
    userId?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    username?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    agent_sort?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    agent_tag?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    assistantName?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    description?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    prologue?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    headUrl?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    instructions?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    isRetrieval?: BoolNullableFilter<"Ai_Agent_Assistants"> | boolean | null
    isCode?: BoolNullableFilter<"Ai_Agent_Assistants"> | boolean | null
    isGoogle?: BoolNullableFilter<"Ai_Agent_Assistants"> | boolean | null
    isDalleImage?: BoolNullableFilter<"Ai_Agent_Assistants"> | boolean | null
    functionNames?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    functionContents?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    assistant_id?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    thread_id?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    file_ids?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    file_names?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    isPublish?: BoolNullableFilter<"Ai_Agent_Assistants"> | boolean | null
    organize_id?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    vector_store_id?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    modelType?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
    createtime?: DateTimeNullableFilter<"Ai_Agent_Assistants"> | Date | string | null
    updatetime?: DateTimeNullableFilter<"Ai_Agent_Assistants"> | Date | string | null
    a?: StringNullableFilter<"Ai_Agent_Assistants"> | string | null
  }, "id">

  export type Ai_Agent_AssistantsOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrderInput | SortOrder
    username?: SortOrderInput | SortOrder
    agent_sort?: SortOrderInput | SortOrder
    agent_tag?: SortOrderInput | SortOrder
    assistantName?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    prologue?: SortOrderInput | SortOrder
    headUrl?: SortOrderInput | SortOrder
    instructions?: SortOrderInput | SortOrder
    isRetrieval?: SortOrderInput | SortOrder
    isCode?: SortOrderInput | SortOrder
    isGoogle?: SortOrderInput | SortOrder
    isDalleImage?: SortOrderInput | SortOrder
    functionNames?: SortOrderInput | SortOrder
    functionContents?: SortOrderInput | SortOrder
    assistant_id?: SortOrderInput | SortOrder
    thread_id?: SortOrderInput | SortOrder
    file_ids?: SortOrderInput | SortOrder
    file_names?: SortOrderInput | SortOrder
    isPublish?: SortOrderInput | SortOrder
    organize_id?: SortOrderInput | SortOrder
    vector_store_id?: SortOrderInput | SortOrder
    modelType?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    updatetime?: SortOrderInput | SortOrder
    a?: SortOrderInput | SortOrder
    _count?: Ai_Agent_AssistantsCountOrderByAggregateInput
    _max?: Ai_Agent_AssistantsMaxOrderByAggregateInput
    _min?: Ai_Agent_AssistantsMinOrderByAggregateInput
  }

  export type Ai_Agent_AssistantsScalarWhereWithAggregatesInput = {
    AND?: Ai_Agent_AssistantsScalarWhereWithAggregatesInput | Ai_Agent_AssistantsScalarWhereWithAggregatesInput[]
    OR?: Ai_Agent_AssistantsScalarWhereWithAggregatesInput[]
    NOT?: Ai_Agent_AssistantsScalarWhereWithAggregatesInput | Ai_Agent_AssistantsScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Ai_Agent_Assistants"> | string
    userId?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    username?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    agent_sort?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    agent_tag?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    assistantName?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    description?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    prologue?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    headUrl?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    instructions?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    isRetrieval?: BoolNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | boolean | null
    isCode?: BoolNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | boolean | null
    isGoogle?: BoolNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | boolean | null
    isDalleImage?: BoolNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | boolean | null
    functionNames?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    functionContents?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    assistant_id?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    thread_id?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    file_ids?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    file_names?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    isPublish?: BoolNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | boolean | null
    organize_id?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    vector_store_id?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    modelType?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | Date | string | null
    updatetime?: DateTimeNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | Date | string | null
    a?: StringNullableWithAggregatesFilter<"Ai_Agent_Assistants"> | string | null
  }

  export type Ai_Agent_ThreadsWhereInput = {
    AND?: Ai_Agent_ThreadsWhereInput | Ai_Agent_ThreadsWhereInput[]
    OR?: Ai_Agent_ThreadsWhereInput[]
    NOT?: Ai_Agent_ThreadsWhereInput | Ai_Agent_ThreadsWhereInput[]
    id?: StringFilter<"Ai_Agent_Threads"> | string
    userId?: StringNullableFilter<"Ai_Agent_Threads"> | string | null
    assistant_id?: StringNullableFilter<"Ai_Agent_Threads"> | string | null
    thread_id?: StringNullableFilter<"Ai_Agent_Threads"> | string | null
    createtime?: DateTimeNullableFilter<"Ai_Agent_Threads"> | Date | string | null
    session_name?: StringFilter<"Ai_Agent_Threads"> | string
  }

  export type Ai_Agent_ThreadsOrderByWithRelationInput = {
    id?: SortOrder
    userId?: SortOrderInput | SortOrder
    assistant_id?: SortOrderInput | SortOrder
    thread_id?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    session_name?: SortOrder
  }

  export type Ai_Agent_ThreadsWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: Ai_Agent_ThreadsWhereInput | Ai_Agent_ThreadsWhereInput[]
    OR?: Ai_Agent_ThreadsWhereInput[]
    NOT?: Ai_Agent_ThreadsWhereInput | Ai_Agent_ThreadsWhereInput[]
    userId?: StringNullableFilter<"Ai_Agent_Threads"> | string | null
    assistant_id?: StringNullableFilter<"Ai_Agent_Threads"> | string | null
    thread_id?: StringNullableFilter<"Ai_Agent_Threads"> | string | null
    createtime?: DateTimeNullableFilter<"Ai_Agent_Threads"> | Date | string | null
    session_name?: StringFilter<"Ai_Agent_Threads"> | string
  }, "id">

  export type Ai_Agent_ThreadsOrderByWithAggregationInput = {
    id?: SortOrder
    userId?: SortOrderInput | SortOrder
    assistant_id?: SortOrderInput | SortOrder
    thread_id?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    session_name?: SortOrder
    _count?: Ai_Agent_ThreadsCountOrderByAggregateInput
    _max?: Ai_Agent_ThreadsMaxOrderByAggregateInput
    _min?: Ai_Agent_ThreadsMinOrderByAggregateInput
  }

  export type Ai_Agent_ThreadsScalarWhereWithAggregatesInput = {
    AND?: Ai_Agent_ThreadsScalarWhereWithAggregatesInput | Ai_Agent_ThreadsScalarWhereWithAggregatesInput[]
    OR?: Ai_Agent_ThreadsScalarWhereWithAggregatesInput[]
    NOT?: Ai_Agent_ThreadsScalarWhereWithAggregatesInput | Ai_Agent_ThreadsScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Ai_Agent_Threads"> | string
    userId?: StringNullableWithAggregatesFilter<"Ai_Agent_Threads"> | string | null
    assistant_id?: StringNullableWithAggregatesFilter<"Ai_Agent_Threads"> | string | null
    thread_id?: StringNullableWithAggregatesFilter<"Ai_Agent_Threads"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"Ai_Agent_Threads"> | Date | string | null
    session_name?: StringWithAggregatesFilter<"Ai_Agent_Threads"> | string
  }

  export type AssistantWhereInput = {
    AND?: AssistantWhereInput | AssistantWhereInput[]
    OR?: AssistantWhereInput[]
    NOT?: AssistantWhereInput | AssistantWhereInput[]
    id?: StringFilter<"Assistant"> | string
    uid?: StringNullableFilter<"Assistant"> | string | null
    assistant_id?: StringNullableFilter<"Assistant"> | string | null
    thread_id?: StringNullableFilter<"Assistant"> | string | null
    file_ids?: StringNullableFilter<"Assistant"> | string | null
    vector_store_id?: StringNullableFilter<"Assistant"> | string | null
    createtime?: DateTimeNullableFilter<"Assistant"> | Date | string | null
  }

  export type AssistantOrderByWithRelationInput = {
    id?: SortOrder
    uid?: SortOrderInput | SortOrder
    assistant_id?: SortOrderInput | SortOrder
    thread_id?: SortOrderInput | SortOrder
    file_ids?: SortOrderInput | SortOrder
    vector_store_id?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
  }

  export type AssistantWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AssistantWhereInput | AssistantWhereInput[]
    OR?: AssistantWhereInput[]
    NOT?: AssistantWhereInput | AssistantWhereInput[]
    uid?: StringNullableFilter<"Assistant"> | string | null
    assistant_id?: StringNullableFilter<"Assistant"> | string | null
    thread_id?: StringNullableFilter<"Assistant"> | string | null
    file_ids?: StringNullableFilter<"Assistant"> | string | null
    vector_store_id?: StringNullableFilter<"Assistant"> | string | null
    createtime?: DateTimeNullableFilter<"Assistant"> | Date | string | null
  }, "id">

  export type AssistantOrderByWithAggregationInput = {
    id?: SortOrder
    uid?: SortOrderInput | SortOrder
    assistant_id?: SortOrderInput | SortOrder
    thread_id?: SortOrderInput | SortOrder
    file_ids?: SortOrderInput | SortOrder
    vector_store_id?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    _count?: AssistantCountOrderByAggregateInput
    _max?: AssistantMaxOrderByAggregateInput
    _min?: AssistantMinOrderByAggregateInput
  }

  export type AssistantScalarWhereWithAggregatesInput = {
    AND?: AssistantScalarWhereWithAggregatesInput | AssistantScalarWhereWithAggregatesInput[]
    OR?: AssistantScalarWhereWithAggregatesInput[]
    NOT?: AssistantScalarWhereWithAggregatesInput | AssistantScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Assistant"> | string
    uid?: StringNullableWithAggregatesFilter<"Assistant"> | string | null
    assistant_id?: StringNullableWithAggregatesFilter<"Assistant"> | string | null
    thread_id?: StringNullableWithAggregatesFilter<"Assistant"> | string | null
    file_ids?: StringNullableWithAggregatesFilter<"Assistant"> | string | null
    vector_store_id?: StringNullableWithAggregatesFilter<"Assistant"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"Assistant"> | Date | string | null
  }

  export type ChatWhereInput = {
    AND?: ChatWhereInput | ChatWhereInput[]
    OR?: ChatWhereInput[]
    NOT?: ChatWhereInput | ChatWhereInput[]
    id?: StringFilter<"Chat"> | string
    groupid?: StringNullableFilter<"Chat"> | string | null
    userid?: StringNullableFilter<"Chat"> | string | null
    username?: StringNullableFilter<"Chat"> | string | null
    answer?: StringNullableFilter<"Chat"> | string | null
    problem?: StringNullableFilter<"Chat"> | string | null
    createtime?: DateTimeNullableFilter<"Chat"> | Date | string | null
    fileid?: StringNullableFilter<"Chat"> | string | null
    isMindMap?: IntNullableFilter<"Chat"> | number | null
    filename?: StringNullableFilter<"Chat"> | string | null
    session_name?: StringFilter<"Chat"> | string
    scene?: StringNullableFilter<"Chat"> | string | null
  }

  export type ChatOrderByWithRelationInput = {
    id?: SortOrder
    groupid?: SortOrderInput | SortOrder
    userid?: SortOrderInput | SortOrder
    username?: SortOrderInput | SortOrder
    answer?: SortOrderInput | SortOrder
    problem?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    fileid?: SortOrderInput | SortOrder
    isMindMap?: SortOrderInput | SortOrder
    filename?: SortOrderInput | SortOrder
    session_name?: SortOrder
    scene?: SortOrderInput | SortOrder
  }

  export type ChatWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ChatWhereInput | ChatWhereInput[]
    OR?: ChatWhereInput[]
    NOT?: ChatWhereInput | ChatWhereInput[]
    groupid?: StringNullableFilter<"Chat"> | string | null
    userid?: StringNullableFilter<"Chat"> | string | null
    username?: StringNullableFilter<"Chat"> | string | null
    answer?: StringNullableFilter<"Chat"> | string | null
    problem?: StringNullableFilter<"Chat"> | string | null
    createtime?: DateTimeNullableFilter<"Chat"> | Date | string | null
    fileid?: StringNullableFilter<"Chat"> | string | null
    isMindMap?: IntNullableFilter<"Chat"> | number | null
    filename?: StringNullableFilter<"Chat"> | string | null
    session_name?: StringFilter<"Chat"> | string
    scene?: StringNullableFilter<"Chat"> | string | null
  }, "id">

  export type ChatOrderByWithAggregationInput = {
    id?: SortOrder
    groupid?: SortOrderInput | SortOrder
    userid?: SortOrderInput | SortOrder
    username?: SortOrderInput | SortOrder
    answer?: SortOrderInput | SortOrder
    problem?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    fileid?: SortOrderInput | SortOrder
    isMindMap?: SortOrderInput | SortOrder
    filename?: SortOrderInput | SortOrder
    session_name?: SortOrder
    scene?: SortOrderInput | SortOrder
    _count?: ChatCountOrderByAggregateInput
    _avg?: ChatAvgOrderByAggregateInput
    _max?: ChatMaxOrderByAggregateInput
    _min?: ChatMinOrderByAggregateInput
    _sum?: ChatSumOrderByAggregateInput
  }

  export type ChatScalarWhereWithAggregatesInput = {
    AND?: ChatScalarWhereWithAggregatesInput | ChatScalarWhereWithAggregatesInput[]
    OR?: ChatScalarWhereWithAggregatesInput[]
    NOT?: ChatScalarWhereWithAggregatesInput | ChatScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Chat"> | string
    groupid?: StringNullableWithAggregatesFilter<"Chat"> | string | null
    userid?: StringNullableWithAggregatesFilter<"Chat"> | string | null
    username?: StringNullableWithAggregatesFilter<"Chat"> | string | null
    answer?: StringNullableWithAggregatesFilter<"Chat"> | string | null
    problem?: StringNullableWithAggregatesFilter<"Chat"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"Chat"> | Date | string | null
    fileid?: StringNullableWithAggregatesFilter<"Chat"> | string | null
    isMindMap?: IntNullableWithAggregatesFilter<"Chat"> | number | null
    filename?: StringNullableWithAggregatesFilter<"Chat"> | string | null
    session_name?: StringWithAggregatesFilter<"Chat"> | string
    scene?: StringNullableWithAggregatesFilter<"Chat"> | string | null
  }

  export type DispositionWhereInput = {
    AND?: DispositionWhereInput | DispositionWhereInput[]
    OR?: DispositionWhereInput[]
    NOT?: DispositionWhereInput | DispositionWhereInput[]
    id?: StringFilter<"Disposition"> | string
    module?: StringNullableFilter<"Disposition"> | string | null
    disposition_class?: StringNullableFilter<"Disposition"> | string | null
    disposition_type?: StringNullableFilter<"Disposition"> | string | null
    disposition_style?: StringNullableFilter<"Disposition"> | string | null
    disposition_theme?: StringNullableFilter<"Disposition"> | string | null
    user_id?: StringNullableFilter<"Disposition"> | string | null
    create_time?: DateTimeNullableFilter<"Disposition"> | Date | string | null
  }

  export type DispositionOrderByWithRelationInput = {
    id?: SortOrder
    module?: SortOrderInput | SortOrder
    disposition_class?: SortOrderInput | SortOrder
    disposition_type?: SortOrderInput | SortOrder
    disposition_style?: SortOrderInput | SortOrder
    disposition_theme?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    create_time?: SortOrderInput | SortOrder
  }

  export type DispositionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: DispositionWhereInput | DispositionWhereInput[]
    OR?: DispositionWhereInput[]
    NOT?: DispositionWhereInput | DispositionWhereInput[]
    module?: StringNullableFilter<"Disposition"> | string | null
    disposition_class?: StringNullableFilter<"Disposition"> | string | null
    disposition_type?: StringNullableFilter<"Disposition"> | string | null
    disposition_style?: StringNullableFilter<"Disposition"> | string | null
    disposition_theme?: StringNullableFilter<"Disposition"> | string | null
    user_id?: StringNullableFilter<"Disposition"> | string | null
    create_time?: DateTimeNullableFilter<"Disposition"> | Date | string | null
  }, "id">

  export type DispositionOrderByWithAggregationInput = {
    id?: SortOrder
    module?: SortOrderInput | SortOrder
    disposition_class?: SortOrderInput | SortOrder
    disposition_type?: SortOrderInput | SortOrder
    disposition_style?: SortOrderInput | SortOrder
    disposition_theme?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    create_time?: SortOrderInput | SortOrder
    _count?: DispositionCountOrderByAggregateInput
    _max?: DispositionMaxOrderByAggregateInput
    _min?: DispositionMinOrderByAggregateInput
  }

  export type DispositionScalarWhereWithAggregatesInput = {
    AND?: DispositionScalarWhereWithAggregatesInput | DispositionScalarWhereWithAggregatesInput[]
    OR?: DispositionScalarWhereWithAggregatesInput[]
    NOT?: DispositionScalarWhereWithAggregatesInput | DispositionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Disposition"> | string
    module?: StringNullableWithAggregatesFilter<"Disposition"> | string | null
    disposition_class?: StringNullableWithAggregatesFilter<"Disposition"> | string | null
    disposition_type?: StringNullableWithAggregatesFilter<"Disposition"> | string | null
    disposition_style?: StringNullableWithAggregatesFilter<"Disposition"> | string | null
    disposition_theme?: StringNullableWithAggregatesFilter<"Disposition"> | string | null
    user_id?: StringNullableWithAggregatesFilter<"Disposition"> | string | null
    create_time?: DateTimeNullableWithAggregatesFilter<"Disposition"> | Date | string | null
  }

  export type GroupWhereInput = {
    AND?: GroupWhereInput | GroupWhereInput[]
    OR?: GroupWhereInput[]
    NOT?: GroupWhereInput | GroupWhereInput[]
    id?: StringFilter<"Group"> | string
    name?: StringNullableFilter<"Group"> | string | null
    userid?: StringNullableFilter<"Group"> | string | null
    createtime?: DateTimeNullableFilter<"Group"> | Date | string | null
  }

  export type GroupOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    userid?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
  }

  export type GroupWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: GroupWhereInput | GroupWhereInput[]
    OR?: GroupWhereInput[]
    NOT?: GroupWhereInput | GroupWhereInput[]
    name?: StringNullableFilter<"Group"> | string | null
    userid?: StringNullableFilter<"Group"> | string | null
    createtime?: DateTimeNullableFilter<"Group"> | Date | string | null
  }, "id">

  export type GroupOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    userid?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    _count?: GroupCountOrderByAggregateInput
    _max?: GroupMaxOrderByAggregateInput
    _min?: GroupMinOrderByAggregateInput
  }

  export type GroupScalarWhereWithAggregatesInput = {
    AND?: GroupScalarWhereWithAggregatesInput | GroupScalarWhereWithAggregatesInput[]
    OR?: GroupScalarWhereWithAggregatesInput[]
    NOT?: GroupScalarWhereWithAggregatesInput | GroupScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Group"> | string
    name?: StringNullableWithAggregatesFilter<"Group"> | string | null
    userid?: StringNullableWithAggregatesFilter<"Group"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"Group"> | Date | string | null
  }

  export type GroupFileWhereInput = {
    AND?: GroupFileWhereInput | GroupFileWhereInput[]
    OR?: GroupFileWhereInput[]
    NOT?: GroupFileWhereInput | GroupFileWhereInput[]
    id?: StringFilter<"GroupFile"> | string
    userid?: StringNullableFilter<"GroupFile"> | string | null
    fileurl?: StringNullableFilter<"GroupFile"> | string | null
    filename?: StringNullableFilter<"GroupFile"> | string | null
    groupid?: StringNullableFilter<"GroupFile"> | string | null
    abstract?: StringNullableFilter<"GroupFile"> | string | null
    assistantFileId?: StringNullableFilter<"GroupFile"> | string | null
    modelType?: StringNullableFilter<"GroupFile"> | string | null
    createtime?: DateTimeNullableFilter<"GroupFile"> | Date | string | null
  }

  export type GroupFileOrderByWithRelationInput = {
    id?: SortOrder
    userid?: SortOrderInput | SortOrder
    fileurl?: SortOrderInput | SortOrder
    filename?: SortOrderInput | SortOrder
    groupid?: SortOrderInput | SortOrder
    abstract?: SortOrderInput | SortOrder
    assistantFileId?: SortOrderInput | SortOrder
    modelType?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
  }

  export type GroupFileWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: GroupFileWhereInput | GroupFileWhereInput[]
    OR?: GroupFileWhereInput[]
    NOT?: GroupFileWhereInput | GroupFileWhereInput[]
    userid?: StringNullableFilter<"GroupFile"> | string | null
    fileurl?: StringNullableFilter<"GroupFile"> | string | null
    filename?: StringNullableFilter<"GroupFile"> | string | null
    groupid?: StringNullableFilter<"GroupFile"> | string | null
    abstract?: StringNullableFilter<"GroupFile"> | string | null
    assistantFileId?: StringNullableFilter<"GroupFile"> | string | null
    modelType?: StringNullableFilter<"GroupFile"> | string | null
    createtime?: DateTimeNullableFilter<"GroupFile"> | Date | string | null
  }, "id">

  export type GroupFileOrderByWithAggregationInput = {
    id?: SortOrder
    userid?: SortOrderInput | SortOrder
    fileurl?: SortOrderInput | SortOrder
    filename?: SortOrderInput | SortOrder
    groupid?: SortOrderInput | SortOrder
    abstract?: SortOrderInput | SortOrder
    assistantFileId?: SortOrderInput | SortOrder
    modelType?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    _count?: GroupFileCountOrderByAggregateInput
    _max?: GroupFileMaxOrderByAggregateInput
    _min?: GroupFileMinOrderByAggregateInput
  }

  export type GroupFileScalarWhereWithAggregatesInput = {
    AND?: GroupFileScalarWhereWithAggregatesInput | GroupFileScalarWhereWithAggregatesInput[]
    OR?: GroupFileScalarWhereWithAggregatesInput[]
    NOT?: GroupFileScalarWhereWithAggregatesInput | GroupFileScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"GroupFile"> | string
    userid?: StringNullableWithAggregatesFilter<"GroupFile"> | string | null
    fileurl?: StringNullableWithAggregatesFilter<"GroupFile"> | string | null
    filename?: StringNullableWithAggregatesFilter<"GroupFile"> | string | null
    groupid?: StringNullableWithAggregatesFilter<"GroupFile"> | string | null
    abstract?: StringNullableWithAggregatesFilter<"GroupFile"> | string | null
    assistantFileId?: StringNullableWithAggregatesFilter<"GroupFile"> | string | null
    modelType?: StringNullableWithAggregatesFilter<"GroupFile"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"GroupFile"> | Date | string | null
  }

  export type InvitationCodeWhereInput = {
    AND?: InvitationCodeWhereInput | InvitationCodeWhereInput[]
    OR?: InvitationCodeWhereInput[]
    NOT?: InvitationCodeWhereInput | InvitationCodeWhereInput[]
    id?: StringFilter<"InvitationCode"> | string
    cid?: StringNullableFilter<"InvitationCode"> | string | null
    themeId?: StringNullableFilter<"InvitationCode"> | string | null
    type?: IntNullableFilter<"InvitationCode"> | number | null
    invitationCode?: StringNullableFilter<"InvitationCode"> | string | null
    createtime?: DateTimeNullableFilter<"InvitationCode"> | Date | string | null
  }

  export type InvitationCodeOrderByWithRelationInput = {
    id?: SortOrder
    cid?: SortOrderInput | SortOrder
    themeId?: SortOrderInput | SortOrder
    type?: SortOrderInput | SortOrder
    invitationCode?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
  }

  export type InvitationCodeWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: InvitationCodeWhereInput | InvitationCodeWhereInput[]
    OR?: InvitationCodeWhereInput[]
    NOT?: InvitationCodeWhereInput | InvitationCodeWhereInput[]
    cid?: StringNullableFilter<"InvitationCode"> | string | null
    themeId?: StringNullableFilter<"InvitationCode"> | string | null
    type?: IntNullableFilter<"InvitationCode"> | number | null
    invitationCode?: StringNullableFilter<"InvitationCode"> | string | null
    createtime?: DateTimeNullableFilter<"InvitationCode"> | Date | string | null
  }, "id">

  export type InvitationCodeOrderByWithAggregationInput = {
    id?: SortOrder
    cid?: SortOrderInput | SortOrder
    themeId?: SortOrderInput | SortOrder
    type?: SortOrderInput | SortOrder
    invitationCode?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    _count?: InvitationCodeCountOrderByAggregateInput
    _avg?: InvitationCodeAvgOrderByAggregateInput
    _max?: InvitationCodeMaxOrderByAggregateInput
    _min?: InvitationCodeMinOrderByAggregateInput
    _sum?: InvitationCodeSumOrderByAggregateInput
  }

  export type InvitationCodeScalarWhereWithAggregatesInput = {
    AND?: InvitationCodeScalarWhereWithAggregatesInput | InvitationCodeScalarWhereWithAggregatesInput[]
    OR?: InvitationCodeScalarWhereWithAggregatesInput[]
    NOT?: InvitationCodeScalarWhereWithAggregatesInput | InvitationCodeScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"InvitationCode"> | string
    cid?: StringNullableWithAggregatesFilter<"InvitationCode"> | string | null
    themeId?: StringNullableWithAggregatesFilter<"InvitationCode"> | string | null
    type?: IntNullableWithAggregatesFilter<"InvitationCode"> | number | null
    invitationCode?: StringNullableWithAggregatesFilter<"InvitationCode"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"InvitationCode"> | Date | string | null
  }

  export type ai_agent_park_sessionWhereInput = {
    AND?: ai_agent_park_sessionWhereInput | ai_agent_park_sessionWhereInput[]
    OR?: ai_agent_park_sessionWhereInput[]
    NOT?: ai_agent_park_sessionWhereInput | ai_agent_park_sessionWhereInput[]
    id?: StringFilter<"ai_agent_park_session"> | string
    session_name?: StringNullableFilter<"ai_agent_park_session"> | string | null
    user_id?: StringNullableFilter<"ai_agent_park_session"> | string | null
    isCocoNote?: IntNullableFilter<"ai_agent_park_session"> | number | null
    createtime?: DateTimeNullableFilter<"ai_agent_park_session"> | Date | string | null
    work_area_text?: StringNullableFilter<"ai_agent_park_session"> | string | null
    scene?: StringNullableFilter<"ai_agent_park_session"> | string | null
  }

  export type ai_agent_park_sessionOrderByWithRelationInput = {
    id?: SortOrder
    session_name?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    isCocoNote?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    work_area_text?: SortOrderInput | SortOrder
    scene?: SortOrderInput | SortOrder
  }

  export type ai_agent_park_sessionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ai_agent_park_sessionWhereInput | ai_agent_park_sessionWhereInput[]
    OR?: ai_agent_park_sessionWhereInput[]
    NOT?: ai_agent_park_sessionWhereInput | ai_agent_park_sessionWhereInput[]
    session_name?: StringNullableFilter<"ai_agent_park_session"> | string | null
    user_id?: StringNullableFilter<"ai_agent_park_session"> | string | null
    isCocoNote?: IntNullableFilter<"ai_agent_park_session"> | number | null
    createtime?: DateTimeNullableFilter<"ai_agent_park_session"> | Date | string | null
    work_area_text?: StringNullableFilter<"ai_agent_park_session"> | string | null
    scene?: StringNullableFilter<"ai_agent_park_session"> | string | null
  }, "id">

  export type ai_agent_park_sessionOrderByWithAggregationInput = {
    id?: SortOrder
    session_name?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    isCocoNote?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    work_area_text?: SortOrderInput | SortOrder
    scene?: SortOrderInput | SortOrder
    _count?: ai_agent_park_sessionCountOrderByAggregateInput
    _avg?: ai_agent_park_sessionAvgOrderByAggregateInput
    _max?: ai_agent_park_sessionMaxOrderByAggregateInput
    _min?: ai_agent_park_sessionMinOrderByAggregateInput
    _sum?: ai_agent_park_sessionSumOrderByAggregateInput
  }

  export type ai_agent_park_sessionScalarWhereWithAggregatesInput = {
    AND?: ai_agent_park_sessionScalarWhereWithAggregatesInput | ai_agent_park_sessionScalarWhereWithAggregatesInput[]
    OR?: ai_agent_park_sessionScalarWhereWithAggregatesInput[]
    NOT?: ai_agent_park_sessionScalarWhereWithAggregatesInput | ai_agent_park_sessionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ai_agent_park_session"> | string
    session_name?: StringNullableWithAggregatesFilter<"ai_agent_park_session"> | string | null
    user_id?: StringNullableWithAggregatesFilter<"ai_agent_park_session"> | string | null
    isCocoNote?: IntNullableWithAggregatesFilter<"ai_agent_park_session"> | number | null
    createtime?: DateTimeNullableWithAggregatesFilter<"ai_agent_park_session"> | Date | string | null
    work_area_text?: StringNullableWithAggregatesFilter<"ai_agent_park_session"> | string | null
    scene?: StringNullableWithAggregatesFilter<"ai_agent_park_session"> | string | null
  }

  export type classroom_ob_commentWhereInput = {
    AND?: classroom_ob_commentWhereInput | classroom_ob_commentWhereInput[]
    OR?: classroom_ob_commentWhereInput[]
    NOT?: classroom_ob_commentWhereInput | classroom_ob_commentWhereInput[]
    id?: StringFilter<"classroom_ob_comment"> | string
    module_id?: StringFilter<"classroom_ob_comment"> | string
    module_name?: StringNullableFilter<"classroom_ob_comment"> | string | null
    nickname?: StringNullableFilter<"classroom_ob_comment"> | string | null
    commentContent?: StringNullableFilter<"classroom_ob_comment"> | string | null
    audit_status?: IntFilter<"classroom_ob_comment"> | number
    t_id?: StringNullableFilter<"classroom_ob_comment"> | string | null
    create_time?: DateTimeNullableFilter<"classroom_ob_comment"> | Date | string | null
  }

  export type classroom_ob_commentOrderByWithRelationInput = {
    id?: SortOrder
    module_id?: SortOrder
    module_name?: SortOrderInput | SortOrder
    nickname?: SortOrderInput | SortOrder
    commentContent?: SortOrderInput | SortOrder
    audit_status?: SortOrder
    t_id?: SortOrderInput | SortOrder
    create_time?: SortOrderInput | SortOrder
  }

  export type classroom_ob_commentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: classroom_ob_commentWhereInput | classroom_ob_commentWhereInput[]
    OR?: classroom_ob_commentWhereInput[]
    NOT?: classroom_ob_commentWhereInput | classroom_ob_commentWhereInput[]
    module_id?: StringFilter<"classroom_ob_comment"> | string
    module_name?: StringNullableFilter<"classroom_ob_comment"> | string | null
    nickname?: StringNullableFilter<"classroom_ob_comment"> | string | null
    commentContent?: StringNullableFilter<"classroom_ob_comment"> | string | null
    audit_status?: IntFilter<"classroom_ob_comment"> | number
    t_id?: StringNullableFilter<"classroom_ob_comment"> | string | null
    create_time?: DateTimeNullableFilter<"classroom_ob_comment"> | Date | string | null
  }, "id">

  export type classroom_ob_commentOrderByWithAggregationInput = {
    id?: SortOrder
    module_id?: SortOrder
    module_name?: SortOrderInput | SortOrder
    nickname?: SortOrderInput | SortOrder
    commentContent?: SortOrderInput | SortOrder
    audit_status?: SortOrder
    t_id?: SortOrderInput | SortOrder
    create_time?: SortOrderInput | SortOrder
    _count?: classroom_ob_commentCountOrderByAggregateInput
    _avg?: classroom_ob_commentAvgOrderByAggregateInput
    _max?: classroom_ob_commentMaxOrderByAggregateInput
    _min?: classroom_ob_commentMinOrderByAggregateInput
    _sum?: classroom_ob_commentSumOrderByAggregateInput
  }

  export type classroom_ob_commentScalarWhereWithAggregatesInput = {
    AND?: classroom_ob_commentScalarWhereWithAggregatesInput | classroom_ob_commentScalarWhereWithAggregatesInput[]
    OR?: classroom_ob_commentScalarWhereWithAggregatesInput[]
    NOT?: classroom_ob_commentScalarWhereWithAggregatesInput | classroom_ob_commentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"classroom_ob_comment"> | string
    module_id?: StringWithAggregatesFilter<"classroom_ob_comment"> | string
    module_name?: StringNullableWithAggregatesFilter<"classroom_ob_comment"> | string | null
    nickname?: StringNullableWithAggregatesFilter<"classroom_ob_comment"> | string | null
    commentContent?: StringNullableWithAggregatesFilter<"classroom_ob_comment"> | string | null
    audit_status?: IntWithAggregatesFilter<"classroom_ob_comment"> | number
    t_id?: StringNullableWithAggregatesFilter<"classroom_ob_comment"> | string | null
    create_time?: DateTimeNullableWithAggregatesFilter<"classroom_ob_comment"> | Date | string | null
  }

  export type classroom_observationWhereInput = {
    AND?: classroom_observationWhereInput | classroom_observationWhereInput[]
    OR?: classroom_observationWhereInput[]
    NOT?: classroom_observationWhereInput | classroom_observationWhereInput[]
    id?: StringFilter<"classroom_observation"> | string
    jsonData?: StringNullableFilter<"classroom_observation"> | string | null
    Type?: IntNullableFilter<"classroom_observation"> | number | null
    tIndex?: IntNullableFilter<"classroom_observation"> | number | null
    tId?: StringNullableFilter<"classroom_observation"> | string | null
    createtime?: DateTimeNullableFilter<"classroom_observation"> | Date | string | null
    like_num?: IntFilter<"classroom_observation"> | number
    like_data?: StringNullableFilter<"classroom_observation"> | string | null
    userid?: StringNullableFilter<"classroom_observation"> | string | null
    isdel?: IntNullableFilter<"classroom_observation"> | number | null
    limitData?: StringNullableFilter<"classroom_observation"> | string | null
  }

  export type classroom_observationOrderByWithRelationInput = {
    id?: SortOrder
    jsonData?: SortOrderInput | SortOrder
    Type?: SortOrderInput | SortOrder
    tIndex?: SortOrderInput | SortOrder
    tId?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    like_num?: SortOrder
    like_data?: SortOrderInput | SortOrder
    userid?: SortOrderInput | SortOrder
    isdel?: SortOrderInput | SortOrder
    limitData?: SortOrderInput | SortOrder
  }

  export type classroom_observationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: classroom_observationWhereInput | classroom_observationWhereInput[]
    OR?: classroom_observationWhereInput[]
    NOT?: classroom_observationWhereInput | classroom_observationWhereInput[]
    jsonData?: StringNullableFilter<"classroom_observation"> | string | null
    Type?: IntNullableFilter<"classroom_observation"> | number | null
    tIndex?: IntNullableFilter<"classroom_observation"> | number | null
    tId?: StringNullableFilter<"classroom_observation"> | string | null
    createtime?: DateTimeNullableFilter<"classroom_observation"> | Date | string | null
    like_num?: IntFilter<"classroom_observation"> | number
    like_data?: StringNullableFilter<"classroom_observation"> | string | null
    userid?: StringNullableFilter<"classroom_observation"> | string | null
    isdel?: IntNullableFilter<"classroom_observation"> | number | null
    limitData?: StringNullableFilter<"classroom_observation"> | string | null
  }, "id">

  export type classroom_observationOrderByWithAggregationInput = {
    id?: SortOrder
    jsonData?: SortOrderInput | SortOrder
    Type?: SortOrderInput | SortOrder
    tIndex?: SortOrderInput | SortOrder
    tId?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    like_num?: SortOrder
    like_data?: SortOrderInput | SortOrder
    userid?: SortOrderInput | SortOrder
    isdel?: SortOrderInput | SortOrder
    limitData?: SortOrderInput | SortOrder
    _count?: classroom_observationCountOrderByAggregateInput
    _avg?: classroom_observationAvgOrderByAggregateInput
    _max?: classroom_observationMaxOrderByAggregateInput
    _min?: classroom_observationMinOrderByAggregateInput
    _sum?: classroom_observationSumOrderByAggregateInput
  }

  export type classroom_observationScalarWhereWithAggregatesInput = {
    AND?: classroom_observationScalarWhereWithAggregatesInput | classroom_observationScalarWhereWithAggregatesInput[]
    OR?: classroom_observationScalarWhereWithAggregatesInput[]
    NOT?: classroom_observationScalarWhereWithAggregatesInput | classroom_observationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"classroom_observation"> | string
    jsonData?: StringNullableWithAggregatesFilter<"classroom_observation"> | string | null
    Type?: IntNullableWithAggregatesFilter<"classroom_observation"> | number | null
    tIndex?: IntNullableWithAggregatesFilter<"classroom_observation"> | number | null
    tId?: StringNullableWithAggregatesFilter<"classroom_observation"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"classroom_observation"> | Date | string | null
    like_num?: IntWithAggregatesFilter<"classroom_observation"> | number
    like_data?: StringNullableWithAggregatesFilter<"classroom_observation"> | string | null
    userid?: StringNullableWithAggregatesFilter<"classroom_observation"> | string | null
    isdel?: IntNullableWithAggregatesFilter<"classroom_observation"> | number | null
    limitData?: StringNullableWithAggregatesFilter<"classroom_observation"> | string | null
  }

  export type course_resourceWhereInput = {
    AND?: course_resourceWhereInput | course_resourceWhereInput[]
    OR?: course_resourceWhereInput[]
    NOT?: course_resourceWhereInput | course_resourceWhereInput[]
    id?: StringFilter<"course_resource"> | string
    subject?: StringNullableFilter<"course_resource"> | string | null
    grade?: StringNullableFilter<"course_resource"> | string | null
    textbook?: StringNullableFilter<"course_resource"> | string | null
    book_type?: StringNullableFilter<"course_resource"> | string | null
    unit?: StringNullableFilter<"course_resource"> | string | null
    period?: StringNullableFilter<"course_resource"> | string | null
    unit_content?: StringNullableFilter<"course_resource"> | string | null
    course_content?: StringNullableFilter<"course_resource"> | string | null
  }

  export type course_resourceOrderByWithRelationInput = {
    id?: SortOrder
    subject?: SortOrderInput | SortOrder
    grade?: SortOrderInput | SortOrder
    textbook?: SortOrderInput | SortOrder
    book_type?: SortOrderInput | SortOrder
    unit?: SortOrderInput | SortOrder
    period?: SortOrderInput | SortOrder
    unit_content?: SortOrderInput | SortOrder
    course_content?: SortOrderInput | SortOrder
  }

  export type course_resourceWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: course_resourceWhereInput | course_resourceWhereInput[]
    OR?: course_resourceWhereInput[]
    NOT?: course_resourceWhereInput | course_resourceWhereInput[]
    subject?: StringNullableFilter<"course_resource"> | string | null
    grade?: StringNullableFilter<"course_resource"> | string | null
    textbook?: StringNullableFilter<"course_resource"> | string | null
    book_type?: StringNullableFilter<"course_resource"> | string | null
    unit?: StringNullableFilter<"course_resource"> | string | null
    period?: StringNullableFilter<"course_resource"> | string | null
    unit_content?: StringNullableFilter<"course_resource"> | string | null
    course_content?: StringNullableFilter<"course_resource"> | string | null
  }, "id">

  export type course_resourceOrderByWithAggregationInput = {
    id?: SortOrder
    subject?: SortOrderInput | SortOrder
    grade?: SortOrderInput | SortOrder
    textbook?: SortOrderInput | SortOrder
    book_type?: SortOrderInput | SortOrder
    unit?: SortOrderInput | SortOrder
    period?: SortOrderInput | SortOrder
    unit_content?: SortOrderInput | SortOrder
    course_content?: SortOrderInput | SortOrder
    _count?: course_resourceCountOrderByAggregateInput
    _max?: course_resourceMaxOrderByAggregateInput
    _min?: course_resourceMinOrderByAggregateInput
  }

  export type course_resourceScalarWhereWithAggregatesInput = {
    AND?: course_resourceScalarWhereWithAggregatesInput | course_resourceScalarWhereWithAggregatesInput[]
    OR?: course_resourceScalarWhereWithAggregatesInput[]
    NOT?: course_resourceScalarWhereWithAggregatesInput | course_resourceScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"course_resource"> | string
    subject?: StringNullableWithAggregatesFilter<"course_resource"> | string | null
    grade?: StringNullableWithAggregatesFilter<"course_resource"> | string | null
    textbook?: StringNullableWithAggregatesFilter<"course_resource"> | string | null
    book_type?: StringNullableWithAggregatesFilter<"course_resource"> | string | null
    unit?: StringNullableWithAggregatesFilter<"course_resource"> | string | null
    period?: StringNullableWithAggregatesFilter<"course_resource"> | string | null
    unit_content?: StringNullableWithAggregatesFilter<"course_resource"> | string | null
    course_content?: StringNullableWithAggregatesFilter<"course_resource"> | string | null
  }

  export type knowledge_construction_docWhereInput = {
    AND?: knowledge_construction_docWhereInput | knowledge_construction_docWhereInput[]
    OR?: knowledge_construction_docWhereInput[]
    NOT?: knowledge_construction_docWhereInput | knowledge_construction_docWhereInput[]
    id?: StringFilter<"knowledge_construction_doc"> | string
    muti_id?: StringNullableFilter<"knowledge_construction_doc"> | string | null
    user_id?: StringNullableFilter<"knowledge_construction_doc"> | string | null
    session_id?: StringNullableFilter<"knowledge_construction_doc"> | string | null
    content?: StringNullableFilter<"knowledge_construction_doc"> | string | null
    create_time?: DateTimeNullableFilter<"knowledge_construction_doc"> | Date | string | null
  }

  export type knowledge_construction_docOrderByWithRelationInput = {
    id?: SortOrder
    muti_id?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    session_id?: SortOrderInput | SortOrder
    content?: SortOrderInput | SortOrder
    create_time?: SortOrderInput | SortOrder
  }

  export type knowledge_construction_docWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: knowledge_construction_docWhereInput | knowledge_construction_docWhereInput[]
    OR?: knowledge_construction_docWhereInput[]
    NOT?: knowledge_construction_docWhereInput | knowledge_construction_docWhereInput[]
    muti_id?: StringNullableFilter<"knowledge_construction_doc"> | string | null
    user_id?: StringNullableFilter<"knowledge_construction_doc"> | string | null
    session_id?: StringNullableFilter<"knowledge_construction_doc"> | string | null
    content?: StringNullableFilter<"knowledge_construction_doc"> | string | null
    create_time?: DateTimeNullableFilter<"knowledge_construction_doc"> | Date | string | null
  }, "id">

  export type knowledge_construction_docOrderByWithAggregationInput = {
    id?: SortOrder
    muti_id?: SortOrderInput | SortOrder
    user_id?: SortOrderInput | SortOrder
    session_id?: SortOrderInput | SortOrder
    content?: SortOrderInput | SortOrder
    create_time?: SortOrderInput | SortOrder
    _count?: knowledge_construction_docCountOrderByAggregateInput
    _max?: knowledge_construction_docMaxOrderByAggregateInput
    _min?: knowledge_construction_docMinOrderByAggregateInput
  }

  export type knowledge_construction_docScalarWhereWithAggregatesInput = {
    AND?: knowledge_construction_docScalarWhereWithAggregatesInput | knowledge_construction_docScalarWhereWithAggregatesInput[]
    OR?: knowledge_construction_docScalarWhereWithAggregatesInput[]
    NOT?: knowledge_construction_docScalarWhereWithAggregatesInput | knowledge_construction_docScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"knowledge_construction_doc"> | string
    muti_id?: StringNullableWithAggregatesFilter<"knowledge_construction_doc"> | string | null
    user_id?: StringNullableWithAggregatesFilter<"knowledge_construction_doc"> | string | null
    session_id?: StringNullableWithAggregatesFilter<"knowledge_construction_doc"> | string | null
    content?: StringNullableWithAggregatesFilter<"knowledge_construction_doc"> | string | null
    create_time?: DateTimeNullableWithAggregatesFilter<"knowledge_construction_doc"> | Date | string | null
  }

  export type meeting_trickWhereInput = {
    AND?: meeting_trickWhereInput | meeting_trickWhereInput[]
    OR?: meeting_trickWhereInput[]
    NOT?: meeting_trickWhereInput | meeting_trickWhereInput[]
    id?: StringFilter<"meeting_trick"> | string
    createtime?: DateTimeNullableFilter<"meeting_trick"> | Date | string | null
    userid?: StringNullableFilter<"meeting_trick"> | string | null
    meeting_name?: StringNullableFilter<"meeting_trick"> | string | null
    meeting_original?: StringNullableFilter<"meeting_trick"> | string | null
    meeting_minutes?: StringNullableFilter<"meeting_trick"> | string | null
    audio_url?: StringNullableFilter<"meeting_trick"> | string | null
    duration?: StringNullableFilter<"meeting_trick"> | string | null
    ab?: StringNullableFilter<"meeting_trick"> | string | null
  }

  export type meeting_trickOrderByWithRelationInput = {
    id?: SortOrder
    createtime?: SortOrderInput | SortOrder
    userid?: SortOrderInput | SortOrder
    meeting_name?: SortOrderInput | SortOrder
    meeting_original?: SortOrderInput | SortOrder
    meeting_minutes?: SortOrderInput | SortOrder
    audio_url?: SortOrderInput | SortOrder
    duration?: SortOrderInput | SortOrder
    ab?: SortOrderInput | SortOrder
  }

  export type meeting_trickWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: meeting_trickWhereInput | meeting_trickWhereInput[]
    OR?: meeting_trickWhereInput[]
    NOT?: meeting_trickWhereInput | meeting_trickWhereInput[]
    createtime?: DateTimeNullableFilter<"meeting_trick"> | Date | string | null
    userid?: StringNullableFilter<"meeting_trick"> | string | null
    meeting_name?: StringNullableFilter<"meeting_trick"> | string | null
    meeting_original?: StringNullableFilter<"meeting_trick"> | string | null
    meeting_minutes?: StringNullableFilter<"meeting_trick"> | string | null
    audio_url?: StringNullableFilter<"meeting_trick"> | string | null
    duration?: StringNullableFilter<"meeting_trick"> | string | null
    ab?: StringNullableFilter<"meeting_trick"> | string | null
  }, "id">

  export type meeting_trickOrderByWithAggregationInput = {
    id?: SortOrder
    createtime?: SortOrderInput | SortOrder
    userid?: SortOrderInput | SortOrder
    meeting_name?: SortOrderInput | SortOrder
    meeting_original?: SortOrderInput | SortOrder
    meeting_minutes?: SortOrderInput | SortOrder
    audio_url?: SortOrderInput | SortOrder
    duration?: SortOrderInput | SortOrder
    ab?: SortOrderInput | SortOrder
    _count?: meeting_trickCountOrderByAggregateInput
    _max?: meeting_trickMaxOrderByAggregateInput
    _min?: meeting_trickMinOrderByAggregateInput
  }

  export type meeting_trickScalarWhereWithAggregatesInput = {
    AND?: meeting_trickScalarWhereWithAggregatesInput | meeting_trickScalarWhereWithAggregatesInput[]
    OR?: meeting_trickScalarWhereWithAggregatesInput[]
    NOT?: meeting_trickScalarWhereWithAggregatesInput | meeting_trickScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"meeting_trick"> | string
    createtime?: DateTimeNullableWithAggregatesFilter<"meeting_trick"> | Date | string | null
    userid?: StringNullableWithAggregatesFilter<"meeting_trick"> | string | null
    meeting_name?: StringNullableWithAggregatesFilter<"meeting_trick"> | string | null
    meeting_original?: StringNullableWithAggregatesFilter<"meeting_trick"> | string | null
    meeting_minutes?: StringNullableWithAggregatesFilter<"meeting_trick"> | string | null
    audio_url?: StringNullableWithAggregatesFilter<"meeting_trick"> | string | null
    duration?: StringNullableWithAggregatesFilter<"meeting_trick"> | string | null
    ab?: StringNullableWithAggregatesFilter<"meeting_trick"> | string | null
  }

  export type meeting_trick_chatWhereInput = {
    AND?: meeting_trick_chatWhereInput | meeting_trick_chatWhereInput[]
    OR?: meeting_trick_chatWhereInput[]
    NOT?: meeting_trick_chatWhereInput | meeting_trick_chatWhereInput[]
    id?: StringFilter<"meeting_trick_chat"> | string
    meeting_id?: StringNullableFilter<"meeting_trick_chat"> | string | null
    createtime?: DateTimeNullableFilter<"meeting_trick_chat"> | Date | string | null
    user_content?: StringNullableFilter<"meeting_trick_chat"> | string | null
    ai_content?: StringNullableFilter<"meeting_trick_chat"> | string | null
  }

  export type meeting_trick_chatOrderByWithRelationInput = {
    id?: SortOrder
    meeting_id?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    user_content?: SortOrderInput | SortOrder
    ai_content?: SortOrderInput | SortOrder
  }

  export type meeting_trick_chatWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: meeting_trick_chatWhereInput | meeting_trick_chatWhereInput[]
    OR?: meeting_trick_chatWhereInput[]
    NOT?: meeting_trick_chatWhereInput | meeting_trick_chatWhereInput[]
    meeting_id?: StringNullableFilter<"meeting_trick_chat"> | string | null
    createtime?: DateTimeNullableFilter<"meeting_trick_chat"> | Date | string | null
    user_content?: StringNullableFilter<"meeting_trick_chat"> | string | null
    ai_content?: StringNullableFilter<"meeting_trick_chat"> | string | null
  }, "id">

  export type meeting_trick_chatOrderByWithAggregationInput = {
    id?: SortOrder
    meeting_id?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    user_content?: SortOrderInput | SortOrder
    ai_content?: SortOrderInput | SortOrder
    _count?: meeting_trick_chatCountOrderByAggregateInput
    _max?: meeting_trick_chatMaxOrderByAggregateInput
    _min?: meeting_trick_chatMinOrderByAggregateInput
  }

  export type meeting_trick_chatScalarWhereWithAggregatesInput = {
    AND?: meeting_trick_chatScalarWhereWithAggregatesInput | meeting_trick_chatScalarWhereWithAggregatesInput[]
    OR?: meeting_trick_chatScalarWhereWithAggregatesInput[]
    NOT?: meeting_trick_chatScalarWhereWithAggregatesInput | meeting_trick_chatScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"meeting_trick_chat"> | string
    meeting_id?: StringNullableWithAggregatesFilter<"meeting_trick_chat"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"meeting_trick_chat"> | Date | string | null
    user_content?: StringNullableWithAggregatesFilter<"meeting_trick_chat"> | string | null
    ai_content?: StringNullableWithAggregatesFilter<"meeting_trick_chat"> | string | null
  }

  export type muti_agent_listWhereInput = {
    AND?: muti_agent_listWhereInput | muti_agent_listWhereInput[]
    OR?: muti_agent_listWhereInput[]
    NOT?: muti_agent_listWhereInput | muti_agent_listWhereInput[]
    id?: StringFilter<"muti_agent_list"> | string
    userid?: StringNullableFilter<"muti_agent_list"> | string | null
    username?: StringNullableFilter<"muti_agent_list"> | string | null
    muti_name?: StringNullableFilter<"muti_agent_list"> | string | null
    description?: StringNullableFilter<"muti_agent_list"> | string | null
    isPublish?: BoolNullableFilter<"muti_agent_list"> | boolean | null
    organizeid?: StringNullableFilter<"muti_agent_list"> | string | null
    content?: StringNullableFilter<"muti_agent_list"> | string | null
    create_time?: DateTimeNullableFilter<"muti_agent_list"> | Date | string | null
    knowledge_construction?: IntNullableFilter<"muti_agent_list"> | number | null
  }

  export type muti_agent_listOrderByWithRelationInput = {
    id?: SortOrder
    userid?: SortOrderInput | SortOrder
    username?: SortOrderInput | SortOrder
    muti_name?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    isPublish?: SortOrderInput | SortOrder
    organizeid?: SortOrderInput | SortOrder
    content?: SortOrderInput | SortOrder
    create_time?: SortOrderInput | SortOrder
    knowledge_construction?: SortOrderInput | SortOrder
  }

  export type muti_agent_listWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: muti_agent_listWhereInput | muti_agent_listWhereInput[]
    OR?: muti_agent_listWhereInput[]
    NOT?: muti_agent_listWhereInput | muti_agent_listWhereInput[]
    userid?: StringNullableFilter<"muti_agent_list"> | string | null
    username?: StringNullableFilter<"muti_agent_list"> | string | null
    muti_name?: StringNullableFilter<"muti_agent_list"> | string | null
    description?: StringNullableFilter<"muti_agent_list"> | string | null
    isPublish?: BoolNullableFilter<"muti_agent_list"> | boolean | null
    organizeid?: StringNullableFilter<"muti_agent_list"> | string | null
    content?: StringNullableFilter<"muti_agent_list"> | string | null
    create_time?: DateTimeNullableFilter<"muti_agent_list"> | Date | string | null
    knowledge_construction?: IntNullableFilter<"muti_agent_list"> | number | null
  }, "id">

  export type muti_agent_listOrderByWithAggregationInput = {
    id?: SortOrder
    userid?: SortOrderInput | SortOrder
    username?: SortOrderInput | SortOrder
    muti_name?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    isPublish?: SortOrderInput | SortOrder
    organizeid?: SortOrderInput | SortOrder
    content?: SortOrderInput | SortOrder
    create_time?: SortOrderInput | SortOrder
    knowledge_construction?: SortOrderInput | SortOrder
    _count?: muti_agent_listCountOrderByAggregateInput
    _avg?: muti_agent_listAvgOrderByAggregateInput
    _max?: muti_agent_listMaxOrderByAggregateInput
    _min?: muti_agent_listMinOrderByAggregateInput
    _sum?: muti_agent_listSumOrderByAggregateInput
  }

  export type muti_agent_listScalarWhereWithAggregatesInput = {
    AND?: muti_agent_listScalarWhereWithAggregatesInput | muti_agent_listScalarWhereWithAggregatesInput[]
    OR?: muti_agent_listScalarWhereWithAggregatesInput[]
    NOT?: muti_agent_listScalarWhereWithAggregatesInput | muti_agent_listScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"muti_agent_list"> | string
    userid?: StringNullableWithAggregatesFilter<"muti_agent_list"> | string | null
    username?: StringNullableWithAggregatesFilter<"muti_agent_list"> | string | null
    muti_name?: StringNullableWithAggregatesFilter<"muti_agent_list"> | string | null
    description?: StringNullableWithAggregatesFilter<"muti_agent_list"> | string | null
    isPublish?: BoolNullableWithAggregatesFilter<"muti_agent_list"> | boolean | null
    organizeid?: StringNullableWithAggregatesFilter<"muti_agent_list"> | string | null
    content?: StringNullableWithAggregatesFilter<"muti_agent_list"> | string | null
    create_time?: DateTimeNullableWithAggregatesFilter<"muti_agent_list"> | Date | string | null
    knowledge_construction?: IntNullableWithAggregatesFilter<"muti_agent_list"> | number | null
  }

  export type park_chat_file_listWhereInput = {
    AND?: park_chat_file_listWhereInput | park_chat_file_listWhereInput[]
    OR?: park_chat_file_listWhereInput[]
    NOT?: park_chat_file_listWhereInput | park_chat_file_listWhereInput[]
    id?: StringFilter<"park_chat_file_list"> | string
    user_id?: StringNullableFilter<"park_chat_file_list"> | string | null
    file_names?: StringFilter<"park_chat_file_list"> | string
    file_ids?: StringFilter<"park_chat_file_list"> | string
    create_time?: DateTimeNullableFilter<"park_chat_file_list"> | Date | string | null
    file_urls?: StringNullableFilter<"park_chat_file_list"> | string | null
  }

  export type park_chat_file_listOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrderInput | SortOrder
    file_names?: SortOrder
    file_ids?: SortOrder
    create_time?: SortOrderInput | SortOrder
    file_urls?: SortOrderInput | SortOrder
  }

  export type park_chat_file_listWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: park_chat_file_listWhereInput | park_chat_file_listWhereInput[]
    OR?: park_chat_file_listWhereInput[]
    NOT?: park_chat_file_listWhereInput | park_chat_file_listWhereInput[]
    user_id?: StringNullableFilter<"park_chat_file_list"> | string | null
    file_names?: StringFilter<"park_chat_file_list"> | string
    file_ids?: StringFilter<"park_chat_file_list"> | string
    create_time?: DateTimeNullableFilter<"park_chat_file_list"> | Date | string | null
    file_urls?: StringNullableFilter<"park_chat_file_list"> | string | null
  }, "id">

  export type park_chat_file_listOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrderInput | SortOrder
    file_names?: SortOrder
    file_ids?: SortOrder
    create_time?: SortOrderInput | SortOrder
    file_urls?: SortOrderInput | SortOrder
    _count?: park_chat_file_listCountOrderByAggregateInput
    _max?: park_chat_file_listMaxOrderByAggregateInput
    _min?: park_chat_file_listMinOrderByAggregateInput
  }

  export type park_chat_file_listScalarWhereWithAggregatesInput = {
    AND?: park_chat_file_listScalarWhereWithAggregatesInput | park_chat_file_listScalarWhereWithAggregatesInput[]
    OR?: park_chat_file_listScalarWhereWithAggregatesInput[]
    NOT?: park_chat_file_listScalarWhereWithAggregatesInput | park_chat_file_listScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"park_chat_file_list"> | string
    user_id?: StringNullableWithAggregatesFilter<"park_chat_file_list"> | string | null
    file_names?: StringWithAggregatesFilter<"park_chat_file_list"> | string
    file_ids?: StringWithAggregatesFilter<"park_chat_file_list"> | string
    create_time?: DateTimeNullableWithAggregatesFilter<"park_chat_file_list"> | Date | string | null
    file_urls?: StringNullableWithAggregatesFilter<"park_chat_file_list"> | string | null
  }

  export type tokenWhereInput = {
    AND?: tokenWhereInput | tokenWhereInput[]
    OR?: tokenWhereInput[]
    NOT?: tokenWhereInput | tokenWhereInput[]
    id?: StringFilter<"token"> | string
    schoolId?: StringNullableFilter<"token"> | string | null
    key?: StringNullableFilter<"token"> | string | null
    createUsername?: StringNullableFilter<"token"> | string | null
    createtime?: DateTimeNullableFilter<"token"> | Date | string | null
  }

  export type tokenOrderByWithRelationInput = {
    id?: SortOrder
    schoolId?: SortOrderInput | SortOrder
    key?: SortOrderInput | SortOrder
    createUsername?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
  }

  export type tokenWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: tokenWhereInput | tokenWhereInput[]
    OR?: tokenWhereInput[]
    NOT?: tokenWhereInput | tokenWhereInput[]
    schoolId?: StringNullableFilter<"token"> | string | null
    key?: StringNullableFilter<"token"> | string | null
    createUsername?: StringNullableFilter<"token"> | string | null
    createtime?: DateTimeNullableFilter<"token"> | Date | string | null
  }, "id">

  export type tokenOrderByWithAggregationInput = {
    id?: SortOrder
    schoolId?: SortOrderInput | SortOrder
    key?: SortOrderInput | SortOrder
    createUsername?: SortOrderInput | SortOrder
    createtime?: SortOrderInput | SortOrder
    _count?: tokenCountOrderByAggregateInput
    _max?: tokenMaxOrderByAggregateInput
    _min?: tokenMinOrderByAggregateInput
  }

  export type tokenScalarWhereWithAggregatesInput = {
    AND?: tokenScalarWhereWithAggregatesInput | tokenScalarWhereWithAggregatesInput[]
    OR?: tokenScalarWhereWithAggregatesInput[]
    NOT?: tokenScalarWhereWithAggregatesInput | tokenScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"token"> | string
    schoolId?: StringNullableWithAggregatesFilter<"token"> | string | null
    key?: StringNullableWithAggregatesFilter<"token"> | string | null
    createUsername?: StringNullableWithAggregatesFilter<"token"> | string | null
    createtime?: DateTimeNullableWithAggregatesFilter<"token"> | Date | string | null
  }

  export type AWS_Policy_RoleCreateInput = {
    id: string
    assistant_id?: string | null
    agent_bedrock_policy?: string | null
    agent_kb_schema_policy?: string | null
    kb_bedrock_policy?: string | null
    kb_aoss_policy?: string | null
    kb_s3_policy?: string | null
    agent_role_name?: string | null
    kb_role_name?: string | null
    createtime?: Date | string | null
  }

  export type AWS_Policy_RoleUncheckedCreateInput = {
    id: string
    assistant_id?: string | null
    agent_bedrock_policy?: string | null
    agent_kb_schema_policy?: string | null
    kb_bedrock_policy?: string | null
    kb_aoss_policy?: string | null
    kb_s3_policy?: string | null
    agent_role_name?: string | null
    kb_role_name?: string | null
    createtime?: Date | string | null
  }

  export type AWS_Policy_RoleUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    agent_bedrock_policy?: NullableStringFieldUpdateOperationsInput | string | null
    agent_kb_schema_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_bedrock_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_aoss_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_s3_policy?: NullableStringFieldUpdateOperationsInput | string | null
    agent_role_name?: NullableStringFieldUpdateOperationsInput | string | null
    kb_role_name?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AWS_Policy_RoleUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    agent_bedrock_policy?: NullableStringFieldUpdateOperationsInput | string | null
    agent_kb_schema_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_bedrock_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_aoss_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_s3_policy?: NullableStringFieldUpdateOperationsInput | string | null
    agent_role_name?: NullableStringFieldUpdateOperationsInput | string | null
    kb_role_name?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AWS_Policy_RoleCreateManyInput = {
    id: string
    assistant_id?: string | null
    agent_bedrock_policy?: string | null
    agent_kb_schema_policy?: string | null
    kb_bedrock_policy?: string | null
    kb_aoss_policy?: string | null
    kb_s3_policy?: string | null
    agent_role_name?: string | null
    kb_role_name?: string | null
    createtime?: Date | string | null
  }

  export type AWS_Policy_RoleUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    agent_bedrock_policy?: NullableStringFieldUpdateOperationsInput | string | null
    agent_kb_schema_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_bedrock_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_aoss_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_s3_policy?: NullableStringFieldUpdateOperationsInput | string | null
    agent_role_name?: NullableStringFieldUpdateOperationsInput | string | null
    kb_role_name?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AWS_Policy_RoleUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    agent_bedrock_policy?: NullableStringFieldUpdateOperationsInput | string | null
    agent_kb_schema_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_bedrock_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_aoss_policy?: NullableStringFieldUpdateOperationsInput | string | null
    kb_s3_policy?: NullableStringFieldUpdateOperationsInput | string | null
    agent_role_name?: NullableStringFieldUpdateOperationsInput | string | null
    kb_role_name?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type Ai_Agent_AssistantsCreateInput = {
    id: string
    userId?: string | null
    username?: string | null
    agent_sort?: string | null
    agent_tag?: string | null
    assistantName?: string | null
    description?: string | null
    prologue?: string | null
    headUrl?: string | null
    instructions?: string | null
    isRetrieval?: boolean | null
    isCode?: boolean | null
    isGoogle?: boolean | null
    isDalleImage?: boolean | null
    functionNames?: string | null
    functionContents?: string | null
    assistant_id?: string | null
    thread_id?: string | null
    file_ids?: string | null
    file_names?: string | null
    isPublish?: boolean | null
    organize_id?: string | null
    vector_store_id?: string | null
    modelType?: string | null
    createtime?: Date | string | null
    updatetime?: Date | string | null
    a?: string | null
  }

  export type Ai_Agent_AssistantsUncheckedCreateInput = {
    id: string
    userId?: string | null
    username?: string | null
    agent_sort?: string | null
    agent_tag?: string | null
    assistantName?: string | null
    description?: string | null
    prologue?: string | null
    headUrl?: string | null
    instructions?: string | null
    isRetrieval?: boolean | null
    isCode?: boolean | null
    isGoogle?: boolean | null
    isDalleImage?: boolean | null
    functionNames?: string | null
    functionContents?: string | null
    assistant_id?: string | null
    thread_id?: string | null
    file_ids?: string | null
    file_names?: string | null
    isPublish?: boolean | null
    organize_id?: string | null
    vector_store_id?: string | null
    modelType?: string | null
    createtime?: Date | string | null
    updatetime?: Date | string | null
    a?: string | null
  }

  export type Ai_Agent_AssistantsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    agent_sort?: NullableStringFieldUpdateOperationsInput | string | null
    agent_tag?: NullableStringFieldUpdateOperationsInput | string | null
    assistantName?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    prologue?: NullableStringFieldUpdateOperationsInput | string | null
    headUrl?: NullableStringFieldUpdateOperationsInput | string | null
    instructions?: NullableStringFieldUpdateOperationsInput | string | null
    isRetrieval?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isCode?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isGoogle?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isDalleImage?: NullableBoolFieldUpdateOperationsInput | boolean | null
    functionNames?: NullableStringFieldUpdateOperationsInput | string | null
    functionContents?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_ids?: NullableStringFieldUpdateOperationsInput | string | null
    file_names?: NullableStringFieldUpdateOperationsInput | string | null
    isPublish?: NullableBoolFieldUpdateOperationsInput | boolean | null
    organize_id?: NullableStringFieldUpdateOperationsInput | string | null
    vector_store_id?: NullableStringFieldUpdateOperationsInput | string | null
    modelType?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updatetime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    a?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type Ai_Agent_AssistantsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    agent_sort?: NullableStringFieldUpdateOperationsInput | string | null
    agent_tag?: NullableStringFieldUpdateOperationsInput | string | null
    assistantName?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    prologue?: NullableStringFieldUpdateOperationsInput | string | null
    headUrl?: NullableStringFieldUpdateOperationsInput | string | null
    instructions?: NullableStringFieldUpdateOperationsInput | string | null
    isRetrieval?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isCode?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isGoogle?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isDalleImage?: NullableBoolFieldUpdateOperationsInput | boolean | null
    functionNames?: NullableStringFieldUpdateOperationsInput | string | null
    functionContents?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_ids?: NullableStringFieldUpdateOperationsInput | string | null
    file_names?: NullableStringFieldUpdateOperationsInput | string | null
    isPublish?: NullableBoolFieldUpdateOperationsInput | boolean | null
    organize_id?: NullableStringFieldUpdateOperationsInput | string | null
    vector_store_id?: NullableStringFieldUpdateOperationsInput | string | null
    modelType?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updatetime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    a?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type Ai_Agent_AssistantsCreateManyInput = {
    id: string
    userId?: string | null
    username?: string | null
    agent_sort?: string | null
    agent_tag?: string | null
    assistantName?: string | null
    description?: string | null
    prologue?: string | null
    headUrl?: string | null
    instructions?: string | null
    isRetrieval?: boolean | null
    isCode?: boolean | null
    isGoogle?: boolean | null
    isDalleImage?: boolean | null
    functionNames?: string | null
    functionContents?: string | null
    assistant_id?: string | null
    thread_id?: string | null
    file_ids?: string | null
    file_names?: string | null
    isPublish?: boolean | null
    organize_id?: string | null
    vector_store_id?: string | null
    modelType?: string | null
    createtime?: Date | string | null
    updatetime?: Date | string | null
    a?: string | null
  }

  export type Ai_Agent_AssistantsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    agent_sort?: NullableStringFieldUpdateOperationsInput | string | null
    agent_tag?: NullableStringFieldUpdateOperationsInput | string | null
    assistantName?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    prologue?: NullableStringFieldUpdateOperationsInput | string | null
    headUrl?: NullableStringFieldUpdateOperationsInput | string | null
    instructions?: NullableStringFieldUpdateOperationsInput | string | null
    isRetrieval?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isCode?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isGoogle?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isDalleImage?: NullableBoolFieldUpdateOperationsInput | boolean | null
    functionNames?: NullableStringFieldUpdateOperationsInput | string | null
    functionContents?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_ids?: NullableStringFieldUpdateOperationsInput | string | null
    file_names?: NullableStringFieldUpdateOperationsInput | string | null
    isPublish?: NullableBoolFieldUpdateOperationsInput | boolean | null
    organize_id?: NullableStringFieldUpdateOperationsInput | string | null
    vector_store_id?: NullableStringFieldUpdateOperationsInput | string | null
    modelType?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updatetime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    a?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type Ai_Agent_AssistantsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    agent_sort?: NullableStringFieldUpdateOperationsInput | string | null
    agent_tag?: NullableStringFieldUpdateOperationsInput | string | null
    assistantName?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    prologue?: NullableStringFieldUpdateOperationsInput | string | null
    headUrl?: NullableStringFieldUpdateOperationsInput | string | null
    instructions?: NullableStringFieldUpdateOperationsInput | string | null
    isRetrieval?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isCode?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isGoogle?: NullableBoolFieldUpdateOperationsInput | boolean | null
    isDalleImage?: NullableBoolFieldUpdateOperationsInput | boolean | null
    functionNames?: NullableStringFieldUpdateOperationsInput | string | null
    functionContents?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_ids?: NullableStringFieldUpdateOperationsInput | string | null
    file_names?: NullableStringFieldUpdateOperationsInput | string | null
    isPublish?: NullableBoolFieldUpdateOperationsInput | boolean | null
    organize_id?: NullableStringFieldUpdateOperationsInput | string | null
    vector_store_id?: NullableStringFieldUpdateOperationsInput | string | null
    modelType?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    updatetime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    a?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type Ai_Agent_ThreadsCreateInput = {
    id: string
    userId?: string | null
    assistant_id?: string | null
    thread_id?: string | null
    createtime?: Date | string | null
    session_name?: string
  }

  export type Ai_Agent_ThreadsUncheckedCreateInput = {
    id: string
    userId?: string | null
    assistant_id?: string | null
    thread_id?: string | null
    createtime?: Date | string | null
    session_name?: string
  }

  export type Ai_Agent_ThreadsUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    session_name?: StringFieldUpdateOperationsInput | string
  }

  export type Ai_Agent_ThreadsUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    session_name?: StringFieldUpdateOperationsInput | string
  }

  export type Ai_Agent_ThreadsCreateManyInput = {
    id: string
    userId?: string | null
    assistant_id?: string | null
    thread_id?: string | null
    createtime?: Date | string | null
    session_name?: string
  }

  export type Ai_Agent_ThreadsUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    session_name?: StringFieldUpdateOperationsInput | string
  }

  export type Ai_Agent_ThreadsUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    session_name?: StringFieldUpdateOperationsInput | string
  }

  export type AssistantCreateInput = {
    id: string
    uid?: string | null
    assistant_id?: string | null
    thread_id?: string | null
    file_ids?: string | null
    vector_store_id?: string | null
    createtime?: Date | string | null
  }

  export type AssistantUncheckedCreateInput = {
    id: string
    uid?: string | null
    assistant_id?: string | null
    thread_id?: string | null
    file_ids?: string | null
    vector_store_id?: string | null
    createtime?: Date | string | null
  }

  export type AssistantUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    uid?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_ids?: NullableStringFieldUpdateOperationsInput | string | null
    vector_store_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AssistantUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    uid?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_ids?: NullableStringFieldUpdateOperationsInput | string | null
    vector_store_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AssistantCreateManyInput = {
    id: string
    uid?: string | null
    assistant_id?: string | null
    thread_id?: string | null
    file_ids?: string | null
    vector_store_id?: string | null
    createtime?: Date | string | null
  }

  export type AssistantUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    uid?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_ids?: NullableStringFieldUpdateOperationsInput | string | null
    vector_store_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type AssistantUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    uid?: NullableStringFieldUpdateOperationsInput | string | null
    assistant_id?: NullableStringFieldUpdateOperationsInput | string | null
    thread_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_ids?: NullableStringFieldUpdateOperationsInput | string | null
    vector_store_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ChatCreateInput = {
    id?: string
    groupid?: string | null
    userid?: string | null
    username?: string | null
    answer?: string | null
    problem?: string | null
    createtime?: Date | string | null
    fileid?: string | null
    isMindMap?: number | null
    filename?: string | null
    session_name?: string
    scene?: string | null
  }

  export type ChatUncheckedCreateInput = {
    id?: string
    groupid?: string | null
    userid?: string | null
    username?: string | null
    answer?: string | null
    problem?: string | null
    createtime?: Date | string | null
    fileid?: string | null
    isMindMap?: number | null
    filename?: string | null
    session_name?: string
    scene?: string | null
  }

  export type ChatUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    groupid?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    answer?: NullableStringFieldUpdateOperationsInput | string | null
    problem?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    fileid?: NullableStringFieldUpdateOperationsInput | string | null
    isMindMap?: NullableIntFieldUpdateOperationsInput | number | null
    filename?: NullableStringFieldUpdateOperationsInput | string | null
    session_name?: StringFieldUpdateOperationsInput | string
    scene?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ChatUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    groupid?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    answer?: NullableStringFieldUpdateOperationsInput | string | null
    problem?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    fileid?: NullableStringFieldUpdateOperationsInput | string | null
    isMindMap?: NullableIntFieldUpdateOperationsInput | number | null
    filename?: NullableStringFieldUpdateOperationsInput | string | null
    session_name?: StringFieldUpdateOperationsInput | string
    scene?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ChatCreateManyInput = {
    id?: string
    groupid?: string | null
    userid?: string | null
    username?: string | null
    answer?: string | null
    problem?: string | null
    createtime?: Date | string | null
    fileid?: string | null
    isMindMap?: number | null
    filename?: string | null
    session_name?: string
    scene?: string | null
  }

  export type ChatUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    groupid?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    answer?: NullableStringFieldUpdateOperationsInput | string | null
    problem?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    fileid?: NullableStringFieldUpdateOperationsInput | string | null
    isMindMap?: NullableIntFieldUpdateOperationsInput | number | null
    filename?: NullableStringFieldUpdateOperationsInput | string | null
    session_name?: StringFieldUpdateOperationsInput | string
    scene?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ChatUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    groupid?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    answer?: NullableStringFieldUpdateOperationsInput | string | null
    problem?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    fileid?: NullableStringFieldUpdateOperationsInput | string | null
    isMindMap?: NullableIntFieldUpdateOperationsInput | number | null
    filename?: NullableStringFieldUpdateOperationsInput | string | null
    session_name?: StringFieldUpdateOperationsInput | string
    scene?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type DispositionCreateInput = {
    id: string
    module?: string | null
    disposition_class?: string | null
    disposition_type?: string | null
    disposition_style?: string | null
    disposition_theme?: string | null
    user_id?: string | null
    create_time?: Date | string | null
  }

  export type DispositionUncheckedCreateInput = {
    id: string
    module?: string | null
    disposition_class?: string | null
    disposition_type?: string | null
    disposition_style?: string | null
    disposition_theme?: string | null
    user_id?: string | null
    create_time?: Date | string | null
  }

  export type DispositionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    module?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_class?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_type?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_style?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_theme?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type DispositionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    module?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_class?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_type?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_style?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_theme?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type DispositionCreateManyInput = {
    id: string
    module?: string | null
    disposition_class?: string | null
    disposition_type?: string | null
    disposition_style?: string | null
    disposition_theme?: string | null
    user_id?: string | null
    create_time?: Date | string | null
  }

  export type DispositionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    module?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_class?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_type?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_style?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_theme?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type DispositionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    module?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_class?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_type?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_style?: NullableStringFieldUpdateOperationsInput | string | null
    disposition_theme?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type GroupCreateInput = {
    id: string
    name?: string | null
    userid?: string | null
    createtime?: Date | string | null
  }

  export type GroupUncheckedCreateInput = {
    id: string
    name?: string | null
    userid?: string | null
    createtime?: Date | string | null
  }

  export type GroupUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type GroupUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type GroupCreateManyInput = {
    id: string
    name?: string | null
    userid?: string | null
    createtime?: Date | string | null
  }

  export type GroupUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type GroupUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type GroupFileCreateInput = {
    id: string
    userid?: string | null
    fileurl?: string | null
    filename?: string | null
    groupid?: string | null
    abstract?: string | null
    assistantFileId?: string | null
    modelType?: string | null
    createtime?: Date | string | null
  }

  export type GroupFileUncheckedCreateInput = {
    id: string
    userid?: string | null
    fileurl?: string | null
    filename?: string | null
    groupid?: string | null
    abstract?: string | null
    assistantFileId?: string | null
    modelType?: string | null
    createtime?: Date | string | null
  }

  export type GroupFileUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    fileurl?: NullableStringFieldUpdateOperationsInput | string | null
    filename?: NullableStringFieldUpdateOperationsInput | string | null
    groupid?: NullableStringFieldUpdateOperationsInput | string | null
    abstract?: NullableStringFieldUpdateOperationsInput | string | null
    assistantFileId?: NullableStringFieldUpdateOperationsInput | string | null
    modelType?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type GroupFileUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    fileurl?: NullableStringFieldUpdateOperationsInput | string | null
    filename?: NullableStringFieldUpdateOperationsInput | string | null
    groupid?: NullableStringFieldUpdateOperationsInput | string | null
    abstract?: NullableStringFieldUpdateOperationsInput | string | null
    assistantFileId?: NullableStringFieldUpdateOperationsInput | string | null
    modelType?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type GroupFileCreateManyInput = {
    id: string
    userid?: string | null
    fileurl?: string | null
    filename?: string | null
    groupid?: string | null
    abstract?: string | null
    assistantFileId?: string | null
    modelType?: string | null
    createtime?: Date | string | null
  }

  export type GroupFileUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    fileurl?: NullableStringFieldUpdateOperationsInput | string | null
    filename?: NullableStringFieldUpdateOperationsInput | string | null
    groupid?: NullableStringFieldUpdateOperationsInput | string | null
    abstract?: NullableStringFieldUpdateOperationsInput | string | null
    assistantFileId?: NullableStringFieldUpdateOperationsInput | string | null
    modelType?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type GroupFileUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    fileurl?: NullableStringFieldUpdateOperationsInput | string | null
    filename?: NullableStringFieldUpdateOperationsInput | string | null
    groupid?: NullableStringFieldUpdateOperationsInput | string | null
    abstract?: NullableStringFieldUpdateOperationsInput | string | null
    assistantFileId?: NullableStringFieldUpdateOperationsInput | string | null
    modelType?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type InvitationCodeCreateInput = {
    id: string
    cid?: string | null
    themeId?: string | null
    type?: number | null
    invitationCode?: string | null
    createtime?: Date | string | null
  }

  export type InvitationCodeUncheckedCreateInput = {
    id: string
    cid?: string | null
    themeId?: string | null
    type?: number | null
    invitationCode?: string | null
    createtime?: Date | string | null
  }

  export type InvitationCodeUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    cid?: NullableStringFieldUpdateOperationsInput | string | null
    themeId?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableIntFieldUpdateOperationsInput | number | null
    invitationCode?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type InvitationCodeUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    cid?: NullableStringFieldUpdateOperationsInput | string | null
    themeId?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableIntFieldUpdateOperationsInput | number | null
    invitationCode?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type InvitationCodeCreateManyInput = {
    id: string
    cid?: string | null
    themeId?: string | null
    type?: number | null
    invitationCode?: string | null
    createtime?: Date | string | null
  }

  export type InvitationCodeUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    cid?: NullableStringFieldUpdateOperationsInput | string | null
    themeId?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableIntFieldUpdateOperationsInput | number | null
    invitationCode?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type InvitationCodeUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    cid?: NullableStringFieldUpdateOperationsInput | string | null
    themeId?: NullableStringFieldUpdateOperationsInput | string | null
    type?: NullableIntFieldUpdateOperationsInput | number | null
    invitationCode?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type ai_agent_park_sessionCreateInput = {
    id: string
    session_name?: string | null
    user_id?: string | null
    isCocoNote?: number | null
    createtime?: Date | string | null
    work_area_text?: string | null
    scene?: string | null
  }

  export type ai_agent_park_sessionUncheckedCreateInput = {
    id: string
    session_name?: string | null
    user_id?: string | null
    isCocoNote?: number | null
    createtime?: Date | string | null
    work_area_text?: string | null
    scene?: string | null
  }

  export type ai_agent_park_sessionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    session_name?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    isCocoNote?: NullableIntFieldUpdateOperationsInput | number | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    work_area_text?: NullableStringFieldUpdateOperationsInput | string | null
    scene?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ai_agent_park_sessionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    session_name?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    isCocoNote?: NullableIntFieldUpdateOperationsInput | number | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    work_area_text?: NullableStringFieldUpdateOperationsInput | string | null
    scene?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ai_agent_park_sessionCreateManyInput = {
    id: string
    session_name?: string | null
    user_id?: string | null
    isCocoNote?: number | null
    createtime?: Date | string | null
    work_area_text?: string | null
    scene?: string | null
  }

  export type ai_agent_park_sessionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    session_name?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    isCocoNote?: NullableIntFieldUpdateOperationsInput | number | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    work_area_text?: NullableStringFieldUpdateOperationsInput | string | null
    scene?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ai_agent_park_sessionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    session_name?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    isCocoNote?: NullableIntFieldUpdateOperationsInput | number | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    work_area_text?: NullableStringFieldUpdateOperationsInput | string | null
    scene?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type classroom_ob_commentCreateInput = {
    id: string
    module_id: string
    module_name?: string | null
    nickname?: string | null
    commentContent?: string | null
    audit_status?: number
    t_id?: string | null
    create_time?: Date | string | null
  }

  export type classroom_ob_commentUncheckedCreateInput = {
    id: string
    module_id: string
    module_name?: string | null
    nickname?: string | null
    commentContent?: string | null
    audit_status?: number
    t_id?: string | null
    create_time?: Date | string | null
  }

  export type classroom_ob_commentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    module_id?: StringFieldUpdateOperationsInput | string
    module_name?: NullableStringFieldUpdateOperationsInput | string | null
    nickname?: NullableStringFieldUpdateOperationsInput | string | null
    commentContent?: NullableStringFieldUpdateOperationsInput | string | null
    audit_status?: IntFieldUpdateOperationsInput | number
    t_id?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type classroom_ob_commentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    module_id?: StringFieldUpdateOperationsInput | string
    module_name?: NullableStringFieldUpdateOperationsInput | string | null
    nickname?: NullableStringFieldUpdateOperationsInput | string | null
    commentContent?: NullableStringFieldUpdateOperationsInput | string | null
    audit_status?: IntFieldUpdateOperationsInput | number
    t_id?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type classroom_ob_commentCreateManyInput = {
    id: string
    module_id: string
    module_name?: string | null
    nickname?: string | null
    commentContent?: string | null
    audit_status?: number
    t_id?: string | null
    create_time?: Date | string | null
  }

  export type classroom_ob_commentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    module_id?: StringFieldUpdateOperationsInput | string
    module_name?: NullableStringFieldUpdateOperationsInput | string | null
    nickname?: NullableStringFieldUpdateOperationsInput | string | null
    commentContent?: NullableStringFieldUpdateOperationsInput | string | null
    audit_status?: IntFieldUpdateOperationsInput | number
    t_id?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type classroom_ob_commentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    module_id?: StringFieldUpdateOperationsInput | string
    module_name?: NullableStringFieldUpdateOperationsInput | string | null
    nickname?: NullableStringFieldUpdateOperationsInput | string | null
    commentContent?: NullableStringFieldUpdateOperationsInput | string | null
    audit_status?: IntFieldUpdateOperationsInput | number
    t_id?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type classroom_observationCreateInput = {
    id: string
    jsonData?: string | null
    Type?: number | null
    tIndex?: number | null
    tId?: string | null
    createtime?: Date | string | null
    like_num?: number
    like_data?: string | null
    userid?: string | null
    isdel?: number | null
    limitData?: string | null
  }

  export type classroom_observationUncheckedCreateInput = {
    id: string
    jsonData?: string | null
    Type?: number | null
    tIndex?: number | null
    tId?: string | null
    createtime?: Date | string | null
    like_num?: number
    like_data?: string | null
    userid?: string | null
    isdel?: number | null
    limitData?: string | null
  }

  export type classroom_observationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    jsonData?: NullableStringFieldUpdateOperationsInput | string | null
    Type?: NullableIntFieldUpdateOperationsInput | number | null
    tIndex?: NullableIntFieldUpdateOperationsInput | number | null
    tId?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    like_num?: IntFieldUpdateOperationsInput | number
    like_data?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    isdel?: NullableIntFieldUpdateOperationsInput | number | null
    limitData?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type classroom_observationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    jsonData?: NullableStringFieldUpdateOperationsInput | string | null
    Type?: NullableIntFieldUpdateOperationsInput | number | null
    tIndex?: NullableIntFieldUpdateOperationsInput | number | null
    tId?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    like_num?: IntFieldUpdateOperationsInput | number
    like_data?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    isdel?: NullableIntFieldUpdateOperationsInput | number | null
    limitData?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type classroom_observationCreateManyInput = {
    id: string
    jsonData?: string | null
    Type?: number | null
    tIndex?: number | null
    tId?: string | null
    createtime?: Date | string | null
    like_num?: number
    like_data?: string | null
    userid?: string | null
    isdel?: number | null
    limitData?: string | null
  }

  export type classroom_observationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    jsonData?: NullableStringFieldUpdateOperationsInput | string | null
    Type?: NullableIntFieldUpdateOperationsInput | number | null
    tIndex?: NullableIntFieldUpdateOperationsInput | number | null
    tId?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    like_num?: IntFieldUpdateOperationsInput | number
    like_data?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    isdel?: NullableIntFieldUpdateOperationsInput | number | null
    limitData?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type classroom_observationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    jsonData?: NullableStringFieldUpdateOperationsInput | string | null
    Type?: NullableIntFieldUpdateOperationsInput | number | null
    tIndex?: NullableIntFieldUpdateOperationsInput | number | null
    tId?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    like_num?: IntFieldUpdateOperationsInput | number
    like_data?: NullableStringFieldUpdateOperationsInput | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    isdel?: NullableIntFieldUpdateOperationsInput | number | null
    limitData?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type course_resourceCreateInput = {
    id: string
    subject?: string | null
    grade?: string | null
    textbook?: string | null
    book_type?: string | null
    unit?: string | null
    period?: string | null
    unit_content?: string | null
    course_content?: string | null
  }

  export type course_resourceUncheckedCreateInput = {
    id: string
    subject?: string | null
    grade?: string | null
    textbook?: string | null
    book_type?: string | null
    unit?: string | null
    period?: string | null
    unit_content?: string | null
    course_content?: string | null
  }

  export type course_resourceUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    grade?: NullableStringFieldUpdateOperationsInput | string | null
    textbook?: NullableStringFieldUpdateOperationsInput | string | null
    book_type?: NullableStringFieldUpdateOperationsInput | string | null
    unit?: NullableStringFieldUpdateOperationsInput | string | null
    period?: NullableStringFieldUpdateOperationsInput | string | null
    unit_content?: NullableStringFieldUpdateOperationsInput | string | null
    course_content?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type course_resourceUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    grade?: NullableStringFieldUpdateOperationsInput | string | null
    textbook?: NullableStringFieldUpdateOperationsInput | string | null
    book_type?: NullableStringFieldUpdateOperationsInput | string | null
    unit?: NullableStringFieldUpdateOperationsInput | string | null
    period?: NullableStringFieldUpdateOperationsInput | string | null
    unit_content?: NullableStringFieldUpdateOperationsInput | string | null
    course_content?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type course_resourceCreateManyInput = {
    id: string
    subject?: string | null
    grade?: string | null
    textbook?: string | null
    book_type?: string | null
    unit?: string | null
    period?: string | null
    unit_content?: string | null
    course_content?: string | null
  }

  export type course_resourceUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    grade?: NullableStringFieldUpdateOperationsInput | string | null
    textbook?: NullableStringFieldUpdateOperationsInput | string | null
    book_type?: NullableStringFieldUpdateOperationsInput | string | null
    unit?: NullableStringFieldUpdateOperationsInput | string | null
    period?: NullableStringFieldUpdateOperationsInput | string | null
    unit_content?: NullableStringFieldUpdateOperationsInput | string | null
    course_content?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type course_resourceUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    subject?: NullableStringFieldUpdateOperationsInput | string | null
    grade?: NullableStringFieldUpdateOperationsInput | string | null
    textbook?: NullableStringFieldUpdateOperationsInput | string | null
    book_type?: NullableStringFieldUpdateOperationsInput | string | null
    unit?: NullableStringFieldUpdateOperationsInput | string | null
    period?: NullableStringFieldUpdateOperationsInput | string | null
    unit_content?: NullableStringFieldUpdateOperationsInput | string | null
    course_content?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type knowledge_construction_docCreateInput = {
    id: string
    muti_id?: string | null
    user_id?: string | null
    session_id?: string | null
    content?: string | null
    create_time?: Date | string | null
  }

  export type knowledge_construction_docUncheckedCreateInput = {
    id: string
    muti_id?: string | null
    user_id?: string | null
    session_id?: string | null
    content?: string | null
    create_time?: Date | string | null
  }

  export type knowledge_construction_docUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    muti_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    content?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type knowledge_construction_docUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    muti_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    content?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type knowledge_construction_docCreateManyInput = {
    id: string
    muti_id?: string | null
    user_id?: string | null
    session_id?: string | null
    content?: string | null
    create_time?: Date | string | null
  }

  export type knowledge_construction_docUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    muti_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    content?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type knowledge_construction_docUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    muti_id?: NullableStringFieldUpdateOperationsInput | string | null
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    session_id?: NullableStringFieldUpdateOperationsInput | string | null
    content?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type meeting_trickCreateInput = {
    id: string
    createtime?: Date | string | null
    userid?: string | null
    meeting_name?: string | null
    meeting_original?: string | null
    meeting_minutes?: string | null
    audio_url?: string | null
    duration?: string | null
    ab?: string | null
  }

  export type meeting_trickUncheckedCreateInput = {
    id: string
    createtime?: Date | string | null
    userid?: string | null
    meeting_name?: string | null
    meeting_original?: string | null
    meeting_minutes?: string | null
    audio_url?: string | null
    duration?: string | null
    ab?: string | null
  }

  export type meeting_trickUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_name?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_original?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_minutes?: NullableStringFieldUpdateOperationsInput | string | null
    audio_url?: NullableStringFieldUpdateOperationsInput | string | null
    duration?: NullableStringFieldUpdateOperationsInput | string | null
    ab?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type meeting_trickUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_name?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_original?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_minutes?: NullableStringFieldUpdateOperationsInput | string | null
    audio_url?: NullableStringFieldUpdateOperationsInput | string | null
    duration?: NullableStringFieldUpdateOperationsInput | string | null
    ab?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type meeting_trickCreateManyInput = {
    id: string
    createtime?: Date | string | null
    userid?: string | null
    meeting_name?: string | null
    meeting_original?: string | null
    meeting_minutes?: string | null
    audio_url?: string | null
    duration?: string | null
    ab?: string | null
  }

  export type meeting_trickUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_name?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_original?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_minutes?: NullableStringFieldUpdateOperationsInput | string | null
    audio_url?: NullableStringFieldUpdateOperationsInput | string | null
    duration?: NullableStringFieldUpdateOperationsInput | string | null
    ab?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type meeting_trickUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_name?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_original?: NullableStringFieldUpdateOperationsInput | string | null
    meeting_minutes?: NullableStringFieldUpdateOperationsInput | string | null
    audio_url?: NullableStringFieldUpdateOperationsInput | string | null
    duration?: NullableStringFieldUpdateOperationsInput | string | null
    ab?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type meeting_trick_chatCreateInput = {
    id: string
    meeting_id?: string | null
    createtime?: Date | string | null
    user_content?: string | null
    ai_content?: string | null
  }

  export type meeting_trick_chatUncheckedCreateInput = {
    id: string
    meeting_id?: string | null
    createtime?: Date | string | null
    user_content?: string | null
    ai_content?: string | null
  }

  export type meeting_trick_chatUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    meeting_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user_content?: NullableStringFieldUpdateOperationsInput | string | null
    ai_content?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type meeting_trick_chatUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    meeting_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user_content?: NullableStringFieldUpdateOperationsInput | string | null
    ai_content?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type meeting_trick_chatCreateManyInput = {
    id: string
    meeting_id?: string | null
    createtime?: Date | string | null
    user_content?: string | null
    ai_content?: string | null
  }

  export type meeting_trick_chatUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    meeting_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user_content?: NullableStringFieldUpdateOperationsInput | string | null
    ai_content?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type meeting_trick_chatUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    meeting_id?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    user_content?: NullableStringFieldUpdateOperationsInput | string | null
    ai_content?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type muti_agent_listCreateInput = {
    id: string
    userid?: string | null
    username?: string | null
    muti_name?: string | null
    description?: string | null
    isPublish?: boolean | null
    organizeid?: string | null
    content?: string | null
    create_time?: Date | string | null
    knowledge_construction?: number | null
  }

  export type muti_agent_listUncheckedCreateInput = {
    id: string
    userid?: string | null
    username?: string | null
    muti_name?: string | null
    description?: string | null
    isPublish?: boolean | null
    organizeid?: string | null
    content?: string | null
    create_time?: Date | string | null
    knowledge_construction?: number | null
  }

  export type muti_agent_listUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    muti_name?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isPublish?: NullableBoolFieldUpdateOperationsInput | boolean | null
    organizeid?: NullableStringFieldUpdateOperationsInput | string | null
    content?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    knowledge_construction?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type muti_agent_listUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    muti_name?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isPublish?: NullableBoolFieldUpdateOperationsInput | boolean | null
    organizeid?: NullableStringFieldUpdateOperationsInput | string | null
    content?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    knowledge_construction?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type muti_agent_listCreateManyInput = {
    id: string
    userid?: string | null
    username?: string | null
    muti_name?: string | null
    description?: string | null
    isPublish?: boolean | null
    organizeid?: string | null
    content?: string | null
    create_time?: Date | string | null
    knowledge_construction?: number | null
  }

  export type muti_agent_listUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    muti_name?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isPublish?: NullableBoolFieldUpdateOperationsInput | boolean | null
    organizeid?: NullableStringFieldUpdateOperationsInput | string | null
    content?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    knowledge_construction?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type muti_agent_listUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    userid?: NullableStringFieldUpdateOperationsInput | string | null
    username?: NullableStringFieldUpdateOperationsInput | string | null
    muti_name?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isPublish?: NullableBoolFieldUpdateOperationsInput | boolean | null
    organizeid?: NullableStringFieldUpdateOperationsInput | string | null
    content?: NullableStringFieldUpdateOperationsInput | string | null
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    knowledge_construction?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type park_chat_file_listCreateInput = {
    id: string
    user_id?: string | null
    file_names: string
    file_ids: string
    create_time?: Date | string | null
    file_urls?: string | null
  }

  export type park_chat_file_listUncheckedCreateInput = {
    id: string
    user_id?: string | null
    file_names: string
    file_ids: string
    create_time?: Date | string | null
    file_urls?: string | null
  }

  export type park_chat_file_listUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_names?: StringFieldUpdateOperationsInput | string
    file_ids?: StringFieldUpdateOperationsInput | string
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    file_urls?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type park_chat_file_listUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_names?: StringFieldUpdateOperationsInput | string
    file_ids?: StringFieldUpdateOperationsInput | string
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    file_urls?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type park_chat_file_listCreateManyInput = {
    id: string
    user_id?: string | null
    file_names: string
    file_ids: string
    create_time?: Date | string | null
    file_urls?: string | null
  }

  export type park_chat_file_listUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_names?: StringFieldUpdateOperationsInput | string
    file_ids?: StringFieldUpdateOperationsInput | string
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    file_urls?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type park_chat_file_listUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: NullableStringFieldUpdateOperationsInput | string | null
    file_names?: StringFieldUpdateOperationsInput | string
    file_ids?: StringFieldUpdateOperationsInput | string
    create_time?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    file_urls?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type tokenCreateInput = {
    id: string
    schoolId?: string | null
    key?: string | null
    createUsername?: string | null
    createtime?: Date | string | null
  }

  export type tokenUncheckedCreateInput = {
    id: string
    schoolId?: string | null
    key?: string | null
    createUsername?: string | null
    createtime?: Date | string | null
  }

  export type tokenUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    schoolId?: NullableStringFieldUpdateOperationsInput | string | null
    key?: NullableStringFieldUpdateOperationsInput | string | null
    createUsername?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type tokenUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    schoolId?: NullableStringFieldUpdateOperationsInput | string | null
    key?: NullableStringFieldUpdateOperationsInput | string | null
    createUsername?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type tokenCreateManyInput = {
    id: string
    schoolId?: string | null
    key?: string | null
    createUsername?: string | null
    createtime?: Date | string | null
  }

  export type tokenUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    schoolId?: NullableStringFieldUpdateOperationsInput | string | null
    key?: NullableStringFieldUpdateOperationsInput | string | null
    createUsername?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type tokenUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    schoolId?: NullableStringFieldUpdateOperationsInput | string | null
    key?: NullableStringFieldUpdateOperationsInput | string | null
    createUsername?: NullableStringFieldUpdateOperationsInput | string | null
    createtime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type StringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type DateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type AWS_Policy_RoleCountOrderByAggregateInput = {
    id?: SortOrder
    assistant_id?: SortOrder
    agent_bedrock_policy?: SortOrder
    agent_kb_schema_policy?: SortOrder
    kb_bedrock_policy?: SortOrder
    kb_aoss_policy?: SortOrder
    kb_s3_policy?: SortOrder
    agent_role_name?: SortOrder
    kb_role_name?: SortOrder
    createtime?: SortOrder
  }

  export type AWS_Policy_RoleMaxOrderByAggregateInput = {
    id?: SortOrder
    assistant_id?: SortOrder
    agent_bedrock_policy?: SortOrder
    agent_kb_schema_policy?: SortOrder
    kb_bedrock_policy?: SortOrder
    kb_aoss_policy?: SortOrder
    kb_s3_policy?: SortOrder
    agent_role_name?: SortOrder
    kb_role_name?: SortOrder
    createtime?: SortOrder
  }

  export type AWS_Policy_RoleMinOrderByAggregateInput = {
    id?: SortOrder
    assistant_id?: SortOrder
    agent_bedrock_policy?: SortOrder
    agent_kb_schema_policy?: SortOrder
    kb_bedrock_policy?: SortOrder
    kb_aoss_policy?: SortOrder
    kb_s3_policy?: SortOrder
    agent_role_name?: SortOrder
    kb_role_name?: SortOrder
    createtime?: SortOrder
  }

  export type StringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type BoolNullableFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableFilter<$PrismaModel> | boolean | null
  }

  export type Ai_Agent_AssistantsCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    username?: SortOrder
    agent_sort?: SortOrder
    agent_tag?: SortOrder
    assistantName?: SortOrder
    description?: SortOrder
    prologue?: SortOrder
    headUrl?: SortOrder
    instructions?: SortOrder
    isRetrieval?: SortOrder
    isCode?: SortOrder
    isGoogle?: SortOrder
    isDalleImage?: SortOrder
    functionNames?: SortOrder
    functionContents?: SortOrder
    assistant_id?: SortOrder
    thread_id?: SortOrder
    file_ids?: SortOrder
    file_names?: SortOrder
    isPublish?: SortOrder
    organize_id?: SortOrder
    vector_store_id?: SortOrder
    modelType?: SortOrder
    createtime?: SortOrder
    updatetime?: SortOrder
    a?: SortOrder
  }

  export type Ai_Agent_AssistantsMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    username?: SortOrder
    agent_sort?: SortOrder
    agent_tag?: SortOrder
    assistantName?: SortOrder
    description?: SortOrder
    prologue?: SortOrder
    headUrl?: SortOrder
    instructions?: SortOrder
    isRetrieval?: SortOrder
    isCode?: SortOrder
    isGoogle?: SortOrder
    isDalleImage?: SortOrder
    functionNames?: SortOrder
    functionContents?: SortOrder
    assistant_id?: SortOrder
    thread_id?: SortOrder
    file_ids?: SortOrder
    file_names?: SortOrder
    isPublish?: SortOrder
    organize_id?: SortOrder
    vector_store_id?: SortOrder
    modelType?: SortOrder
    createtime?: SortOrder
    updatetime?: SortOrder
    a?: SortOrder
  }

  export type Ai_Agent_AssistantsMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    username?: SortOrder
    agent_sort?: SortOrder
    agent_tag?: SortOrder
    assistantName?: SortOrder
    description?: SortOrder
    prologue?: SortOrder
    headUrl?: SortOrder
    instructions?: SortOrder
    isRetrieval?: SortOrder
    isCode?: SortOrder
    isGoogle?: SortOrder
    isDalleImage?: SortOrder
    functionNames?: SortOrder
    functionContents?: SortOrder
    assistant_id?: SortOrder
    thread_id?: SortOrder
    file_ids?: SortOrder
    file_names?: SortOrder
    isPublish?: SortOrder
    organize_id?: SortOrder
    vector_store_id?: SortOrder
    modelType?: SortOrder
    createtime?: SortOrder
    updatetime?: SortOrder
    a?: SortOrder
  }

  export type BoolNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableWithAggregatesFilter<$PrismaModel> | boolean | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedBoolNullableFilter<$PrismaModel>
    _max?: NestedBoolNullableFilter<$PrismaModel>
  }

  export type Ai_Agent_ThreadsCountOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    assistant_id?: SortOrder
    thread_id?: SortOrder
    createtime?: SortOrder
    session_name?: SortOrder
  }

  export type Ai_Agent_ThreadsMaxOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    assistant_id?: SortOrder
    thread_id?: SortOrder
    createtime?: SortOrder
    session_name?: SortOrder
  }

  export type Ai_Agent_ThreadsMinOrderByAggregateInput = {
    id?: SortOrder
    userId?: SortOrder
    assistant_id?: SortOrder
    thread_id?: SortOrder
    createtime?: SortOrder
    session_name?: SortOrder
  }

  export type AssistantCountOrderByAggregateInput = {
    id?: SortOrder
    uid?: SortOrder
    assistant_id?: SortOrder
    thread_id?: SortOrder
    file_ids?: SortOrder
    vector_store_id?: SortOrder
    createtime?: SortOrder
  }

  export type AssistantMaxOrderByAggregateInput = {
    id?: SortOrder
    uid?: SortOrder
    assistant_id?: SortOrder
    thread_id?: SortOrder
    file_ids?: SortOrder
    vector_store_id?: SortOrder
    createtime?: SortOrder
  }

  export type AssistantMinOrderByAggregateInput = {
    id?: SortOrder
    uid?: SortOrder
    assistant_id?: SortOrder
    thread_id?: SortOrder
    file_ids?: SortOrder
    vector_store_id?: SortOrder
    createtime?: SortOrder
  }

  export type IntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type ChatCountOrderByAggregateInput = {
    id?: SortOrder
    groupid?: SortOrder
    userid?: SortOrder
    username?: SortOrder
    answer?: SortOrder
    problem?: SortOrder
    createtime?: SortOrder
    fileid?: SortOrder
    isMindMap?: SortOrder
    filename?: SortOrder
    session_name?: SortOrder
    scene?: SortOrder
  }

  export type ChatAvgOrderByAggregateInput = {
    isMindMap?: SortOrder
  }

  export type ChatMaxOrderByAggregateInput = {
    id?: SortOrder
    groupid?: SortOrder
    userid?: SortOrder
    username?: SortOrder
    answer?: SortOrder
    problem?: SortOrder
    createtime?: SortOrder
    fileid?: SortOrder
    isMindMap?: SortOrder
    filename?: SortOrder
    session_name?: SortOrder
    scene?: SortOrder
  }

  export type ChatMinOrderByAggregateInput = {
    id?: SortOrder
    groupid?: SortOrder
    userid?: SortOrder
    username?: SortOrder
    answer?: SortOrder
    problem?: SortOrder
    createtime?: SortOrder
    fileid?: SortOrder
    isMindMap?: SortOrder
    filename?: SortOrder
    session_name?: SortOrder
    scene?: SortOrder
  }

  export type ChatSumOrderByAggregateInput = {
    isMindMap?: SortOrder
  }

  export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type DispositionCountOrderByAggregateInput = {
    id?: SortOrder
    module?: SortOrder
    disposition_class?: SortOrder
    disposition_type?: SortOrder
    disposition_style?: SortOrder
    disposition_theme?: SortOrder
    user_id?: SortOrder
    create_time?: SortOrder
  }

  export type DispositionMaxOrderByAggregateInput = {
    id?: SortOrder
    module?: SortOrder
    disposition_class?: SortOrder
    disposition_type?: SortOrder
    disposition_style?: SortOrder
    disposition_theme?: SortOrder
    user_id?: SortOrder
    create_time?: SortOrder
  }

  export type DispositionMinOrderByAggregateInput = {
    id?: SortOrder
    module?: SortOrder
    disposition_class?: SortOrder
    disposition_type?: SortOrder
    disposition_style?: SortOrder
    disposition_theme?: SortOrder
    user_id?: SortOrder
    create_time?: SortOrder
  }

  export type GroupCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userid?: SortOrder
    createtime?: SortOrder
  }

  export type GroupMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userid?: SortOrder
    createtime?: SortOrder
  }

  export type GroupMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userid?: SortOrder
    createtime?: SortOrder
  }

  export type GroupFileCountOrderByAggregateInput = {
    id?: SortOrder
    userid?: SortOrder
    fileurl?: SortOrder
    filename?: SortOrder
    groupid?: SortOrder
    abstract?: SortOrder
    assistantFileId?: SortOrder
    modelType?: SortOrder
    createtime?: SortOrder
  }

  export type GroupFileMaxOrderByAggregateInput = {
    id?: SortOrder
    userid?: SortOrder
    fileurl?: SortOrder
    filename?: SortOrder
    groupid?: SortOrder
    abstract?: SortOrder
    assistantFileId?: SortOrder
    modelType?: SortOrder
    createtime?: SortOrder
  }

  export type GroupFileMinOrderByAggregateInput = {
    id?: SortOrder
    userid?: SortOrder
    fileurl?: SortOrder
    filename?: SortOrder
    groupid?: SortOrder
    abstract?: SortOrder
    assistantFileId?: SortOrder
    modelType?: SortOrder
    createtime?: SortOrder
  }

  export type InvitationCodeCountOrderByAggregateInput = {
    id?: SortOrder
    cid?: SortOrder
    themeId?: SortOrder
    type?: SortOrder
    invitationCode?: SortOrder
    createtime?: SortOrder
  }

  export type InvitationCodeAvgOrderByAggregateInput = {
    type?: SortOrder
  }

  export type InvitationCodeMaxOrderByAggregateInput = {
    id?: SortOrder
    cid?: SortOrder
    themeId?: SortOrder
    type?: SortOrder
    invitationCode?: SortOrder
    createtime?: SortOrder
  }

  export type InvitationCodeMinOrderByAggregateInput = {
    id?: SortOrder
    cid?: SortOrder
    themeId?: SortOrder
    type?: SortOrder
    invitationCode?: SortOrder
    createtime?: SortOrder
  }

  export type InvitationCodeSumOrderByAggregateInput = {
    type?: SortOrder
  }

  export type ai_agent_park_sessionCountOrderByAggregateInput = {
    id?: SortOrder
    session_name?: SortOrder
    user_id?: SortOrder
    isCocoNote?: SortOrder
    createtime?: SortOrder
    work_area_text?: SortOrder
    scene?: SortOrder
  }

  export type ai_agent_park_sessionAvgOrderByAggregateInput = {
    isCocoNote?: SortOrder
  }

  export type ai_agent_park_sessionMaxOrderByAggregateInput = {
    id?: SortOrder
    session_name?: SortOrder
    user_id?: SortOrder
    isCocoNote?: SortOrder
    createtime?: SortOrder
    work_area_text?: SortOrder
    scene?: SortOrder
  }

  export type ai_agent_park_sessionMinOrderByAggregateInput = {
    id?: SortOrder
    session_name?: SortOrder
    user_id?: SortOrder
    isCocoNote?: SortOrder
    createtime?: SortOrder
    work_area_text?: SortOrder
    scene?: SortOrder
  }

  export type ai_agent_park_sessionSumOrderByAggregateInput = {
    isCocoNote?: SortOrder
  }

  export type IntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type classroom_ob_commentCountOrderByAggregateInput = {
    id?: SortOrder
    module_id?: SortOrder
    module_name?: SortOrder
    nickname?: SortOrder
    commentContent?: SortOrder
    audit_status?: SortOrder
    t_id?: SortOrder
    create_time?: SortOrder
  }

  export type classroom_ob_commentAvgOrderByAggregateInput = {
    audit_status?: SortOrder
  }

  export type classroom_ob_commentMaxOrderByAggregateInput = {
    id?: SortOrder
    module_id?: SortOrder
    module_name?: SortOrder
    nickname?: SortOrder
    commentContent?: SortOrder
    audit_status?: SortOrder
    t_id?: SortOrder
    create_time?: SortOrder
  }

  export type classroom_ob_commentMinOrderByAggregateInput = {
    id?: SortOrder
    module_id?: SortOrder
    module_name?: SortOrder
    nickname?: SortOrder
    commentContent?: SortOrder
    audit_status?: SortOrder
    t_id?: SortOrder
    create_time?: SortOrder
  }

  export type classroom_ob_commentSumOrderByAggregateInput = {
    audit_status?: SortOrder
  }

  export type IntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type classroom_observationCountOrderByAggregateInput = {
    id?: SortOrder
    jsonData?: SortOrder
    Type?: SortOrder
    tIndex?: SortOrder
    tId?: SortOrder
    createtime?: SortOrder
    like_num?: SortOrder
    like_data?: SortOrder
    userid?: SortOrder
    isdel?: SortOrder
    limitData?: SortOrder
  }

  export type classroom_observationAvgOrderByAggregateInput = {
    Type?: SortOrder
    tIndex?: SortOrder
    like_num?: SortOrder
    isdel?: SortOrder
  }

  export type classroom_observationMaxOrderByAggregateInput = {
    id?: SortOrder
    jsonData?: SortOrder
    Type?: SortOrder
    tIndex?: SortOrder
    tId?: SortOrder
    createtime?: SortOrder
    like_num?: SortOrder
    like_data?: SortOrder
    userid?: SortOrder
    isdel?: SortOrder
    limitData?: SortOrder
  }

  export type classroom_observationMinOrderByAggregateInput = {
    id?: SortOrder
    jsonData?: SortOrder
    Type?: SortOrder
    tIndex?: SortOrder
    tId?: SortOrder
    createtime?: SortOrder
    like_num?: SortOrder
    like_data?: SortOrder
    userid?: SortOrder
    isdel?: SortOrder
    limitData?: SortOrder
  }

  export type classroom_observationSumOrderByAggregateInput = {
    Type?: SortOrder
    tIndex?: SortOrder
    like_num?: SortOrder
    isdel?: SortOrder
  }

  export type course_resourceCountOrderByAggregateInput = {
    id?: SortOrder
    subject?: SortOrder
    grade?: SortOrder
    textbook?: SortOrder
    book_type?: SortOrder
    unit?: SortOrder
    period?: SortOrder
    unit_content?: SortOrder
    course_content?: SortOrder
  }

  export type course_resourceMaxOrderByAggregateInput = {
    id?: SortOrder
    subject?: SortOrder
    grade?: SortOrder
    textbook?: SortOrder
    book_type?: SortOrder
    unit?: SortOrder
    period?: SortOrder
    unit_content?: SortOrder
    course_content?: SortOrder
  }

  export type course_resourceMinOrderByAggregateInput = {
    id?: SortOrder
    subject?: SortOrder
    grade?: SortOrder
    textbook?: SortOrder
    book_type?: SortOrder
    unit?: SortOrder
    period?: SortOrder
    unit_content?: SortOrder
    course_content?: SortOrder
  }

  export type knowledge_construction_docCountOrderByAggregateInput = {
    id?: SortOrder
    muti_id?: SortOrder
    user_id?: SortOrder
    session_id?: SortOrder
    content?: SortOrder
    create_time?: SortOrder
  }

  export type knowledge_construction_docMaxOrderByAggregateInput = {
    id?: SortOrder
    muti_id?: SortOrder
    user_id?: SortOrder
    session_id?: SortOrder
    content?: SortOrder
    create_time?: SortOrder
  }

  export type knowledge_construction_docMinOrderByAggregateInput = {
    id?: SortOrder
    muti_id?: SortOrder
    user_id?: SortOrder
    session_id?: SortOrder
    content?: SortOrder
    create_time?: SortOrder
  }

  export type meeting_trickCountOrderByAggregateInput = {
    id?: SortOrder
    createtime?: SortOrder
    userid?: SortOrder
    meeting_name?: SortOrder
    meeting_original?: SortOrder
    meeting_minutes?: SortOrder
    audio_url?: SortOrder
    duration?: SortOrder
    ab?: SortOrder
  }

  export type meeting_trickMaxOrderByAggregateInput = {
    id?: SortOrder
    createtime?: SortOrder
    userid?: SortOrder
    meeting_name?: SortOrder
    meeting_original?: SortOrder
    meeting_minutes?: SortOrder
    audio_url?: SortOrder
    duration?: SortOrder
    ab?: SortOrder
  }

  export type meeting_trickMinOrderByAggregateInput = {
    id?: SortOrder
    createtime?: SortOrder
    userid?: SortOrder
    meeting_name?: SortOrder
    meeting_original?: SortOrder
    meeting_minutes?: SortOrder
    audio_url?: SortOrder
    duration?: SortOrder
    ab?: SortOrder
  }

  export type meeting_trick_chatCountOrderByAggregateInput = {
    id?: SortOrder
    meeting_id?: SortOrder
    createtime?: SortOrder
    user_content?: SortOrder
    ai_content?: SortOrder
  }

  export type meeting_trick_chatMaxOrderByAggregateInput = {
    id?: SortOrder
    meeting_id?: SortOrder
    createtime?: SortOrder
    user_content?: SortOrder
    ai_content?: SortOrder
  }

  export type meeting_trick_chatMinOrderByAggregateInput = {
    id?: SortOrder
    meeting_id?: SortOrder
    createtime?: SortOrder
    user_content?: SortOrder
    ai_content?: SortOrder
  }

  export type muti_agent_listCountOrderByAggregateInput = {
    id?: SortOrder
    userid?: SortOrder
    username?: SortOrder
    muti_name?: SortOrder
    description?: SortOrder
    isPublish?: SortOrder
    organizeid?: SortOrder
    content?: SortOrder
    create_time?: SortOrder
    knowledge_construction?: SortOrder
  }

  export type muti_agent_listAvgOrderByAggregateInput = {
    knowledge_construction?: SortOrder
  }

  export type muti_agent_listMaxOrderByAggregateInput = {
    id?: SortOrder
    userid?: SortOrder
    username?: SortOrder
    muti_name?: SortOrder
    description?: SortOrder
    isPublish?: SortOrder
    organizeid?: SortOrder
    content?: SortOrder
    create_time?: SortOrder
    knowledge_construction?: SortOrder
  }

  export type muti_agent_listMinOrderByAggregateInput = {
    id?: SortOrder
    userid?: SortOrder
    username?: SortOrder
    muti_name?: SortOrder
    description?: SortOrder
    isPublish?: SortOrder
    organizeid?: SortOrder
    content?: SortOrder
    create_time?: SortOrder
    knowledge_construction?: SortOrder
  }

  export type muti_agent_listSumOrderByAggregateInput = {
    knowledge_construction?: SortOrder
  }

  export type park_chat_file_listCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    file_names?: SortOrder
    file_ids?: SortOrder
    create_time?: SortOrder
    file_urls?: SortOrder
  }

  export type park_chat_file_listMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    file_names?: SortOrder
    file_ids?: SortOrder
    create_time?: SortOrder
    file_urls?: SortOrder
  }

  export type park_chat_file_listMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    file_names?: SortOrder
    file_ids?: SortOrder
    create_time?: SortOrder
    file_urls?: SortOrder
  }

  export type tokenCountOrderByAggregateInput = {
    id?: SortOrder
    schoolId?: SortOrder
    key?: SortOrder
    createUsername?: SortOrder
    createtime?: SortOrder
  }

  export type tokenMaxOrderByAggregateInput = {
    id?: SortOrder
    schoolId?: SortOrder
    key?: SortOrder
    createUsername?: SortOrder
    createtime?: SortOrder
  }

  export type tokenMinOrderByAggregateInput = {
    id?: SortOrder
    schoolId?: SortOrder
    key?: SortOrder
    createUsername?: SortOrder
    createtime?: SortOrder
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type NullableBoolFieldUpdateOperationsInput = {
    set?: boolean | null
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type NestedDateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type NestedIntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | null
    notIn?: Date[] | string[] | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type NestedBoolNullableFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableFilter<$PrismaModel> | boolean | null
  }

  export type NestedBoolNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel> | null
    not?: NestedBoolNullableWithAggregatesFilter<$PrismaModel> | boolean | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedBoolNullableFilter<$PrismaModel>
    _max?: NestedBoolNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type NestedFloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type NestedFloatFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }



  /**
   * Aliases for legacy arg types
   */
    /**
     * @deprecated Use AWS_Policy_RoleDefaultArgs instead
     */
    export type AWS_Policy_RoleArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AWS_Policy_RoleDefaultArgs<ExtArgs>
    /**
     * @deprecated Use Ai_Agent_AssistantsDefaultArgs instead
     */
    export type Ai_Agent_AssistantsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = Ai_Agent_AssistantsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use Ai_Agent_ThreadsDefaultArgs instead
     */
    export type Ai_Agent_ThreadsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = Ai_Agent_ThreadsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AssistantDefaultArgs instead
     */
    export type AssistantArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AssistantDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChatDefaultArgs instead
     */
    export type ChatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChatDefaultArgs<ExtArgs>
    /**
     * @deprecated Use DispositionDefaultArgs instead
     */
    export type DispositionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = DispositionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use GroupDefaultArgs instead
     */
    export type GroupArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = GroupDefaultArgs<ExtArgs>
    /**
     * @deprecated Use GroupFileDefaultArgs instead
     */
    export type GroupFileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = GroupFileDefaultArgs<ExtArgs>
    /**
     * @deprecated Use InvitationCodeDefaultArgs instead
     */
    export type InvitationCodeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = InvitationCodeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ai_agent_park_sessionDefaultArgs instead
     */
    export type ai_agent_park_sessionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ai_agent_park_sessionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use classroom_ob_commentDefaultArgs instead
     */
    export type classroom_ob_commentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = classroom_ob_commentDefaultArgs<ExtArgs>
    /**
     * @deprecated Use classroom_observationDefaultArgs instead
     */
    export type classroom_observationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = classroom_observationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use course_resourceDefaultArgs instead
     */
    export type course_resourceArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = course_resourceDefaultArgs<ExtArgs>
    /**
     * @deprecated Use knowledge_construction_docDefaultArgs instead
     */
    export type knowledge_construction_docArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = knowledge_construction_docDefaultArgs<ExtArgs>
    /**
     * @deprecated Use meeting_trickDefaultArgs instead
     */
    export type meeting_trickArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = meeting_trickDefaultArgs<ExtArgs>
    /**
     * @deprecated Use meeting_trick_chatDefaultArgs instead
     */
    export type meeting_trick_chatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = meeting_trick_chatDefaultArgs<ExtArgs>
    /**
     * @deprecated Use muti_agent_listDefaultArgs instead
     */
    export type muti_agent_listArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = muti_agent_listDefaultArgs<ExtArgs>
    /**
     * @deprecated Use park_chat_file_listDefaultArgs instead
     */
    export type park_chat_file_listArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = park_chat_file_listDefaultArgs<ExtArgs>
    /**
     * @deprecated Use tokenDefaultArgs instead
     */
    export type tokenArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = tokenDefaultArgs<ExtArgs>

  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}