ghostfolio/node_modules/.prisma/client/index.d.ts

/**
 * Client
**/

import * as runtime from '@prisma/client/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 Access
 * 
 */
export type Access = $Result.DefaultSelection<Prisma.$AccessPayload>
/**
 * Model Account
 * 
 */
export type Account = $Result.DefaultSelection<Prisma.$AccountPayload>
/**
 * Model AccountBalance
 * 
 */
export type AccountBalance = $Result.DefaultSelection<Prisma.$AccountBalancePayload>
/**
 * Model Analytics
 * 
 */
export type Analytics = $Result.DefaultSelection<Prisma.$AnalyticsPayload>
/**
 * Model ApiKey
 * 
 */
export type ApiKey = $Result.DefaultSelection<Prisma.$ApiKeyPayload>
/**
 * Model AssetProfileResolution
 * 
 */
export type AssetProfileResolution = $Result.DefaultSelection<Prisma.$AssetProfileResolutionPayload>
/**
 * Model AuthDevice
 * 
 */
export type AuthDevice = $Result.DefaultSelection<Prisma.$AuthDevicePayload>
/**
 * Model MarketData
 * 
 */
export type MarketData = $Result.DefaultSelection<Prisma.$MarketDataPayload>
/**
 * Model Order
 * 
 */
export type Order = $Result.DefaultSelection<Prisma.$OrderPayload>
/**
 * Model Platform
 * 
 */
export type Platform = $Result.DefaultSelection<Prisma.$PlatformPayload>
/**
 * Model Property
 * 
 */
export type Property = $Result.DefaultSelection<Prisma.$PropertyPayload>
/**
 * Model Settings
 * 
 */
export type Settings = $Result.DefaultSelection<Prisma.$SettingsPayload>
/**
 * Model SymbolProfile
 * 
 */
export type SymbolProfile = $Result.DefaultSelection<Prisma.$SymbolProfilePayload>
/**
 * Model SymbolProfileOverrides
 * 
 */
export type SymbolProfileOverrides = $Result.DefaultSelection<Prisma.$SymbolProfileOverridesPayload>
/**
 * Model Subscription
 * 
 */
export type Subscription = $Result.DefaultSelection<Prisma.$SubscriptionPayload>
/**
 * Model Tag
 * 
 */
export type Tag = $Result.DefaultSelection<Prisma.$TagPayload>
/**
 * Model User
 * 
 */
export type User = $Result.DefaultSelection<Prisma.$UserPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const AccessPermission: {
  READ: 'READ',
  READ_RESTRICTED: 'READ_RESTRICTED'
};

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


export const AssetClass: {
  ALTERNATIVE_INVESTMENT: 'ALTERNATIVE_INVESTMENT',
  COMMODITY: 'COMMODITY',
  EQUITY: 'EQUITY',
  FIXED_INCOME: 'FIXED_INCOME',
  LIQUIDITY: 'LIQUIDITY',
  REAL_ESTATE: 'REAL_ESTATE'
};

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


export const AssetSubClass: {
  BOND: 'BOND',
  CASH: 'CASH',
  COLLECTIBLE: 'COLLECTIBLE',
  COMMODITY: 'COMMODITY',
  CRYPTOCURRENCY: 'CRYPTOCURRENCY',
  ETF: 'ETF',
  MUTUALFUND: 'MUTUALFUND',
  PRECIOUS_METAL: 'PRECIOUS_METAL',
  PRIVATE_EQUITY: 'PRIVATE_EQUITY',
  STOCK: 'STOCK'
};

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


export const DataSource: {
  ALPHA_VANTAGE: 'ALPHA_VANTAGE',
  COINGECKO: 'COINGECKO',
  EOD_HISTORICAL_DATA: 'EOD_HISTORICAL_DATA',
  FINANCIAL_MODELING_PREP: 'FINANCIAL_MODELING_PREP',
  GHOSTFOLIO: 'GHOSTFOLIO',
  GOOGLE_SHEETS: 'GOOGLE_SHEETS',
  MANUAL: 'MANUAL',
  RAPID_API: 'RAPID_API',
  YAHOO: 'YAHOO'
};

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


export const MarketDataState: {
  CLOSE: 'CLOSE',
  INTRADAY: 'INTRADAY'
};

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


export const Provider: {
  ANONYMOUS: 'ANONYMOUS',
  GOOGLE: 'GOOGLE',
  INTERNET_IDENTITY: 'INTERNET_IDENTITY',
  OIDC: 'OIDC'
};

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


export const Role: {
  ADMIN: 'ADMIN',
  DEMO: 'DEMO',
  INACTIVE: 'INACTIVE',
  USER: 'USER'
};

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


export const Type: {
  BUY: 'BUY',
  DIVIDEND: 'DIVIDEND',
  FEE: 'FEE',
  INTEREST: 'INTEREST',
  LIABILITY: 'LIABILITY',
  SELL: 'SELL'
};

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


export const ViewMode: {
  DEFAULT: 'DEFAULT',
  ZEN: 'ZEN'
};

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

}

export type AccessPermission = $Enums.AccessPermission

export const AccessPermission: typeof $Enums.AccessPermission

export type AssetClass = $Enums.AssetClass

export const AssetClass: typeof $Enums.AssetClass

export type AssetSubClass = $Enums.AssetSubClass

export const AssetSubClass: typeof $Enums.AssetSubClass

export type DataSource = $Enums.DataSource

export const DataSource: typeof $Enums.DataSource

export type MarketDataState = $Enums.MarketDataState

export const MarketDataState: typeof $Enums.MarketDataState

export type Provider = $Enums.Provider

export const Provider: typeof $Enums.Provider

export type Role = $Enums.Role

export const Role: typeof $Enums.Role

export type Type = $Enums.Type

export const Type: typeof $Enums.Type

export type ViewMode = $Enums.ViewMode

export const ViewMode: typeof $Enums.ViewMode

/**
 * ##  Prisma Client ʲˢ
 *
 * Type-safe database client for TypeScript & Node.js
 * @example
 * ```
 * const prisma = new PrismaClient()
 * // Fetch zero or more Accesses
 * const accesses = await prisma.access.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,
  const 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 Accesses
   * const accesses = await prisma.access.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): PrismaClient;

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

  /**
   * Disconnect from the database
   */
  $disconnect(): $Utils.JsPromise<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<ClientOptions>, ExtArgs, $Utils.Call<Prisma.TypeMapCb<ClientOptions>, {
    extArgs: ExtArgs
  }>>

      /**
   * `prisma.access`: Exposes CRUD operations for the **Access** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Accesses
    * const accesses = await prisma.access.findMany()
    * ```
    */
  get access(): Prisma.AccessDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.account`: Exposes CRUD operations for the **Account** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Accounts
    * const accounts = await prisma.account.findMany()
    * ```
    */
  get account(): Prisma.AccountDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.accountBalance`: Exposes CRUD operations for the **AccountBalance** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AccountBalances
    * const accountBalances = await prisma.accountBalance.findMany()
    * ```
    */
  get accountBalance(): Prisma.AccountBalanceDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.analytics`: Exposes CRUD operations for the **Analytics** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Analytics
    * const analytics = await prisma.analytics.findMany()
    * ```
    */
  get analytics(): Prisma.AnalyticsDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.apiKey`: Exposes CRUD operations for the **ApiKey** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ApiKeys
    * const apiKeys = await prisma.apiKey.findMany()
    * ```
    */
  get apiKey(): Prisma.ApiKeyDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.assetProfileResolution`: Exposes CRUD operations for the **AssetProfileResolution** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AssetProfileResolutions
    * const assetProfileResolutions = await prisma.assetProfileResolution.findMany()
    * ```
    */
  get assetProfileResolution(): Prisma.AssetProfileResolutionDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.authDevice`: Exposes CRUD operations for the **AuthDevice** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AuthDevices
    * const authDevices = await prisma.authDevice.findMany()
    * ```
    */
  get authDevice(): Prisma.AuthDeviceDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.marketData`: Exposes CRUD operations for the **MarketData** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MarketData
    * const marketData = await prisma.marketData.findMany()
    * ```
    */
  get marketData(): Prisma.MarketDataDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.order`: Exposes CRUD operations for the **Order** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Orders
    * const orders = await prisma.order.findMany()
    * ```
    */
  get order(): Prisma.OrderDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.platform`: Exposes CRUD operations for the **Platform** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Platforms
    * const platforms = await prisma.platform.findMany()
    * ```
    */
  get platform(): Prisma.PlatformDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.property`: Exposes CRUD operations for the **Property** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Properties
    * const properties = await prisma.property.findMany()
    * ```
    */
  get property(): Prisma.PropertyDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.settings`: Exposes CRUD operations for the **Settings** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Settings
    * const settings = await prisma.settings.findMany()
    * ```
    */
  get settings(): Prisma.SettingsDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.symbolProfile`: Exposes CRUD operations for the **SymbolProfile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more SymbolProfiles
    * const symbolProfiles = await prisma.symbolProfile.findMany()
    * ```
    */
  get symbolProfile(): Prisma.SymbolProfileDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.symbolProfileOverrides`: Exposes CRUD operations for the **SymbolProfileOverrides** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more SymbolProfileOverrides
    * const symbolProfileOverrides = await prisma.symbolProfileOverrides.findMany()
    * ```
    */
  get symbolProfileOverrides(): Prisma.SymbolProfileOverridesDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.subscription`: Exposes CRUD operations for the **Subscription** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Subscriptions
    * const subscriptions = await prisma.subscription.findMany()
    * ```
    */
  get subscription(): Prisma.SubscriptionDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.tag`: Exposes CRUD operations for the **Tag** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Tags
    * const tags = await prisma.tag.findMany()
    * ```
    */
  get tag(): Prisma.TagDelegate<ExtArgs, ClientOptions>;

  /**
   * `prisma.user`: Exposes CRUD operations for the **User** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Users
    * const users = await prisma.user.findMany()
    * ```
    */
  get user(): Prisma.UserDelegate<ExtArgs, ClientOptions>;
}

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

  /**
   * 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: 6.19.0
   * Query Engine version: 2ba551f319ab1df4bc874a89965d8b3641056773
   */
  export type PrismaVersion = {
    client: string
  }

  export const prismaVersion: PrismaVersion

  /**
   * Utility Types
   */


  export import Bytes = runtime.Bytes
  export import JsonObject = runtime.JsonObject
  export import JsonArray = runtime.JsonArray
  export import JsonValue = runtime.JsonValue
  export import InputJsonObject = runtime.InputJsonObject
  export import InputJsonArray = runtime.InputJsonArray
  export import InputJsonValue = runtime.InputJsonValue

  /**
   * 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 ? P : never]-?: O[P]} & O
    : never>;

  type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;

  export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
  /** End Helper Types for "Merge" **/

  export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;

  /**
  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: {
    Access: 'Access',
    Account: 'Account',
    AccountBalance: 'AccountBalance',
    Analytics: 'Analytics',
    ApiKey: 'ApiKey',
    AssetProfileResolution: 'AssetProfileResolution',
    AuthDevice: 'AuthDevice',
    MarketData: 'MarketData',
    Order: 'Order',
    Platform: 'Platform',
    Property: 'Property',
    Settings: 'Settings',
    SymbolProfile: 'SymbolProfile',
    SymbolProfileOverrides: 'SymbolProfileOverrides',
    Subscription: 'Subscription',
    Tag: 'Tag',
    User: 'User'
  };

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


  export type Datasources = {
    db?: Datasource
  }

  interface TypeMapCb<ClientOptions = {}> extends $Utils.Fn<{extArgs: $Extensions.InternalArgs }, $Utils.Record<string, any>> {
    returns: Prisma.TypeMap<this['params']['extArgs'], ClientOptions extends { omit: infer OmitOptions } ? OmitOptions : {}>
  }

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
    globalOmitOptions: {
      omit: GlobalOmitOptions
    }
    meta: {
      modelProps: "access" | "account" | "accountBalance" | "analytics" | "apiKey" | "assetProfileResolution" | "authDevice" | "marketData" | "order" | "platform" | "property" | "settings" | "symbolProfile" | "symbolProfileOverrides" | "subscription" | "tag" | "user"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      Access: {
        payload: Prisma.$AccessPayload<ExtArgs>
        fields: Prisma.AccessFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AccessFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AccessFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload>
          }
          findFirst: {
            args: Prisma.AccessFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AccessFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload>
          }
          findMany: {
            args: Prisma.AccessFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload>[]
          }
          create: {
            args: Prisma.AccessCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload>
          }
          createMany: {
            args: Prisma.AccessCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AccessCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload>[]
          }
          delete: {
            args: Prisma.AccessDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload>
          }
          update: {
            args: Prisma.AccessUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload>
          }
          deleteMany: {
            args: Prisma.AccessDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AccessUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.AccessUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload>[]
          }
          upsert: {
            args: Prisma.AccessUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccessPayload>
          }
          aggregate: {
            args: Prisma.AccessAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAccess>
          }
          groupBy: {
            args: Prisma.AccessGroupByArgs<ExtArgs>
            result: $Utils.Optional<AccessGroupByOutputType>[]
          }
          count: {
            args: Prisma.AccessCountArgs<ExtArgs>
            result: $Utils.Optional<AccessCountAggregateOutputType> | number
          }
        }
      }
      Account: {
        payload: Prisma.$AccountPayload<ExtArgs>
        fields: Prisma.AccountFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AccountFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AccountFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          findFirst: {
            args: Prisma.AccountFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AccountFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          findMany: {
            args: Prisma.AccountFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
          }
          create: {
            args: Prisma.AccountCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          createMany: {
            args: Prisma.AccountCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AccountCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
          }
          delete: {
            args: Prisma.AccountDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          update: {
            args: Prisma.AccountUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          deleteMany: {
            args: Prisma.AccountDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AccountUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.AccountUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>[]
          }
          upsert: {
            args: Prisma.AccountUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountPayload>
          }
          aggregate: {
            args: Prisma.AccountAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAccount>
          }
          groupBy: {
            args: Prisma.AccountGroupByArgs<ExtArgs>
            result: $Utils.Optional<AccountGroupByOutputType>[]
          }
          count: {
            args: Prisma.AccountCountArgs<ExtArgs>
            result: $Utils.Optional<AccountCountAggregateOutputType> | number
          }
        }
      }
      AccountBalance: {
        payload: Prisma.$AccountBalancePayload<ExtArgs>
        fields: Prisma.AccountBalanceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AccountBalanceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AccountBalanceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload>
          }
          findFirst: {
            args: Prisma.AccountBalanceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AccountBalanceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload>
          }
          findMany: {
            args: Prisma.AccountBalanceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload>[]
          }
          create: {
            args: Prisma.AccountBalanceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload>
          }
          createMany: {
            args: Prisma.AccountBalanceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AccountBalanceCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload>[]
          }
          delete: {
            args: Prisma.AccountBalanceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload>
          }
          update: {
            args: Prisma.AccountBalanceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload>
          }
          deleteMany: {
            args: Prisma.AccountBalanceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AccountBalanceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.AccountBalanceUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload>[]
          }
          upsert: {
            args: Prisma.AccountBalanceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AccountBalancePayload>
          }
          aggregate: {
            args: Prisma.AccountBalanceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAccountBalance>
          }
          groupBy: {
            args: Prisma.AccountBalanceGroupByArgs<ExtArgs>
            result: $Utils.Optional<AccountBalanceGroupByOutputType>[]
          }
          count: {
            args: Prisma.AccountBalanceCountArgs<ExtArgs>
            result: $Utils.Optional<AccountBalanceCountAggregateOutputType> | number
          }
        }
      }
      Analytics: {
        payload: Prisma.$AnalyticsPayload<ExtArgs>
        fields: Prisma.AnalyticsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AnalyticsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AnalyticsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload>
          }
          findFirst: {
            args: Prisma.AnalyticsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AnalyticsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload>
          }
          findMany: {
            args: Prisma.AnalyticsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload>[]
          }
          create: {
            args: Prisma.AnalyticsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload>
          }
          createMany: {
            args: Prisma.AnalyticsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AnalyticsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload>[]
          }
          delete: {
            args: Prisma.AnalyticsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload>
          }
          update: {
            args: Prisma.AnalyticsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload>
          }
          deleteMany: {
            args: Prisma.AnalyticsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AnalyticsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.AnalyticsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload>[]
          }
          upsert: {
            args: Prisma.AnalyticsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AnalyticsPayload>
          }
          aggregate: {
            args: Prisma.AnalyticsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAnalytics>
          }
          groupBy: {
            args: Prisma.AnalyticsGroupByArgs<ExtArgs>
            result: $Utils.Optional<AnalyticsGroupByOutputType>[]
          }
          count: {
            args: Prisma.AnalyticsCountArgs<ExtArgs>
            result: $Utils.Optional<AnalyticsCountAggregateOutputType> | number
          }
        }
      }
      ApiKey: {
        payload: Prisma.$ApiKeyPayload<ExtArgs>
        fields: Prisma.ApiKeyFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ApiKeyFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ApiKeyFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          findFirst: {
            args: Prisma.ApiKeyFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ApiKeyFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          findMany: {
            args: Prisma.ApiKeyFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>[]
          }
          create: {
            args: Prisma.ApiKeyCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          createMany: {
            args: Prisma.ApiKeyCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ApiKeyCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>[]
          }
          delete: {
            args: Prisma.ApiKeyDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          update: {
            args: Prisma.ApiKeyUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          deleteMany: {
            args: Prisma.ApiKeyDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ApiKeyUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.ApiKeyUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>[]
          }
          upsert: {
            args: Prisma.ApiKeyUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ApiKeyPayload>
          }
          aggregate: {
            args: Prisma.ApiKeyAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateApiKey>
          }
          groupBy: {
            args: Prisma.ApiKeyGroupByArgs<ExtArgs>
            result: $Utils.Optional<ApiKeyGroupByOutputType>[]
          }
          count: {
            args: Prisma.ApiKeyCountArgs<ExtArgs>
            result: $Utils.Optional<ApiKeyCountAggregateOutputType> | number
          }
        }
      }
      AssetProfileResolution: {
        payload: Prisma.$AssetProfileResolutionPayload<ExtArgs>
        fields: Prisma.AssetProfileResolutionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AssetProfileResolutionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AssetProfileResolutionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload>
          }
          findFirst: {
            args: Prisma.AssetProfileResolutionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AssetProfileResolutionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload>
          }
          findMany: {
            args: Prisma.AssetProfileResolutionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload>[]
          }
          create: {
            args: Prisma.AssetProfileResolutionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload>
          }
          createMany: {
            args: Prisma.AssetProfileResolutionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AssetProfileResolutionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload>[]
          }
          delete: {
            args: Prisma.AssetProfileResolutionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload>
          }
          update: {
            args: Prisma.AssetProfileResolutionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload>
          }
          deleteMany: {
            args: Prisma.AssetProfileResolutionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AssetProfileResolutionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.AssetProfileResolutionUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload>[]
          }
          upsert: {
            args: Prisma.AssetProfileResolutionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AssetProfileResolutionPayload>
          }
          aggregate: {
            args: Prisma.AssetProfileResolutionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAssetProfileResolution>
          }
          groupBy: {
            args: Prisma.AssetProfileResolutionGroupByArgs<ExtArgs>
            result: $Utils.Optional<AssetProfileResolutionGroupByOutputType>[]
          }
          count: {
            args: Prisma.AssetProfileResolutionCountArgs<ExtArgs>
            result: $Utils.Optional<AssetProfileResolutionCountAggregateOutputType> | number
          }
        }
      }
      AuthDevice: {
        payload: Prisma.$AuthDevicePayload<ExtArgs>
        fields: Prisma.AuthDeviceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AuthDeviceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AuthDeviceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload>
          }
          findFirst: {
            args: Prisma.AuthDeviceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AuthDeviceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload>
          }
          findMany: {
            args: Prisma.AuthDeviceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload>[]
          }
          create: {
            args: Prisma.AuthDeviceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload>
          }
          createMany: {
            args: Prisma.AuthDeviceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AuthDeviceCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload>[]
          }
          delete: {
            args: Prisma.AuthDeviceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload>
          }
          update: {
            args: Prisma.AuthDeviceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload>
          }
          deleteMany: {
            args: Prisma.AuthDeviceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AuthDeviceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.AuthDeviceUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload>[]
          }
          upsert: {
            args: Prisma.AuthDeviceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AuthDevicePayload>
          }
          aggregate: {
            args: Prisma.AuthDeviceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAuthDevice>
          }
          groupBy: {
            args: Prisma.AuthDeviceGroupByArgs<ExtArgs>
            result: $Utils.Optional<AuthDeviceGroupByOutputType>[]
          }
          count: {
            args: Prisma.AuthDeviceCountArgs<ExtArgs>
            result: $Utils.Optional<AuthDeviceCountAggregateOutputType> | number
          }
        }
      }
      MarketData: {
        payload: Prisma.$MarketDataPayload<ExtArgs>
        fields: Prisma.MarketDataFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MarketDataFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MarketDataFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload>
          }
          findFirst: {
            args: Prisma.MarketDataFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MarketDataFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload>
          }
          findMany: {
            args: Prisma.MarketDataFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload>[]
          }
          create: {
            args: Prisma.MarketDataCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload>
          }
          createMany: {
            args: Prisma.MarketDataCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.MarketDataCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload>[]
          }
          delete: {
            args: Prisma.MarketDataDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload>
          }
          update: {
            args: Prisma.MarketDataUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload>
          }
          deleteMany: {
            args: Prisma.MarketDataDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MarketDataUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.MarketDataUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload>[]
          }
          upsert: {
            args: Prisma.MarketDataUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MarketDataPayload>
          }
          aggregate: {
            args: Prisma.MarketDataAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMarketData>
          }
          groupBy: {
            args: Prisma.MarketDataGroupByArgs<ExtArgs>
            result: $Utils.Optional<MarketDataGroupByOutputType>[]
          }
          count: {
            args: Prisma.MarketDataCountArgs<ExtArgs>
            result: $Utils.Optional<MarketDataCountAggregateOutputType> | number
          }
        }
      }
      Order: {
        payload: Prisma.$OrderPayload<ExtArgs>
        fields: Prisma.OrderFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OrderFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OrderFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          findFirst: {
            args: Prisma.OrderFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OrderFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          findMany: {
            args: Prisma.OrderFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>[]
          }
          create: {
            args: Prisma.OrderCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          createMany: {
            args: Prisma.OrderCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.OrderCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>[]
          }
          delete: {
            args: Prisma.OrderDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          update: {
            args: Prisma.OrderUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          deleteMany: {
            args: Prisma.OrderDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.OrderUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.OrderUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>[]
          }
          upsert: {
            args: Prisma.OrderUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          aggregate: {
            args: Prisma.OrderAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateOrder>
          }
          groupBy: {
            args: Prisma.OrderGroupByArgs<ExtArgs>
            result: $Utils.Optional<OrderGroupByOutputType>[]
          }
          count: {
            args: Prisma.OrderCountArgs<ExtArgs>
            result: $Utils.Optional<OrderCountAggregateOutputType> | number
          }
        }
      }
      Platform: {
        payload: Prisma.$PlatformPayload<ExtArgs>
        fields: Prisma.PlatformFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PlatformFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PlatformFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload>
          }
          findFirst: {
            args: Prisma.PlatformFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PlatformFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload>
          }
          findMany: {
            args: Prisma.PlatformFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload>[]
          }
          create: {
            args: Prisma.PlatformCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload>
          }
          createMany: {
            args: Prisma.PlatformCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PlatformCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload>[]
          }
          delete: {
            args: Prisma.PlatformDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload>
          }
          update: {
            args: Prisma.PlatformUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload>
          }
          deleteMany: {
            args: Prisma.PlatformDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PlatformUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PlatformUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload>[]
          }
          upsert: {
            args: Prisma.PlatformUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PlatformPayload>
          }
          aggregate: {
            args: Prisma.PlatformAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePlatform>
          }
          groupBy: {
            args: Prisma.PlatformGroupByArgs<ExtArgs>
            result: $Utils.Optional<PlatformGroupByOutputType>[]
          }
          count: {
            args: Prisma.PlatformCountArgs<ExtArgs>
            result: $Utils.Optional<PlatformCountAggregateOutputType> | number
          }
        }
      }
      Property: {
        payload: Prisma.$PropertyPayload<ExtArgs>
        fields: Prisma.PropertyFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PropertyFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PropertyFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload>
          }
          findFirst: {
            args: Prisma.PropertyFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PropertyFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload>
          }
          findMany: {
            args: Prisma.PropertyFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload>[]
          }
          create: {
            args: Prisma.PropertyCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload>
          }
          createMany: {
            args: Prisma.PropertyCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PropertyCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload>[]
          }
          delete: {
            args: Prisma.PropertyDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload>
          }
          update: {
            args: Prisma.PropertyUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload>
          }
          deleteMany: {
            args: Prisma.PropertyDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PropertyUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.PropertyUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload>[]
          }
          upsert: {
            args: Prisma.PropertyUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PropertyPayload>
          }
          aggregate: {
            args: Prisma.PropertyAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProperty>
          }
          groupBy: {
            args: Prisma.PropertyGroupByArgs<ExtArgs>
            result: $Utils.Optional<PropertyGroupByOutputType>[]
          }
          count: {
            args: Prisma.PropertyCountArgs<ExtArgs>
            result: $Utils.Optional<PropertyCountAggregateOutputType> | number
          }
        }
      }
      Settings: {
        payload: Prisma.$SettingsPayload<ExtArgs>
        fields: Prisma.SettingsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SettingsFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SettingsFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload>
          }
          findFirst: {
            args: Prisma.SettingsFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SettingsFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload>
          }
          findMany: {
            args: Prisma.SettingsFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload>[]
          }
          create: {
            args: Prisma.SettingsCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload>
          }
          createMany: {
            args: Prisma.SettingsCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SettingsCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload>[]
          }
          delete: {
            args: Prisma.SettingsDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload>
          }
          update: {
            args: Prisma.SettingsUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload>
          }
          deleteMany: {
            args: Prisma.SettingsDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SettingsUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.SettingsUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload>[]
          }
          upsert: {
            args: Prisma.SettingsUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingsPayload>
          }
          aggregate: {
            args: Prisma.SettingsAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSettings>
          }
          groupBy: {
            args: Prisma.SettingsGroupByArgs<ExtArgs>
            result: $Utils.Optional<SettingsGroupByOutputType>[]
          }
          count: {
            args: Prisma.SettingsCountArgs<ExtArgs>
            result: $Utils.Optional<SettingsCountAggregateOutputType> | number
          }
        }
      }
      SymbolProfile: {
        payload: Prisma.$SymbolProfilePayload<ExtArgs>
        fields: Prisma.SymbolProfileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SymbolProfileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SymbolProfileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload>
          }
          findFirst: {
            args: Prisma.SymbolProfileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SymbolProfileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload>
          }
          findMany: {
            args: Prisma.SymbolProfileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload>[]
          }
          create: {
            args: Prisma.SymbolProfileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload>
          }
          createMany: {
            args: Prisma.SymbolProfileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SymbolProfileCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload>[]
          }
          delete: {
            args: Prisma.SymbolProfileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload>
          }
          update: {
            args: Prisma.SymbolProfileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload>
          }
          deleteMany: {
            args: Prisma.SymbolProfileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SymbolProfileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.SymbolProfileUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload>[]
          }
          upsert: {
            args: Prisma.SymbolProfileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfilePayload>
          }
          aggregate: {
            args: Prisma.SymbolProfileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSymbolProfile>
          }
          groupBy: {
            args: Prisma.SymbolProfileGroupByArgs<ExtArgs>
            result: $Utils.Optional<SymbolProfileGroupByOutputType>[]
          }
          count: {
            args: Prisma.SymbolProfileCountArgs<ExtArgs>
            result: $Utils.Optional<SymbolProfileCountAggregateOutputType> | number
          }
        }
      }
      SymbolProfileOverrides: {
        payload: Prisma.$SymbolProfileOverridesPayload<ExtArgs>
        fields: Prisma.SymbolProfileOverridesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SymbolProfileOverridesFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SymbolProfileOverridesFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload>
          }
          findFirst: {
            args: Prisma.SymbolProfileOverridesFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SymbolProfileOverridesFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload>
          }
          findMany: {
            args: Prisma.SymbolProfileOverridesFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload>[]
          }
          create: {
            args: Prisma.SymbolProfileOverridesCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload>
          }
          createMany: {
            args: Prisma.SymbolProfileOverridesCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SymbolProfileOverridesCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload>[]
          }
          delete: {
            args: Prisma.SymbolProfileOverridesDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload>
          }
          update: {
            args: Prisma.SymbolProfileOverridesUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload>
          }
          deleteMany: {
            args: Prisma.SymbolProfileOverridesDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SymbolProfileOverridesUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.SymbolProfileOverridesUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload>[]
          }
          upsert: {
            args: Prisma.SymbolProfileOverridesUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SymbolProfileOverridesPayload>
          }
          aggregate: {
            args: Prisma.SymbolProfileOverridesAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSymbolProfileOverrides>
          }
          groupBy: {
            args: Prisma.SymbolProfileOverridesGroupByArgs<ExtArgs>
            result: $Utils.Optional<SymbolProfileOverridesGroupByOutputType>[]
          }
          count: {
            args: Prisma.SymbolProfileOverridesCountArgs<ExtArgs>
            result: $Utils.Optional<SymbolProfileOverridesCountAggregateOutputType> | number
          }
        }
      }
      Subscription: {
        payload: Prisma.$SubscriptionPayload<ExtArgs>
        fields: Prisma.SubscriptionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SubscriptionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SubscriptionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          findFirst: {
            args: Prisma.SubscriptionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SubscriptionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          findMany: {
            args: Prisma.SubscriptionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>[]
          }
          create: {
            args: Prisma.SubscriptionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          createMany: {
            args: Prisma.SubscriptionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SubscriptionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>[]
          }
          delete: {
            args: Prisma.SubscriptionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          update: {
            args: Prisma.SubscriptionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          deleteMany: {
            args: Prisma.SubscriptionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SubscriptionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.SubscriptionUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>[]
          }
          upsert: {
            args: Prisma.SubscriptionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SubscriptionPayload>
          }
          aggregate: {
            args: Prisma.SubscriptionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSubscription>
          }
          groupBy: {
            args: Prisma.SubscriptionGroupByArgs<ExtArgs>
            result: $Utils.Optional<SubscriptionGroupByOutputType>[]
          }
          count: {
            args: Prisma.SubscriptionCountArgs<ExtArgs>
            result: $Utils.Optional<SubscriptionCountAggregateOutputType> | number
          }
        }
      }
      Tag: {
        payload: Prisma.$TagPayload<ExtArgs>
        fields: Prisma.TagFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TagFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TagFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          findFirst: {
            args: Prisma.TagFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TagFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          findMany: {
            args: Prisma.TagFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>[]
          }
          create: {
            args: Prisma.TagCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          createMany: {
            args: Prisma.TagCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.TagCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>[]
          }
          delete: {
            args: Prisma.TagDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          update: {
            args: Prisma.TagUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          deleteMany: {
            args: Prisma.TagDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TagUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.TagUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>[]
          }
          upsert: {
            args: Prisma.TagUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TagPayload>
          }
          aggregate: {
            args: Prisma.TagAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTag>
          }
          groupBy: {
            args: Prisma.TagGroupByArgs<ExtArgs>
            result: $Utils.Optional<TagGroupByOutputType>[]
          }
          count: {
            args: Prisma.TagCountArgs<ExtArgs>
            result: $Utils.Optional<TagCountAggregateOutputType> | number
          }
        }
      }
      User: {
        payload: Prisma.$UserPayload<ExtArgs>
        fields: Prisma.UserFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findFirst: {
            args: Prisma.UserFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findMany: {
            args: Prisma.UserFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          create: {
            args: Prisma.UserCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          createMany: {
            args: Prisma.UserCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.UserCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          delete: {
            args: Prisma.UserDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          update: {
            args: Prisma.UserUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          deleteMany: {
            args: Prisma.UserDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateManyAndReturn: {
            args: Prisma.UserUpdateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          upsert: {
            args: Prisma.UserUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          aggregate: {
            args: Prisma.UserAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUser>
          }
          groupBy: {
            args: Prisma.UserGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserCountArgs<ExtArgs>
            result: $Utils.Optional<UserCountAggregateOutputType> | number
          }
        }
      }
    }
  } & {
    other: {
      payload: any
      operations: {
        $executeRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $executeRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
        $queryRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $queryRawUnsafe: {
          args: [query: string, ...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
     * ```
     * // Shorthand for `emit: 'stdout'`
     * log: ['query', 'info', 'warn', 'error']
     * 
     * // Emit as events only
     * log: [
     *   { emit: 'event', level: 'query' },
     *   { emit: 'event', level: 'info' },
     *   { emit: 'event', level: 'warn' }
     *   { emit: 'event', level: 'error' }
     * ]
     * 
     * / Emit as events and log to stdout
     * og: [
     *  { emit: 'stdout', level: 'query' },
     *  { emit: 'stdout', level: 'info' },
     *  { emit: 'stdout', level: 'warn' }
     *  { emit: 'stdout', level: 'error' }
     * 
     * ```
     * Read more in our [docs](https://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
    }
    /**
     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`
     */
    adapter?: runtime.SqlDriverAdapterFactory | null
    /**
     * Global configuration for omitting model fields by default.
     * 
     * @example
     * ```
     * const prisma = new PrismaClient({
     *   omit: {
     *     user: {
     *       password: true
     *     }
     *   }
     * })
     * ```
     */
    omit?: Prisma.GlobalOmitConfig
  }
  export type GlobalOmitConfig = {
    access?: AccessOmit
    account?: AccountOmit
    accountBalance?: AccountBalanceOmit
    analytics?: AnalyticsOmit
    apiKey?: ApiKeyOmit
    assetProfileResolution?: AssetProfileResolutionOmit
    authDevice?: AuthDeviceOmit
    marketData?: MarketDataOmit
    order?: OrderOmit
    platform?: PlatformOmit
    property?: PropertyOmit
    settings?: SettingsOmit
    symbolProfile?: SymbolProfileOmit
    symbolProfileOverrides?: SymbolProfileOverridesOmit
    subscription?: SubscriptionOmit
    tag?: TagOmit
    user?: UserOmit
  }

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

  export type CheckIsLogLevel<T> = T extends LogLevel ? T : never;

  export type GetLogType<T> = CheckIsLogLevel<
    T extends LogDefinition ? T['level'] : T
  >;

  export type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition>
    ? GetLogType<T[number]>
    : never;

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

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


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

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


  /**
   * Count Type AccountCountOutputType
   */

  export type AccountCountOutputType = {
    activities: number
    balances: number
  }

  export type AccountCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    activities?: boolean | AccountCountOutputTypeCountActivitiesArgs
    balances?: boolean | AccountCountOutputTypeCountBalancesArgs
  }

  // Custom InputTypes
  /**
   * AccountCountOutputType without action
   */
  export type AccountCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountCountOutputType
     */
    select?: AccountCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * AccountCountOutputType without action
   */
  export type AccountCountOutputTypeCountActivitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderWhereInput
  }

  /**
   * AccountCountOutputType without action
   */
  export type AccountCountOutputTypeCountBalancesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccountBalanceWhereInput
  }


  /**
   * Count Type OrderCountOutputType
   */

  export type OrderCountOutputType = {
    tags: number
  }

  export type OrderCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    tags?: boolean | OrderCountOutputTypeCountTagsArgs
  }

  // Custom InputTypes
  /**
   * OrderCountOutputType without action
   */
  export type OrderCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderCountOutputType
     */
    select?: OrderCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * OrderCountOutputType without action
   */
  export type OrderCountOutputTypeCountTagsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TagWhereInput
  }


  /**
   * Count Type PlatformCountOutputType
   */

  export type PlatformCountOutputType = {
    accounts: number
  }

  export type PlatformCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    accounts?: boolean | PlatformCountOutputTypeCountAccountsArgs
  }

  // Custom InputTypes
  /**
   * PlatformCountOutputType without action
   */
  export type PlatformCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PlatformCountOutputType
     */
    select?: PlatformCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * PlatformCountOutputType without action
   */
  export type PlatformCountOutputTypeCountAccountsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccountWhereInput
  }


  /**
   * Count Type SymbolProfileCountOutputType
   */

  export type SymbolProfileCountOutputType = {
    activities: number
    watchedBy: number
  }

  export type SymbolProfileCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    activities?: boolean | SymbolProfileCountOutputTypeCountActivitiesArgs
    watchedBy?: boolean | SymbolProfileCountOutputTypeCountWatchedByArgs
  }

  // Custom InputTypes
  /**
   * SymbolProfileCountOutputType without action
   */
  export type SymbolProfileCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileCountOutputType
     */
    select?: SymbolProfileCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * SymbolProfileCountOutputType without action
   */
  export type SymbolProfileCountOutputTypeCountActivitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderWhereInput
  }

  /**
   * SymbolProfileCountOutputType without action
   */
  export type SymbolProfileCountOutputTypeCountWatchedByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserWhereInput
  }


  /**
   * Count Type TagCountOutputType
   */

  export type TagCountOutputType = {
    activities: number
  }

  export type TagCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    activities?: boolean | TagCountOutputTypeCountActivitiesArgs
  }

  // Custom InputTypes
  /**
   * TagCountOutputType without action
   */
  export type TagCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TagCountOutputType
     */
    select?: TagCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * TagCountOutputType without action
   */
  export type TagCountOutputTypeCountActivitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderWhereInput
  }


  /**
   * Count Type UserCountOutputType
   */

  export type UserCountOutputType = {
    accessesGet: number
    accessesGive: number
    accounts: number
    activities: number
    apiKeys: number
    authDevices: number
    subscriptions: number
    tags: number
    watchlist: number
    SymbolProfile: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    accessesGet?: boolean | UserCountOutputTypeCountAccessesGetArgs
    accessesGive?: boolean | UserCountOutputTypeCountAccessesGiveArgs
    accounts?: boolean | UserCountOutputTypeCountAccountsArgs
    activities?: boolean | UserCountOutputTypeCountActivitiesArgs
    apiKeys?: boolean | UserCountOutputTypeCountApiKeysArgs
    authDevices?: boolean | UserCountOutputTypeCountAuthDevicesArgs
    subscriptions?: boolean | UserCountOutputTypeCountSubscriptionsArgs
    tags?: boolean | UserCountOutputTypeCountTagsArgs
    watchlist?: boolean | UserCountOutputTypeCountWatchlistArgs
    SymbolProfile?: boolean | UserCountOutputTypeCountSymbolProfileArgs
  }

  // Custom InputTypes
  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserCountOutputType
     */
    select?: UserCountOutputTypeSelect<ExtArgs> | null
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountAccessesGetArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccessWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountAccessesGiveArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccessWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountAccountsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccountWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountActivitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountApiKeysArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ApiKeyWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountAuthDevicesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AuthDeviceWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountSubscriptionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SubscriptionWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountTagsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TagWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountWatchlistArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SymbolProfileWhereInput
  }

  /**
   * UserCountOutputType without action
   */
  export type UserCountOutputTypeCountSymbolProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SymbolProfileWhereInput
  }


  /**
   * Models
   */

  /**
   * Model Access
   */

  export type AggregateAccess = {
    _count: AccessCountAggregateOutputType | null
    _min: AccessMinAggregateOutputType | null
    _max: AccessMaxAggregateOutputType | null
  }

  export type AccessMinAggregateOutputType = {
    alias: string | null
    createdAt: Date | null
    granteeUserId: string | null
    id: string | null
    updatedAt: Date | null
    userId: string | null
  }

  export type AccessMaxAggregateOutputType = {
    alias: string | null
    createdAt: Date | null
    granteeUserId: string | null
    id: string | null
    updatedAt: Date | null
    userId: string | null
  }

  export type AccessCountAggregateOutputType = {
    alias: number
    createdAt: number
    granteeUserId: number
    id: number
    permissions: number
    settings: number
    updatedAt: number
    userId: number
    _all: number
  }


  export type AccessMinAggregateInputType = {
    alias?: true
    createdAt?: true
    granteeUserId?: true
    id?: true
    updatedAt?: true
    userId?: true
  }

  export type AccessMaxAggregateInputType = {
    alias?: true
    createdAt?: true
    granteeUserId?: true
    id?: true
    updatedAt?: true
    userId?: true
  }

  export type AccessCountAggregateInputType = {
    alias?: true
    createdAt?: true
    granteeUserId?: true
    id?: true
    permissions?: true
    settings?: true
    updatedAt?: true
    userId?: true
    _all?: true
  }

  export type AccessAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Access to aggregate.
     */
    where?: AccessWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accesses to fetch.
     */
    orderBy?: AccessOrderByWithRelationInput | AccessOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AccessWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accesses 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` Accesses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Accesses
    **/
    _count?: true | AccessCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AccessMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AccessMaxAggregateInputType
  }

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




  export type AccessGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccessWhereInput
    orderBy?: AccessOrderByWithAggregationInput | AccessOrderByWithAggregationInput[]
    by: AccessScalarFieldEnum[] | AccessScalarFieldEnum
    having?: AccessScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AccessCountAggregateInputType | true
    _min?: AccessMinAggregateInputType
    _max?: AccessMaxAggregateInputType
  }

  export type AccessGroupByOutputType = {
    alias: string | null
    createdAt: Date
    granteeUserId: string | null
    id: string
    permissions: $Enums.AccessPermission[]
    settings: JsonValue
    updatedAt: Date
    userId: string
    _count: AccessCountAggregateOutputType | null
    _min: AccessMinAggregateOutputType | null
    _max: AccessMaxAggregateOutputType | null
  }

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


  export type AccessSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    alias?: boolean
    createdAt?: boolean
    granteeUserId?: boolean
    id?: boolean
    permissions?: boolean
    settings?: boolean
    updatedAt?: boolean
    userId?: boolean
    granteeUser?: boolean | Access$granteeUserArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["access"]>

  export type AccessSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    alias?: boolean
    createdAt?: boolean
    granteeUserId?: boolean
    id?: boolean
    permissions?: boolean
    settings?: boolean
    updatedAt?: boolean
    userId?: boolean
    granteeUser?: boolean | Access$granteeUserArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["access"]>

  export type AccessSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    alias?: boolean
    createdAt?: boolean
    granteeUserId?: boolean
    id?: boolean
    permissions?: boolean
    settings?: boolean
    updatedAt?: boolean
    userId?: boolean
    granteeUser?: boolean | Access$granteeUserArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["access"]>

  export type AccessSelectScalar = {
    alias?: boolean
    createdAt?: boolean
    granteeUserId?: boolean
    id?: boolean
    permissions?: boolean
    settings?: boolean
    updatedAt?: boolean
    userId?: boolean
  }

  export type AccessOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"alias" | "createdAt" | "granteeUserId" | "id" | "permissions" | "settings" | "updatedAt" | "userId", ExtArgs["result"]["access"]>
  export type AccessInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    granteeUser?: boolean | Access$granteeUserArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AccessIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    granteeUser?: boolean | Access$granteeUserArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AccessIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    granteeUser?: boolean | Access$granteeUserArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $AccessPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Access"
    objects: {
      granteeUser: Prisma.$UserPayload<ExtArgs> | null
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      alias: string | null
      createdAt: Date
      granteeUserId: string | null
      id: string
      permissions: $Enums.AccessPermission[]
      settings: Prisma.JsonValue
      updatedAt: Date
      userId: string
    }, ExtArgs["result"]["access"]>
    composites: {}
  }

  type AccessGetPayload<S extends boolean | null | undefined | AccessDefaultArgs> = $Result.GetResult<Prisma.$AccessPayload, S>

  type AccessCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<AccessFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: AccessCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Access 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 {AccessFindFirstArgs} args - Arguments to find a Access
     * @example
     * // Get one Access
     * const access = await prisma.access.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AccessFindFirstArgs>(args?: SelectSubset<T, AccessFindFirstArgs<ExtArgs>>): Prisma__AccessClient<$Result.GetResult<Prisma.$AccessPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Access 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 {AccessFindFirstOrThrowArgs} args - Arguments to find a Access
     * @example
     * // Get one Access
     * const access = await prisma.access.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AccessFindFirstOrThrowArgs>(args?: SelectSubset<T, AccessFindFirstOrThrowArgs<ExtArgs>>): Prisma__AccessClient<$Result.GetResult<Prisma.$AccessPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Accesses 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 {AccessFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Accesses
     * const accesses = await prisma.access.findMany()
     * 
     * // Get first 10 Accesses
     * const accesses = await prisma.access.findMany({ take: 10 })
     * 
     * // Only select the `alias`
     * const accessWithAliasOnly = await prisma.access.findMany({ select: { alias: true } })
     * 
     */
    findMany<T extends AccessFindManyArgs>(args?: SelectSubset<T, AccessFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccessPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Access.
     * @param {AccessCreateArgs} args - Arguments to create a Access.
     * @example
     * // Create one Access
     * const Access = await prisma.access.create({
     *   data: {
     *     // ... data to create a Access
     *   }
     * })
     * 
     */
    create<T extends AccessCreateArgs>(args: SelectSubset<T, AccessCreateArgs<ExtArgs>>): Prisma__AccessClient<$Result.GetResult<Prisma.$AccessPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Accesses and returns the data saved in the database.
     * @param {AccessCreateManyAndReturnArgs} args - Arguments to create many Accesses.
     * @example
     * // Create many Accesses
     * const access = await prisma.access.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Accesses and only return the `alias`
     * const accessWithAliasOnly = await prisma.access.createManyAndReturn({
     *   select: { alias: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends AccessCreateManyAndReturnArgs>(args?: SelectSubset<T, AccessCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccessPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Access.
     * @param {AccessDeleteArgs} args - Arguments to delete one Access.
     * @example
     * // Delete one Access
     * const Access = await prisma.access.delete({
     *   where: {
     *     // ... filter to delete one Access
     *   }
     * })
     * 
     */
    delete<T extends AccessDeleteArgs>(args: SelectSubset<T, AccessDeleteArgs<ExtArgs>>): Prisma__AccessClient<$Result.GetResult<Prisma.$AccessPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Access.
     * @param {AccessUpdateArgs} args - Arguments to update one Access.
     * @example
     * // Update one Access
     * const access = await prisma.access.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AccessUpdateArgs>(args: SelectSubset<T, AccessUpdateArgs<ExtArgs>>): Prisma__AccessClient<$Result.GetResult<Prisma.$AccessPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more Accesses and returns the data updated in the database.
     * @param {AccessUpdateManyAndReturnArgs} args - Arguments to update many Accesses.
     * @example
     * // Update many Accesses
     * const access = await prisma.access.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Accesses and only return the `alias`
     * const accessWithAliasOnly = await prisma.access.updateManyAndReturn({
     *   select: { alias: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends AccessUpdateManyAndReturnArgs>(args: SelectSubset<T, AccessUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccessPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a Access.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccessAggregateArgs} 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 AccessAggregateArgs>(args: Subset<T, AccessAggregateArgs>): Prisma.PrismaPromise<GetAccessAggregateType<T>>

    /**
     * Group by Access.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccessGroupByArgs} 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 AccessGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AccessGroupByArgs['orderBy'] }
        : { orderBy?: AccessGroupByArgs['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, AccessGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAccessGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Access model
   */
  readonly fields: AccessFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Access.
   * 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__AccessClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    granteeUser<T extends Access$granteeUserArgs<ExtArgs> = {}>(args?: Subset<T, Access$granteeUserArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 Access model
   */
  interface AccessFieldRefs {
    readonly alias: FieldRef<"Access", 'String'>
    readonly createdAt: FieldRef<"Access", 'DateTime'>
    readonly granteeUserId: FieldRef<"Access", 'String'>
    readonly id: FieldRef<"Access", 'String'>
    readonly permissions: FieldRef<"Access", 'AccessPermission[]'>
    readonly settings: FieldRef<"Access", 'Json'>
    readonly updatedAt: FieldRef<"Access", 'DateTime'>
    readonly userId: FieldRef<"Access", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Access findUnique
   */
  export type AccessFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    /**
     * Filter, which Access to fetch.
     */
    where: AccessWhereUniqueInput
  }

  /**
   * Access findUniqueOrThrow
   */
  export type AccessFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    /**
     * Filter, which Access to fetch.
     */
    where: AccessWhereUniqueInput
  }

  /**
   * Access findFirst
   */
  export type AccessFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    /**
     * Filter, which Access to fetch.
     */
    where?: AccessWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accesses to fetch.
     */
    orderBy?: AccessOrderByWithRelationInput | AccessOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Accesses.
     */
    cursor?: AccessWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accesses 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` Accesses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Accesses.
     */
    distinct?: AccessScalarFieldEnum | AccessScalarFieldEnum[]
  }

  /**
   * Access findFirstOrThrow
   */
  export type AccessFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    /**
     * Filter, which Access to fetch.
     */
    where?: AccessWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accesses to fetch.
     */
    orderBy?: AccessOrderByWithRelationInput | AccessOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Accesses.
     */
    cursor?: AccessWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accesses 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` Accesses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Accesses.
     */
    distinct?: AccessScalarFieldEnum | AccessScalarFieldEnum[]
  }

  /**
   * Access findMany
   */
  export type AccessFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    /**
     * Filter, which Accesses to fetch.
     */
    where?: AccessWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accesses to fetch.
     */
    orderBy?: AccessOrderByWithRelationInput | AccessOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Accesses.
     */
    cursor?: AccessWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accesses 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` Accesses.
     */
    skip?: number
    distinct?: AccessScalarFieldEnum | AccessScalarFieldEnum[]
  }

  /**
   * Access create
   */
  export type AccessCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    /**
     * The data needed to create a Access.
     */
    data: XOR<AccessCreateInput, AccessUncheckedCreateInput>
  }

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

  /**
   * Access createManyAndReturn
   */
  export type AccessCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * The data used to create many Accesses.
     */
    data: AccessCreateManyInput | AccessCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Access update
   */
  export type AccessUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    /**
     * The data needed to update a Access.
     */
    data: XOR<AccessUpdateInput, AccessUncheckedUpdateInput>
    /**
     * Choose, which Access to update.
     */
    where: AccessWhereUniqueInput
  }

  /**
   * Access updateMany
   */
  export type AccessUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Accesses.
     */
    data: XOR<AccessUpdateManyMutationInput, AccessUncheckedUpdateManyInput>
    /**
     * Filter which Accesses to update
     */
    where?: AccessWhereInput
    /**
     * Limit how many Accesses to update.
     */
    limit?: number
  }

  /**
   * Access updateManyAndReturn
   */
  export type AccessUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * The data used to update Accesses.
     */
    data: XOR<AccessUpdateManyMutationInput, AccessUncheckedUpdateManyInput>
    /**
     * Filter which Accesses to update
     */
    where?: AccessWhereInput
    /**
     * Limit how many Accesses to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Access upsert
   */
  export type AccessUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    /**
     * The filter to search for the Access to update in case it exists.
     */
    where: AccessWhereUniqueInput
    /**
     * In case the Access found by the `where` argument doesn't exist, create a new Access with this data.
     */
    create: XOR<AccessCreateInput, AccessUncheckedCreateInput>
    /**
     * In case the Access was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AccessUpdateInput, AccessUncheckedUpdateInput>
  }

  /**
   * Access delete
   */
  export type AccessDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    /**
     * Filter which Access to delete.
     */
    where: AccessWhereUniqueInput
  }

  /**
   * Access deleteMany
   */
  export type AccessDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Accesses to delete
     */
    where?: AccessWhereInput
    /**
     * Limit how many Accesses to delete.
     */
    limit?: number
  }

  /**
   * Access.granteeUser
   */
  export type Access$granteeUserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
  }

  /**
   * Access without action
   */
  export type AccessDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
  }


  /**
   * Model Account
   */

  export type AggregateAccount = {
    _count: AccountCountAggregateOutputType | null
    _avg: AccountAvgAggregateOutputType | null
    _sum: AccountSumAggregateOutputType | null
    _min: AccountMinAggregateOutputType | null
    _max: AccountMaxAggregateOutputType | null
  }

  export type AccountAvgAggregateOutputType = {
    balance: number | null
  }

  export type AccountSumAggregateOutputType = {
    balance: number | null
  }

  export type AccountMinAggregateOutputType = {
    balance: number | null
    comment: string | null
    createdAt: Date | null
    currency: string | null
    id: string | null
    isExcluded: boolean | null
    name: string | null
    platformId: string | null
    updatedAt: Date | null
    userId: string | null
  }

  export type AccountMaxAggregateOutputType = {
    balance: number | null
    comment: string | null
    createdAt: Date | null
    currency: string | null
    id: string | null
    isExcluded: boolean | null
    name: string | null
    platformId: string | null
    updatedAt: Date | null
    userId: string | null
  }

  export type AccountCountAggregateOutputType = {
    balance: number
    comment: number
    createdAt: number
    currency: number
    id: number
    isExcluded: number
    name: number
    platformId: number
    updatedAt: number
    userId: number
    _all: number
  }


  export type AccountAvgAggregateInputType = {
    balance?: true
  }

  export type AccountSumAggregateInputType = {
    balance?: true
  }

  export type AccountMinAggregateInputType = {
    balance?: true
    comment?: true
    createdAt?: true
    currency?: true
    id?: true
    isExcluded?: true
    name?: true
    platformId?: true
    updatedAt?: true
    userId?: true
  }

  export type AccountMaxAggregateInputType = {
    balance?: true
    comment?: true
    createdAt?: true
    currency?: true
    id?: true
    isExcluded?: true
    name?: true
    platformId?: true
    updatedAt?: true
    userId?: true
  }

  export type AccountCountAggregateInputType = {
    balance?: true
    comment?: true
    createdAt?: true
    currency?: true
    id?: true
    isExcluded?: true
    name?: true
    platformId?: true
    updatedAt?: true
    userId?: true
    _all?: true
  }

  export type AccountAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Account to aggregate.
     */
    where?: AccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accounts to fetch.
     */
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accounts 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` Accounts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Accounts
    **/
    _count?: true | AccountCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AccountAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AccountSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AccountMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AccountMaxAggregateInputType
  }

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




  export type AccountGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccountWhereInput
    orderBy?: AccountOrderByWithAggregationInput | AccountOrderByWithAggregationInput[]
    by: AccountScalarFieldEnum[] | AccountScalarFieldEnum
    having?: AccountScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AccountCountAggregateInputType | true
    _avg?: AccountAvgAggregateInputType
    _sum?: AccountSumAggregateInputType
    _min?: AccountMinAggregateInputType
    _max?: AccountMaxAggregateInputType
  }

  export type AccountGroupByOutputType = {
    balance: number
    comment: string | null
    createdAt: Date
    currency: string | null
    id: string
    isExcluded: boolean
    name: string | null
    platformId: string | null
    updatedAt: Date
    userId: string
    _count: AccountCountAggregateOutputType | null
    _avg: AccountAvgAggregateOutputType | null
    _sum: AccountSumAggregateOutputType | null
    _min: AccountMinAggregateOutputType | null
    _max: AccountMaxAggregateOutputType | null
  }

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


  export type AccountSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    balance?: boolean
    comment?: boolean
    createdAt?: boolean
    currency?: boolean
    id?: boolean
    isExcluded?: boolean
    name?: boolean
    platformId?: boolean
    updatedAt?: boolean
    userId?: boolean
    activities?: boolean | Account$activitiesArgs<ExtArgs>
    balances?: boolean | Account$balancesArgs<ExtArgs>
    platform?: boolean | Account$platformArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    _count?: boolean | AccountCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["account"]>

  export type AccountSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    balance?: boolean
    comment?: boolean
    createdAt?: boolean
    currency?: boolean
    id?: boolean
    isExcluded?: boolean
    name?: boolean
    platformId?: boolean
    updatedAt?: boolean
    userId?: boolean
    platform?: boolean | Account$platformArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["account"]>

  export type AccountSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    balance?: boolean
    comment?: boolean
    createdAt?: boolean
    currency?: boolean
    id?: boolean
    isExcluded?: boolean
    name?: boolean
    platformId?: boolean
    updatedAt?: boolean
    userId?: boolean
    platform?: boolean | Account$platformArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["account"]>

  export type AccountSelectScalar = {
    balance?: boolean
    comment?: boolean
    createdAt?: boolean
    currency?: boolean
    id?: boolean
    isExcluded?: boolean
    name?: boolean
    platformId?: boolean
    updatedAt?: boolean
    userId?: boolean
  }

  export type AccountOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"balance" | "comment" | "createdAt" | "currency" | "id" | "isExcluded" | "name" | "platformId" | "updatedAt" | "userId", ExtArgs["result"]["account"]>
  export type AccountInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    activities?: boolean | Account$activitiesArgs<ExtArgs>
    balances?: boolean | Account$balancesArgs<ExtArgs>
    platform?: boolean | Account$platformArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    _count?: boolean | AccountCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type AccountIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    platform?: boolean | Account$platformArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AccountIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    platform?: boolean | Account$platformArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $AccountPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Account"
    objects: {
      activities: Prisma.$OrderPayload<ExtArgs>[]
      balances: Prisma.$AccountBalancePayload<ExtArgs>[]
      platform: Prisma.$PlatformPayload<ExtArgs> | null
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      balance: number
      comment: string | null
      createdAt: Date
      currency: string | null
      id: string
      isExcluded: boolean
      name: string | null
      platformId: string | null
      updatedAt: Date
      userId: string
    }, ExtArgs["result"]["account"]>
    composites: {}
  }

  type AccountGetPayload<S extends boolean | null | undefined | AccountDefaultArgs> = $Result.GetResult<Prisma.$AccountPayload, S>

  type AccountCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<AccountFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: AccountCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Account 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 {AccountFindFirstArgs} args - Arguments to find a Account
     * @example
     * // Get one Account
     * const account = await prisma.account.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AccountFindFirstArgs>(args?: SelectSubset<T, AccountFindFirstArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Account 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 {AccountFindFirstOrThrowArgs} args - Arguments to find a Account
     * @example
     * // Get one Account
     * const account = await prisma.account.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AccountFindFirstOrThrowArgs>(args?: SelectSubset<T, AccountFindFirstOrThrowArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Accounts 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 {AccountFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Accounts
     * const accounts = await prisma.account.findMany()
     * 
     * // Get first 10 Accounts
     * const accounts = await prisma.account.findMany({ take: 10 })
     * 
     * // Only select the `balance`
     * const accountWithBalanceOnly = await prisma.account.findMany({ select: { balance: true } })
     * 
     */
    findMany<T extends AccountFindManyArgs>(args?: SelectSubset<T, AccountFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Account.
     * @param {AccountCreateArgs} args - Arguments to create a Account.
     * @example
     * // Create one Account
     * const Account = await prisma.account.create({
     *   data: {
     *     // ... data to create a Account
     *   }
     * })
     * 
     */
    create<T extends AccountCreateArgs>(args: SelectSubset<T, AccountCreateArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Accounts and returns the data saved in the database.
     * @param {AccountCreateManyAndReturnArgs} args - Arguments to create many Accounts.
     * @example
     * // Create many Accounts
     * const account = await prisma.account.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Accounts and only return the `balance`
     * const accountWithBalanceOnly = await prisma.account.createManyAndReturn({
     *   select: { balance: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends AccountCreateManyAndReturnArgs>(args?: SelectSubset<T, AccountCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Account.
     * @param {AccountDeleteArgs} args - Arguments to delete one Account.
     * @example
     * // Delete one Account
     * const Account = await prisma.account.delete({
     *   where: {
     *     // ... filter to delete one Account
     *   }
     * })
     * 
     */
    delete<T extends AccountDeleteArgs>(args: SelectSubset<T, AccountDeleteArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Account.
     * @param {AccountUpdateArgs} args - Arguments to update one Account.
     * @example
     * // Update one Account
     * const account = await prisma.account.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AccountUpdateArgs>(args: SelectSubset<T, AccountUpdateArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more Accounts and returns the data updated in the database.
     * @param {AccountUpdateManyAndReturnArgs} args - Arguments to update many Accounts.
     * @example
     * // Update many Accounts
     * const account = await prisma.account.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Accounts and only return the `balance`
     * const accountWithBalanceOnly = await prisma.account.updateManyAndReturn({
     *   select: { balance: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends AccountUpdateManyAndReturnArgs>(args: SelectSubset<T, AccountUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a Account.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountAggregateArgs} 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 AccountAggregateArgs>(args: Subset<T, AccountAggregateArgs>): Prisma.PrismaPromise<GetAccountAggregateType<T>>

    /**
     * Group by Account.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountGroupByArgs} 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 AccountGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AccountGroupByArgs['orderBy'] }
        : { orderBy?: AccountGroupByArgs['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, AccountGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAccountGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Account model
   */
  readonly fields: AccountFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Account.
   * 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__AccountClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    activities<T extends Account$activitiesArgs<ExtArgs> = {}>(args?: Subset<T, Account$activitiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    balances<T extends Account$balancesArgs<ExtArgs> = {}>(args?: Subset<T, Account$balancesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountBalancePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    platform<T extends Account$platformArgs<ExtArgs> = {}>(args?: Subset<T, Account$platformArgs<ExtArgs>>): Prisma__PlatformClient<$Result.GetResult<Prisma.$PlatformPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 Account model
   */
  interface AccountFieldRefs {
    readonly balance: FieldRef<"Account", 'Float'>
    readonly comment: FieldRef<"Account", 'String'>
    readonly createdAt: FieldRef<"Account", 'DateTime'>
    readonly currency: FieldRef<"Account", 'String'>
    readonly id: FieldRef<"Account", 'String'>
    readonly isExcluded: FieldRef<"Account", 'Boolean'>
    readonly name: FieldRef<"Account", 'String'>
    readonly platformId: FieldRef<"Account", 'String'>
    readonly updatedAt: FieldRef<"Account", 'DateTime'>
    readonly userId: FieldRef<"Account", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Account findUnique
   */
  export type AccountFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Account to fetch.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account findUniqueOrThrow
   */
  export type AccountFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Account to fetch.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account findFirst
   */
  export type AccountFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Account to fetch.
     */
    where?: AccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accounts to fetch.
     */
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Accounts.
     */
    cursor?: AccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accounts 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` Accounts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Accounts.
     */
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

  /**
   * Account findFirstOrThrow
   */
  export type AccountFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Account to fetch.
     */
    where?: AccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accounts to fetch.
     */
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Accounts.
     */
    cursor?: AccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accounts 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` Accounts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Accounts.
     */
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

  /**
   * Account findMany
   */
  export type AccountFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter, which Accounts to fetch.
     */
    where?: AccountWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Accounts to fetch.
     */
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Accounts.
     */
    cursor?: AccountWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Accounts 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` Accounts.
     */
    skip?: number
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

  /**
   * Account create
   */
  export type AccountCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * The data needed to create a Account.
     */
    data: XOR<AccountCreateInput, AccountUncheckedCreateInput>
  }

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

  /**
   * Account createManyAndReturn
   */
  export type AccountCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * The data used to create many Accounts.
     */
    data: AccountCreateManyInput | AccountCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Account update
   */
  export type AccountUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * The data needed to update a Account.
     */
    data: XOR<AccountUpdateInput, AccountUncheckedUpdateInput>
    /**
     * Choose, which Account to update.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account updateMany
   */
  export type AccountUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Accounts.
     */
    data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyInput>
    /**
     * Filter which Accounts to update
     */
    where?: AccountWhereInput
    /**
     * Limit how many Accounts to update.
     */
    limit?: number
  }

  /**
   * Account updateManyAndReturn
   */
  export type AccountUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * The data used to update Accounts.
     */
    data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyInput>
    /**
     * Filter which Accounts to update
     */
    where?: AccountWhereInput
    /**
     * Limit how many Accounts to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Account upsert
   */
  export type AccountUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * The filter to search for the Account to update in case it exists.
     */
    where: AccountWhereUniqueInput
    /**
     * In case the Account found by the `where` argument doesn't exist, create a new Account with this data.
     */
    create: XOR<AccountCreateInput, AccountUncheckedCreateInput>
    /**
     * In case the Account was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AccountUpdateInput, AccountUncheckedUpdateInput>
  }

  /**
   * Account delete
   */
  export type AccountDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    /**
     * Filter which Account to delete.
     */
    where: AccountWhereUniqueInput
  }

  /**
   * Account deleteMany
   */
  export type AccountDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Accounts to delete
     */
    where?: AccountWhereInput
    /**
     * Limit how many Accounts to delete.
     */
    limit?: number
  }

  /**
   * Account.activities
   */
  export type Account$activitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    where?: OrderWhereInput
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    cursor?: OrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OrderScalarFieldEnum | OrderScalarFieldEnum[]
  }

  /**
   * Account.balances
   */
  export type Account$balancesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
    where?: AccountBalanceWhereInput
    orderBy?: AccountBalanceOrderByWithRelationInput | AccountBalanceOrderByWithRelationInput[]
    cursor?: AccountBalanceWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AccountBalanceScalarFieldEnum | AccountBalanceScalarFieldEnum[]
  }

  /**
   * Account.platform
   */
  export type Account$platformArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
    where?: PlatformWhereInput
  }

  /**
   * Account without action
   */
  export type AccountDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
  }


  /**
   * Model AccountBalance
   */

  export type AggregateAccountBalance = {
    _count: AccountBalanceCountAggregateOutputType | null
    _avg: AccountBalanceAvgAggregateOutputType | null
    _sum: AccountBalanceSumAggregateOutputType | null
    _min: AccountBalanceMinAggregateOutputType | null
    _max: AccountBalanceMaxAggregateOutputType | null
  }

  export type AccountBalanceAvgAggregateOutputType = {
    value: number | null
  }

  export type AccountBalanceSumAggregateOutputType = {
    value: number | null
  }

  export type AccountBalanceMinAggregateOutputType = {
    accountId: string | null
    createdAt: Date | null
    date: Date | null
    id: string | null
    updatedAt: Date | null
    userId: string | null
    value: number | null
  }

  export type AccountBalanceMaxAggregateOutputType = {
    accountId: string | null
    createdAt: Date | null
    date: Date | null
    id: string | null
    updatedAt: Date | null
    userId: string | null
    value: number | null
  }

  export type AccountBalanceCountAggregateOutputType = {
    accountId: number
    createdAt: number
    date: number
    id: number
    updatedAt: number
    userId: number
    value: number
    _all: number
  }


  export type AccountBalanceAvgAggregateInputType = {
    value?: true
  }

  export type AccountBalanceSumAggregateInputType = {
    value?: true
  }

  export type AccountBalanceMinAggregateInputType = {
    accountId?: true
    createdAt?: true
    date?: true
    id?: true
    updatedAt?: true
    userId?: true
    value?: true
  }

  export type AccountBalanceMaxAggregateInputType = {
    accountId?: true
    createdAt?: true
    date?: true
    id?: true
    updatedAt?: true
    userId?: true
    value?: true
  }

  export type AccountBalanceCountAggregateInputType = {
    accountId?: true
    createdAt?: true
    date?: true
    id?: true
    updatedAt?: true
    userId?: true
    value?: true
    _all?: true
  }

  export type AccountBalanceAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AccountBalance to aggregate.
     */
    where?: AccountBalanceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AccountBalances to fetch.
     */
    orderBy?: AccountBalanceOrderByWithRelationInput | AccountBalanceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AccountBalanceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AccountBalances 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` AccountBalances.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned AccountBalances
    **/
    _count?: true | AccountBalanceCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AccountBalanceAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AccountBalanceSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AccountBalanceMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AccountBalanceMaxAggregateInputType
  }

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




  export type AccountBalanceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AccountBalanceWhereInput
    orderBy?: AccountBalanceOrderByWithAggregationInput | AccountBalanceOrderByWithAggregationInput[]
    by: AccountBalanceScalarFieldEnum[] | AccountBalanceScalarFieldEnum
    having?: AccountBalanceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AccountBalanceCountAggregateInputType | true
    _avg?: AccountBalanceAvgAggregateInputType
    _sum?: AccountBalanceSumAggregateInputType
    _min?: AccountBalanceMinAggregateInputType
    _max?: AccountBalanceMaxAggregateInputType
  }

  export type AccountBalanceGroupByOutputType = {
    accountId: string
    createdAt: Date
    date: Date
    id: string
    updatedAt: Date
    userId: string
    value: number
    _count: AccountBalanceCountAggregateOutputType | null
    _avg: AccountBalanceAvgAggregateOutputType | null
    _sum: AccountBalanceSumAggregateOutputType | null
    _min: AccountBalanceMinAggregateOutputType | null
    _max: AccountBalanceMaxAggregateOutputType | null
  }

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


  export type AccountBalanceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    accountId?: boolean
    createdAt?: boolean
    date?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
    value?: boolean
    account?: boolean | AccountDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["accountBalance"]>

  export type AccountBalanceSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    accountId?: boolean
    createdAt?: boolean
    date?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
    value?: boolean
    account?: boolean | AccountDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["accountBalance"]>

  export type AccountBalanceSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    accountId?: boolean
    createdAt?: boolean
    date?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
    value?: boolean
    account?: boolean | AccountDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["accountBalance"]>

  export type AccountBalanceSelectScalar = {
    accountId?: boolean
    createdAt?: boolean
    date?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
    value?: boolean
  }

  export type AccountBalanceOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"accountId" | "createdAt" | "date" | "id" | "updatedAt" | "userId" | "value", ExtArgs["result"]["accountBalance"]>
  export type AccountBalanceInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    account?: boolean | AccountDefaultArgs<ExtArgs>
  }
  export type AccountBalanceIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    account?: boolean | AccountDefaultArgs<ExtArgs>
  }
  export type AccountBalanceIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    account?: boolean | AccountDefaultArgs<ExtArgs>
  }

  export type $AccountBalancePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AccountBalance"
    objects: {
      account: Prisma.$AccountPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      accountId: string
      createdAt: Date
      date: Date
      id: string
      updatedAt: Date
      userId: string
      value: number
    }, ExtArgs["result"]["accountBalance"]>
    composites: {}
  }

  type AccountBalanceGetPayload<S extends boolean | null | undefined | AccountBalanceDefaultArgs> = $Result.GetResult<Prisma.$AccountBalancePayload, S>

  type AccountBalanceCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<AccountBalanceFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: AccountBalanceCountAggregateInputType | true
    }

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

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

    /**
     * Find the first AccountBalance 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 {AccountBalanceFindFirstArgs} args - Arguments to find a AccountBalance
     * @example
     * // Get one AccountBalance
     * const accountBalance = await prisma.accountBalance.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AccountBalanceFindFirstArgs>(args?: SelectSubset<T, AccountBalanceFindFirstArgs<ExtArgs>>): Prisma__AccountBalanceClient<$Result.GetResult<Prisma.$AccountBalancePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first AccountBalance 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 {AccountBalanceFindFirstOrThrowArgs} args - Arguments to find a AccountBalance
     * @example
     * // Get one AccountBalance
     * const accountBalance = await prisma.accountBalance.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AccountBalanceFindFirstOrThrowArgs>(args?: SelectSubset<T, AccountBalanceFindFirstOrThrowArgs<ExtArgs>>): Prisma__AccountBalanceClient<$Result.GetResult<Prisma.$AccountBalancePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more AccountBalances 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 {AccountBalanceFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all AccountBalances
     * const accountBalances = await prisma.accountBalance.findMany()
     * 
     * // Get first 10 AccountBalances
     * const accountBalances = await prisma.accountBalance.findMany({ take: 10 })
     * 
     * // Only select the `accountId`
     * const accountBalanceWithAccountIdOnly = await prisma.accountBalance.findMany({ select: { accountId: true } })
     * 
     */
    findMany<T extends AccountBalanceFindManyArgs>(args?: SelectSubset<T, AccountBalanceFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountBalancePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a AccountBalance.
     * @param {AccountBalanceCreateArgs} args - Arguments to create a AccountBalance.
     * @example
     * // Create one AccountBalance
     * const AccountBalance = await prisma.accountBalance.create({
     *   data: {
     *     // ... data to create a AccountBalance
     *   }
     * })
     * 
     */
    create<T extends AccountBalanceCreateArgs>(args: SelectSubset<T, AccountBalanceCreateArgs<ExtArgs>>): Prisma__AccountBalanceClient<$Result.GetResult<Prisma.$AccountBalancePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many AccountBalances and returns the data saved in the database.
     * @param {AccountBalanceCreateManyAndReturnArgs} args - Arguments to create many AccountBalances.
     * @example
     * // Create many AccountBalances
     * const accountBalance = await prisma.accountBalance.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many AccountBalances and only return the `accountId`
     * const accountBalanceWithAccountIdOnly = await prisma.accountBalance.createManyAndReturn({
     *   select: { accountId: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends AccountBalanceCreateManyAndReturnArgs>(args?: SelectSubset<T, AccountBalanceCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountBalancePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a AccountBalance.
     * @param {AccountBalanceDeleteArgs} args - Arguments to delete one AccountBalance.
     * @example
     * // Delete one AccountBalance
     * const AccountBalance = await prisma.accountBalance.delete({
     *   where: {
     *     // ... filter to delete one AccountBalance
     *   }
     * })
     * 
     */
    delete<T extends AccountBalanceDeleteArgs>(args: SelectSubset<T, AccountBalanceDeleteArgs<ExtArgs>>): Prisma__AccountBalanceClient<$Result.GetResult<Prisma.$AccountBalancePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one AccountBalance.
     * @param {AccountBalanceUpdateArgs} args - Arguments to update one AccountBalance.
     * @example
     * // Update one AccountBalance
     * const accountBalance = await prisma.accountBalance.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AccountBalanceUpdateArgs>(args: SelectSubset<T, AccountBalanceUpdateArgs<ExtArgs>>): Prisma__AccountBalanceClient<$Result.GetResult<Prisma.$AccountBalancePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more AccountBalances and returns the data updated in the database.
     * @param {AccountBalanceUpdateManyAndReturnArgs} args - Arguments to update many AccountBalances.
     * @example
     * // Update many AccountBalances
     * const accountBalance = await prisma.accountBalance.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more AccountBalances and only return the `accountId`
     * const accountBalanceWithAccountIdOnly = await prisma.accountBalance.updateManyAndReturn({
     *   select: { accountId: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends AccountBalanceUpdateManyAndReturnArgs>(args: SelectSubset<T, AccountBalanceUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountBalancePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a AccountBalance.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountBalanceAggregateArgs} 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 AccountBalanceAggregateArgs>(args: Subset<T, AccountBalanceAggregateArgs>): Prisma.PrismaPromise<GetAccountBalanceAggregateType<T>>

    /**
     * Group by AccountBalance.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AccountBalanceGroupByArgs} 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 AccountBalanceGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AccountBalanceGroupByArgs['orderBy'] }
        : { orderBy?: AccountBalanceGroupByArgs['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, AccountBalanceGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAccountBalanceGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the AccountBalance model
   */
  readonly fields: AccountBalanceFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for AccountBalance.
   * 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__AccountBalanceClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    account<T extends AccountDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AccountDefaultArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 AccountBalance model
   */
  interface AccountBalanceFieldRefs {
    readonly accountId: FieldRef<"AccountBalance", 'String'>
    readonly createdAt: FieldRef<"AccountBalance", 'DateTime'>
    readonly date: FieldRef<"AccountBalance", 'DateTime'>
    readonly id: FieldRef<"AccountBalance", 'String'>
    readonly updatedAt: FieldRef<"AccountBalance", 'DateTime'>
    readonly userId: FieldRef<"AccountBalance", 'String'>
    readonly value: FieldRef<"AccountBalance", 'Float'>
  }
    

  // Custom InputTypes
  /**
   * AccountBalance findUnique
   */
  export type AccountBalanceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
    /**
     * Filter, which AccountBalance to fetch.
     */
    where: AccountBalanceWhereUniqueInput
  }

  /**
   * AccountBalance findUniqueOrThrow
   */
  export type AccountBalanceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
    /**
     * Filter, which AccountBalance to fetch.
     */
    where: AccountBalanceWhereUniqueInput
  }

  /**
   * AccountBalance findFirst
   */
  export type AccountBalanceFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
    /**
     * Filter, which AccountBalance to fetch.
     */
    where?: AccountBalanceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AccountBalances to fetch.
     */
    orderBy?: AccountBalanceOrderByWithRelationInput | AccountBalanceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AccountBalances.
     */
    cursor?: AccountBalanceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AccountBalances 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` AccountBalances.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of AccountBalances.
     */
    distinct?: AccountBalanceScalarFieldEnum | AccountBalanceScalarFieldEnum[]
  }

  /**
   * AccountBalance findFirstOrThrow
   */
  export type AccountBalanceFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
    /**
     * Filter, which AccountBalance to fetch.
     */
    where?: AccountBalanceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AccountBalances to fetch.
     */
    orderBy?: AccountBalanceOrderByWithRelationInput | AccountBalanceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AccountBalances.
     */
    cursor?: AccountBalanceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AccountBalances 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` AccountBalances.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of AccountBalances.
     */
    distinct?: AccountBalanceScalarFieldEnum | AccountBalanceScalarFieldEnum[]
  }

  /**
   * AccountBalance findMany
   */
  export type AccountBalanceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
    /**
     * Filter, which AccountBalances to fetch.
     */
    where?: AccountBalanceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AccountBalances to fetch.
     */
    orderBy?: AccountBalanceOrderByWithRelationInput | AccountBalanceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing AccountBalances.
     */
    cursor?: AccountBalanceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AccountBalances 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` AccountBalances.
     */
    skip?: number
    distinct?: AccountBalanceScalarFieldEnum | AccountBalanceScalarFieldEnum[]
  }

  /**
   * AccountBalance create
   */
  export type AccountBalanceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
    /**
     * The data needed to create a AccountBalance.
     */
    data: XOR<AccountBalanceCreateInput, AccountBalanceUncheckedCreateInput>
  }

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

  /**
   * AccountBalance createManyAndReturn
   */
  export type AccountBalanceCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * The data used to create many AccountBalances.
     */
    data: AccountBalanceCreateManyInput | AccountBalanceCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * AccountBalance update
   */
  export type AccountBalanceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
    /**
     * The data needed to update a AccountBalance.
     */
    data: XOR<AccountBalanceUpdateInput, AccountBalanceUncheckedUpdateInput>
    /**
     * Choose, which AccountBalance to update.
     */
    where: AccountBalanceWhereUniqueInput
  }

  /**
   * AccountBalance updateMany
   */
  export type AccountBalanceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AccountBalances.
     */
    data: XOR<AccountBalanceUpdateManyMutationInput, AccountBalanceUncheckedUpdateManyInput>
    /**
     * Filter which AccountBalances to update
     */
    where?: AccountBalanceWhereInput
    /**
     * Limit how many AccountBalances to update.
     */
    limit?: number
  }

  /**
   * AccountBalance updateManyAndReturn
   */
  export type AccountBalanceUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * The data used to update AccountBalances.
     */
    data: XOR<AccountBalanceUpdateManyMutationInput, AccountBalanceUncheckedUpdateManyInput>
    /**
     * Filter which AccountBalances to update
     */
    where?: AccountBalanceWhereInput
    /**
     * Limit how many AccountBalances to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * AccountBalance upsert
   */
  export type AccountBalanceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
    /**
     * The filter to search for the AccountBalance to update in case it exists.
     */
    where: AccountBalanceWhereUniqueInput
    /**
     * In case the AccountBalance found by the `where` argument doesn't exist, create a new AccountBalance with this data.
     */
    create: XOR<AccountBalanceCreateInput, AccountBalanceUncheckedCreateInput>
    /**
     * In case the AccountBalance was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AccountBalanceUpdateInput, AccountBalanceUncheckedUpdateInput>
  }

  /**
   * AccountBalance delete
   */
  export type AccountBalanceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
    /**
     * Filter which AccountBalance to delete.
     */
    where: AccountBalanceWhereUniqueInput
  }

  /**
   * AccountBalance deleteMany
   */
  export type AccountBalanceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AccountBalances to delete
     */
    where?: AccountBalanceWhereInput
    /**
     * Limit how many AccountBalances to delete.
     */
    limit?: number
  }

  /**
   * AccountBalance without action
   */
  export type AccountBalanceDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AccountBalance
     */
    select?: AccountBalanceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AccountBalance
     */
    omit?: AccountBalanceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountBalanceInclude<ExtArgs> | null
  }


  /**
   * Model Analytics
   */

  export type AggregateAnalytics = {
    _count: AnalyticsCountAggregateOutputType | null
    _avg: AnalyticsAvgAggregateOutputType | null
    _sum: AnalyticsSumAggregateOutputType | null
    _min: AnalyticsMinAggregateOutputType | null
    _max: AnalyticsMaxAggregateOutputType | null
  }

  export type AnalyticsAvgAggregateOutputType = {
    activityCount: number | null
    dataProviderGhostfolioDailyRequests: number | null
  }

  export type AnalyticsSumAggregateOutputType = {
    activityCount: number | null
    dataProviderGhostfolioDailyRequests: number | null
  }

  export type AnalyticsMinAggregateOutputType = {
    activityCount: number | null
    country: string | null
    dataProviderGhostfolioDailyRequests: number | null
    lastRequestAt: Date | null
    updatedAt: Date | null
    userId: string | null
  }

  export type AnalyticsMaxAggregateOutputType = {
    activityCount: number | null
    country: string | null
    dataProviderGhostfolioDailyRequests: number | null
    lastRequestAt: Date | null
    updatedAt: Date | null
    userId: string | null
  }

  export type AnalyticsCountAggregateOutputType = {
    activityCount: number
    country: number
    dataProviderGhostfolioDailyRequests: number
    lastRequestAt: number
    updatedAt: number
    userId: number
    _all: number
  }


  export type AnalyticsAvgAggregateInputType = {
    activityCount?: true
    dataProviderGhostfolioDailyRequests?: true
  }

  export type AnalyticsSumAggregateInputType = {
    activityCount?: true
    dataProviderGhostfolioDailyRequests?: true
  }

  export type AnalyticsMinAggregateInputType = {
    activityCount?: true
    country?: true
    dataProviderGhostfolioDailyRequests?: true
    lastRequestAt?: true
    updatedAt?: true
    userId?: true
  }

  export type AnalyticsMaxAggregateInputType = {
    activityCount?: true
    country?: true
    dataProviderGhostfolioDailyRequests?: true
    lastRequestAt?: true
    updatedAt?: true
    userId?: true
  }

  export type AnalyticsCountAggregateInputType = {
    activityCount?: true
    country?: true
    dataProviderGhostfolioDailyRequests?: true
    lastRequestAt?: true
    updatedAt?: true
    userId?: true
    _all?: true
  }

  export type AnalyticsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Analytics to aggregate.
     */
    where?: AnalyticsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Analytics to fetch.
     */
    orderBy?: AnalyticsOrderByWithRelationInput | AnalyticsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AnalyticsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Analytics 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` Analytics.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Analytics
    **/
    _count?: true | AnalyticsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AnalyticsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AnalyticsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AnalyticsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AnalyticsMaxAggregateInputType
  }

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




  export type AnalyticsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AnalyticsWhereInput
    orderBy?: AnalyticsOrderByWithAggregationInput | AnalyticsOrderByWithAggregationInput[]
    by: AnalyticsScalarFieldEnum[] | AnalyticsScalarFieldEnum
    having?: AnalyticsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AnalyticsCountAggregateInputType | true
    _avg?: AnalyticsAvgAggregateInputType
    _sum?: AnalyticsSumAggregateInputType
    _min?: AnalyticsMinAggregateInputType
    _max?: AnalyticsMaxAggregateInputType
  }

  export type AnalyticsGroupByOutputType = {
    activityCount: number
    country: string | null
    dataProviderGhostfolioDailyRequests: number
    lastRequestAt: Date
    updatedAt: Date
    userId: string
    _count: AnalyticsCountAggregateOutputType | null
    _avg: AnalyticsAvgAggregateOutputType | null
    _sum: AnalyticsSumAggregateOutputType | null
    _min: AnalyticsMinAggregateOutputType | null
    _max: AnalyticsMaxAggregateOutputType | null
  }

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


  export type AnalyticsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    activityCount?: boolean
    country?: boolean
    dataProviderGhostfolioDailyRequests?: boolean
    lastRequestAt?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["analytics"]>

  export type AnalyticsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    activityCount?: boolean
    country?: boolean
    dataProviderGhostfolioDailyRequests?: boolean
    lastRequestAt?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["analytics"]>

  export type AnalyticsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    activityCount?: boolean
    country?: boolean
    dataProviderGhostfolioDailyRequests?: boolean
    lastRequestAt?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["analytics"]>

  export type AnalyticsSelectScalar = {
    activityCount?: boolean
    country?: boolean
    dataProviderGhostfolioDailyRequests?: boolean
    lastRequestAt?: boolean
    updatedAt?: boolean
    userId?: boolean
  }

  export type AnalyticsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"activityCount" | "country" | "dataProviderGhostfolioDailyRequests" | "lastRequestAt" | "updatedAt" | "userId", ExtArgs["result"]["analytics"]>
  export type AnalyticsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AnalyticsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AnalyticsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $AnalyticsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Analytics"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      activityCount: number
      country: string | null
      dataProviderGhostfolioDailyRequests: number
      lastRequestAt: Date
      updatedAt: Date
      userId: string
    }, ExtArgs["result"]["analytics"]>
    composites: {}
  }

  type AnalyticsGetPayload<S extends boolean | null | undefined | AnalyticsDefaultArgs> = $Result.GetResult<Prisma.$AnalyticsPayload, S>

  type AnalyticsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<AnalyticsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: AnalyticsCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Analytics 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 {AnalyticsFindFirstArgs} args - Arguments to find a Analytics
     * @example
     * // Get one Analytics
     * const analytics = await prisma.analytics.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AnalyticsFindFirstArgs>(args?: SelectSubset<T, AnalyticsFindFirstArgs<ExtArgs>>): Prisma__AnalyticsClient<$Result.GetResult<Prisma.$AnalyticsPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Analytics 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 {AnalyticsFindFirstOrThrowArgs} args - Arguments to find a Analytics
     * @example
     * // Get one Analytics
     * const analytics = await prisma.analytics.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AnalyticsFindFirstOrThrowArgs>(args?: SelectSubset<T, AnalyticsFindFirstOrThrowArgs<ExtArgs>>): Prisma__AnalyticsClient<$Result.GetResult<Prisma.$AnalyticsPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Analytics 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 {AnalyticsFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Analytics
     * const analytics = await prisma.analytics.findMany()
     * 
     * // Get first 10 Analytics
     * const analytics = await prisma.analytics.findMany({ take: 10 })
     * 
     * // Only select the `activityCount`
     * const analyticsWithActivityCountOnly = await prisma.analytics.findMany({ select: { activityCount: true } })
     * 
     */
    findMany<T extends AnalyticsFindManyArgs>(args?: SelectSubset<T, AnalyticsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AnalyticsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Analytics.
     * @param {AnalyticsCreateArgs} args - Arguments to create a Analytics.
     * @example
     * // Create one Analytics
     * const Analytics = await prisma.analytics.create({
     *   data: {
     *     // ... data to create a Analytics
     *   }
     * })
     * 
     */
    create<T extends AnalyticsCreateArgs>(args: SelectSubset<T, AnalyticsCreateArgs<ExtArgs>>): Prisma__AnalyticsClient<$Result.GetResult<Prisma.$AnalyticsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Analytics and returns the data saved in the database.
     * @param {AnalyticsCreateManyAndReturnArgs} args - Arguments to create many Analytics.
     * @example
     * // Create many Analytics
     * const analytics = await prisma.analytics.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Analytics and only return the `activityCount`
     * const analyticsWithActivityCountOnly = await prisma.analytics.createManyAndReturn({
     *   select: { activityCount: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends AnalyticsCreateManyAndReturnArgs>(args?: SelectSubset<T, AnalyticsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AnalyticsPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Analytics.
     * @param {AnalyticsDeleteArgs} args - Arguments to delete one Analytics.
     * @example
     * // Delete one Analytics
     * const Analytics = await prisma.analytics.delete({
     *   where: {
     *     // ... filter to delete one Analytics
     *   }
     * })
     * 
     */
    delete<T extends AnalyticsDeleteArgs>(args: SelectSubset<T, AnalyticsDeleteArgs<ExtArgs>>): Prisma__AnalyticsClient<$Result.GetResult<Prisma.$AnalyticsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Analytics.
     * @param {AnalyticsUpdateArgs} args - Arguments to update one Analytics.
     * @example
     * // Update one Analytics
     * const analytics = await prisma.analytics.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AnalyticsUpdateArgs>(args: SelectSubset<T, AnalyticsUpdateArgs<ExtArgs>>): Prisma__AnalyticsClient<$Result.GetResult<Prisma.$AnalyticsPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more Analytics and returns the data updated in the database.
     * @param {AnalyticsUpdateManyAndReturnArgs} args - Arguments to update many Analytics.
     * @example
     * // Update many Analytics
     * const analytics = await prisma.analytics.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Analytics and only return the `activityCount`
     * const analyticsWithActivityCountOnly = await prisma.analytics.updateManyAndReturn({
     *   select: { activityCount: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends AnalyticsUpdateManyAndReturnArgs>(args: SelectSubset<T, AnalyticsUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AnalyticsPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a Analytics.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AnalyticsAggregateArgs} 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 AnalyticsAggregateArgs>(args: Subset<T, AnalyticsAggregateArgs>): Prisma.PrismaPromise<GetAnalyticsAggregateType<T>>

    /**
     * Group by Analytics.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AnalyticsGroupByArgs} 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 AnalyticsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AnalyticsGroupByArgs['orderBy'] }
        : { orderBy?: AnalyticsGroupByArgs['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, AnalyticsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAnalyticsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Analytics model
   */
  readonly fields: AnalyticsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Analytics.
   * 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__AnalyticsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 Analytics model
   */
  interface AnalyticsFieldRefs {
    readonly activityCount: FieldRef<"Analytics", 'Int'>
    readonly country: FieldRef<"Analytics", 'String'>
    readonly dataProviderGhostfolioDailyRequests: FieldRef<"Analytics", 'Int'>
    readonly lastRequestAt: FieldRef<"Analytics", 'DateTime'>
    readonly updatedAt: FieldRef<"Analytics", 'DateTime'>
    readonly userId: FieldRef<"Analytics", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Analytics findUnique
   */
  export type AnalyticsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
    /**
     * Filter, which Analytics to fetch.
     */
    where: AnalyticsWhereUniqueInput
  }

  /**
   * Analytics findUniqueOrThrow
   */
  export type AnalyticsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
    /**
     * Filter, which Analytics to fetch.
     */
    where: AnalyticsWhereUniqueInput
  }

  /**
   * Analytics findFirst
   */
  export type AnalyticsFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
    /**
     * Filter, which Analytics to fetch.
     */
    where?: AnalyticsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Analytics to fetch.
     */
    orderBy?: AnalyticsOrderByWithRelationInput | AnalyticsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Analytics.
     */
    cursor?: AnalyticsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Analytics 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` Analytics.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Analytics.
     */
    distinct?: AnalyticsScalarFieldEnum | AnalyticsScalarFieldEnum[]
  }

  /**
   * Analytics findFirstOrThrow
   */
  export type AnalyticsFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
    /**
     * Filter, which Analytics to fetch.
     */
    where?: AnalyticsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Analytics to fetch.
     */
    orderBy?: AnalyticsOrderByWithRelationInput | AnalyticsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Analytics.
     */
    cursor?: AnalyticsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Analytics 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` Analytics.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Analytics.
     */
    distinct?: AnalyticsScalarFieldEnum | AnalyticsScalarFieldEnum[]
  }

  /**
   * Analytics findMany
   */
  export type AnalyticsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
    /**
     * Filter, which Analytics to fetch.
     */
    where?: AnalyticsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Analytics to fetch.
     */
    orderBy?: AnalyticsOrderByWithRelationInput | AnalyticsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Analytics.
     */
    cursor?: AnalyticsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Analytics 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` Analytics.
     */
    skip?: number
    distinct?: AnalyticsScalarFieldEnum | AnalyticsScalarFieldEnum[]
  }

  /**
   * Analytics create
   */
  export type AnalyticsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
    /**
     * The data needed to create a Analytics.
     */
    data: XOR<AnalyticsCreateInput, AnalyticsUncheckedCreateInput>
  }

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

  /**
   * Analytics createManyAndReturn
   */
  export type AnalyticsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * The data used to create many Analytics.
     */
    data: AnalyticsCreateManyInput | AnalyticsCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Analytics update
   */
  export type AnalyticsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
    /**
     * The data needed to update a Analytics.
     */
    data: XOR<AnalyticsUpdateInput, AnalyticsUncheckedUpdateInput>
    /**
     * Choose, which Analytics to update.
     */
    where: AnalyticsWhereUniqueInput
  }

  /**
   * Analytics updateMany
   */
  export type AnalyticsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Analytics.
     */
    data: XOR<AnalyticsUpdateManyMutationInput, AnalyticsUncheckedUpdateManyInput>
    /**
     * Filter which Analytics to update
     */
    where?: AnalyticsWhereInput
    /**
     * Limit how many Analytics to update.
     */
    limit?: number
  }

  /**
   * Analytics updateManyAndReturn
   */
  export type AnalyticsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * The data used to update Analytics.
     */
    data: XOR<AnalyticsUpdateManyMutationInput, AnalyticsUncheckedUpdateManyInput>
    /**
     * Filter which Analytics to update
     */
    where?: AnalyticsWhereInput
    /**
     * Limit how many Analytics to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Analytics upsert
   */
  export type AnalyticsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
    /**
     * The filter to search for the Analytics to update in case it exists.
     */
    where: AnalyticsWhereUniqueInput
    /**
     * In case the Analytics found by the `where` argument doesn't exist, create a new Analytics with this data.
     */
    create: XOR<AnalyticsCreateInput, AnalyticsUncheckedCreateInput>
    /**
     * In case the Analytics was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AnalyticsUpdateInput, AnalyticsUncheckedUpdateInput>
  }

  /**
   * Analytics delete
   */
  export type AnalyticsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
    /**
     * Filter which Analytics to delete.
     */
    where: AnalyticsWhereUniqueInput
  }

  /**
   * Analytics deleteMany
   */
  export type AnalyticsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Analytics to delete
     */
    where?: AnalyticsWhereInput
    /**
     * Limit how many Analytics to delete.
     */
    limit?: number
  }

  /**
   * Analytics without action
   */
  export type AnalyticsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
  }


  /**
   * Model ApiKey
   */

  export type AggregateApiKey = {
    _count: ApiKeyCountAggregateOutputType | null
    _min: ApiKeyMinAggregateOutputType | null
    _max: ApiKeyMaxAggregateOutputType | null
  }

  export type ApiKeyMinAggregateOutputType = {
    createdAt: Date | null
    hashedKey: string | null
    id: string | null
    updatedAt: Date | null
    userId: string | null
  }

  export type ApiKeyMaxAggregateOutputType = {
    createdAt: Date | null
    hashedKey: string | null
    id: string | null
    updatedAt: Date | null
    userId: string | null
  }

  export type ApiKeyCountAggregateOutputType = {
    createdAt: number
    hashedKey: number
    id: number
    updatedAt: number
    userId: number
    _all: number
  }


  export type ApiKeyMinAggregateInputType = {
    createdAt?: true
    hashedKey?: true
    id?: true
    updatedAt?: true
    userId?: true
  }

  export type ApiKeyMaxAggregateInputType = {
    createdAt?: true
    hashedKey?: true
    id?: true
    updatedAt?: true
    userId?: true
  }

  export type ApiKeyCountAggregateInputType = {
    createdAt?: true
    hashedKey?: true
    id?: true
    updatedAt?: true
    userId?: true
    _all?: true
  }

  export type ApiKeyAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ApiKey to aggregate.
     */
    where?: ApiKeyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ApiKeys to fetch.
     */
    orderBy?: ApiKeyOrderByWithRelationInput | ApiKeyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ApiKeyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ApiKeys 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` ApiKeys.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ApiKeys
    **/
    _count?: true | ApiKeyCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ApiKeyMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ApiKeyMaxAggregateInputType
  }

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




  export type ApiKeyGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ApiKeyWhereInput
    orderBy?: ApiKeyOrderByWithAggregationInput | ApiKeyOrderByWithAggregationInput[]
    by: ApiKeyScalarFieldEnum[] | ApiKeyScalarFieldEnum
    having?: ApiKeyScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ApiKeyCountAggregateInputType | true
    _min?: ApiKeyMinAggregateInputType
    _max?: ApiKeyMaxAggregateInputType
  }

  export type ApiKeyGroupByOutputType = {
    createdAt: Date
    hashedKey: string
    id: string
    updatedAt: Date
    userId: string
    _count: ApiKeyCountAggregateOutputType | null
    _min: ApiKeyMinAggregateOutputType | null
    _max: ApiKeyMaxAggregateOutputType | null
  }

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


  export type ApiKeySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    hashedKey?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["apiKey"]>

  export type ApiKeySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    hashedKey?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["apiKey"]>

  export type ApiKeySelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    hashedKey?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["apiKey"]>

  export type ApiKeySelectScalar = {
    createdAt?: boolean
    hashedKey?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
  }

  export type ApiKeyOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"createdAt" | "hashedKey" | "id" | "updatedAt" | "userId", ExtArgs["result"]["apiKey"]>
  export type ApiKeyInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ApiKeyIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type ApiKeyIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $ApiKeyPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ApiKey"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      createdAt: Date
      hashedKey: string
      id: string
      updatedAt: Date
      userId: string
    }, ExtArgs["result"]["apiKey"]>
    composites: {}
  }

  type ApiKeyGetPayload<S extends boolean | null | undefined | ApiKeyDefaultArgs> = $Result.GetResult<Prisma.$ApiKeyPayload, S>

  type ApiKeyCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<ApiKeyFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: ApiKeyCountAggregateInputType | true
    }

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

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

    /**
     * Find the first ApiKey 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 {ApiKeyFindFirstArgs} args - Arguments to find a ApiKey
     * @example
     * // Get one ApiKey
     * const apiKey = await prisma.apiKey.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ApiKeyFindFirstArgs>(args?: SelectSubset<T, ApiKeyFindFirstArgs<ExtArgs>>): Prisma__ApiKeyClient<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first ApiKey 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 {ApiKeyFindFirstOrThrowArgs} args - Arguments to find a ApiKey
     * @example
     * // Get one ApiKey
     * const apiKey = await prisma.apiKey.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ApiKeyFindFirstOrThrowArgs>(args?: SelectSubset<T, ApiKeyFindFirstOrThrowArgs<ExtArgs>>): Prisma__ApiKeyClient<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more ApiKeys 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 {ApiKeyFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all ApiKeys
     * const apiKeys = await prisma.apiKey.findMany()
     * 
     * // Get first 10 ApiKeys
     * const apiKeys = await prisma.apiKey.findMany({ take: 10 })
     * 
     * // Only select the `createdAt`
     * const apiKeyWithCreatedAtOnly = await prisma.apiKey.findMany({ select: { createdAt: true } })
     * 
     */
    findMany<T extends ApiKeyFindManyArgs>(args?: SelectSubset<T, ApiKeyFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a ApiKey.
     * @param {ApiKeyCreateArgs} args - Arguments to create a ApiKey.
     * @example
     * // Create one ApiKey
     * const ApiKey = await prisma.apiKey.create({
     *   data: {
     *     // ... data to create a ApiKey
     *   }
     * })
     * 
     */
    create<T extends ApiKeyCreateArgs>(args: SelectSubset<T, ApiKeyCreateArgs<ExtArgs>>): Prisma__ApiKeyClient<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many ApiKeys and returns the data saved in the database.
     * @param {ApiKeyCreateManyAndReturnArgs} args - Arguments to create many ApiKeys.
     * @example
     * // Create many ApiKeys
     * const apiKey = await prisma.apiKey.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many ApiKeys and only return the `createdAt`
     * const apiKeyWithCreatedAtOnly = await prisma.apiKey.createManyAndReturn({
     *   select: { createdAt: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends ApiKeyCreateManyAndReturnArgs>(args?: SelectSubset<T, ApiKeyCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a ApiKey.
     * @param {ApiKeyDeleteArgs} args - Arguments to delete one ApiKey.
     * @example
     * // Delete one ApiKey
     * const ApiKey = await prisma.apiKey.delete({
     *   where: {
     *     // ... filter to delete one ApiKey
     *   }
     * })
     * 
     */
    delete<T extends ApiKeyDeleteArgs>(args: SelectSubset<T, ApiKeyDeleteArgs<ExtArgs>>): Prisma__ApiKeyClient<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one ApiKey.
     * @param {ApiKeyUpdateArgs} args - Arguments to update one ApiKey.
     * @example
     * // Update one ApiKey
     * const apiKey = await prisma.apiKey.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ApiKeyUpdateArgs>(args: SelectSubset<T, ApiKeyUpdateArgs<ExtArgs>>): Prisma__ApiKeyClient<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more ApiKeys and returns the data updated in the database.
     * @param {ApiKeyUpdateManyAndReturnArgs} args - Arguments to update many ApiKeys.
     * @example
     * // Update many ApiKeys
     * const apiKey = await prisma.apiKey.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more ApiKeys and only return the `createdAt`
     * const apiKeyWithCreatedAtOnly = await prisma.apiKey.updateManyAndReturn({
     *   select: { createdAt: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends ApiKeyUpdateManyAndReturnArgs>(args: SelectSubset<T, ApiKeyUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a ApiKey.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ApiKeyAggregateArgs} 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 ApiKeyAggregateArgs>(args: Subset<T, ApiKeyAggregateArgs>): Prisma.PrismaPromise<GetApiKeyAggregateType<T>>

    /**
     * Group by ApiKey.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ApiKeyGroupByArgs} 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 ApiKeyGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ApiKeyGroupByArgs['orderBy'] }
        : { orderBy?: ApiKeyGroupByArgs['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, ApiKeyGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetApiKeyGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the ApiKey model
   */
  readonly fields: ApiKeyFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for ApiKey.
   * 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__ApiKeyClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 ApiKey model
   */
  interface ApiKeyFieldRefs {
    readonly createdAt: FieldRef<"ApiKey", 'DateTime'>
    readonly hashedKey: FieldRef<"ApiKey", 'String'>
    readonly id: FieldRef<"ApiKey", 'String'>
    readonly updatedAt: FieldRef<"ApiKey", 'DateTime'>
    readonly userId: FieldRef<"ApiKey", 'String'>
  }
    

  // Custom InputTypes
  /**
   * ApiKey findUnique
   */
  export type ApiKeyFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * Filter, which ApiKey to fetch.
     */
    where: ApiKeyWhereUniqueInput
  }

  /**
   * ApiKey findUniqueOrThrow
   */
  export type ApiKeyFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * Filter, which ApiKey to fetch.
     */
    where: ApiKeyWhereUniqueInput
  }

  /**
   * ApiKey findFirst
   */
  export type ApiKeyFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * Filter, which ApiKey to fetch.
     */
    where?: ApiKeyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ApiKeys to fetch.
     */
    orderBy?: ApiKeyOrderByWithRelationInput | ApiKeyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ApiKeys.
     */
    cursor?: ApiKeyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ApiKeys 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` ApiKeys.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ApiKeys.
     */
    distinct?: ApiKeyScalarFieldEnum | ApiKeyScalarFieldEnum[]
  }

  /**
   * ApiKey findFirstOrThrow
   */
  export type ApiKeyFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * Filter, which ApiKey to fetch.
     */
    where?: ApiKeyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ApiKeys to fetch.
     */
    orderBy?: ApiKeyOrderByWithRelationInput | ApiKeyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ApiKeys.
     */
    cursor?: ApiKeyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ApiKeys 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` ApiKeys.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ApiKeys.
     */
    distinct?: ApiKeyScalarFieldEnum | ApiKeyScalarFieldEnum[]
  }

  /**
   * ApiKey findMany
   */
  export type ApiKeyFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * Filter, which ApiKeys to fetch.
     */
    where?: ApiKeyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ApiKeys to fetch.
     */
    orderBy?: ApiKeyOrderByWithRelationInput | ApiKeyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ApiKeys.
     */
    cursor?: ApiKeyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ApiKeys 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` ApiKeys.
     */
    skip?: number
    distinct?: ApiKeyScalarFieldEnum | ApiKeyScalarFieldEnum[]
  }

  /**
   * ApiKey create
   */
  export type ApiKeyCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * The data needed to create a ApiKey.
     */
    data: XOR<ApiKeyCreateInput, ApiKeyUncheckedCreateInput>
  }

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

  /**
   * ApiKey createManyAndReturn
   */
  export type ApiKeyCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * The data used to create many ApiKeys.
     */
    data: ApiKeyCreateManyInput | ApiKeyCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ApiKey update
   */
  export type ApiKeyUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * The data needed to update a ApiKey.
     */
    data: XOR<ApiKeyUpdateInput, ApiKeyUncheckedUpdateInput>
    /**
     * Choose, which ApiKey to update.
     */
    where: ApiKeyWhereUniqueInput
  }

  /**
   * ApiKey updateMany
   */
  export type ApiKeyUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ApiKeys.
     */
    data: XOR<ApiKeyUpdateManyMutationInput, ApiKeyUncheckedUpdateManyInput>
    /**
     * Filter which ApiKeys to update
     */
    where?: ApiKeyWhereInput
    /**
     * Limit how many ApiKeys to update.
     */
    limit?: number
  }

  /**
   * ApiKey updateManyAndReturn
   */
  export type ApiKeyUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * The data used to update ApiKeys.
     */
    data: XOR<ApiKeyUpdateManyMutationInput, ApiKeyUncheckedUpdateManyInput>
    /**
     * Filter which ApiKeys to update
     */
    where?: ApiKeyWhereInput
    /**
     * Limit how many ApiKeys to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * ApiKey upsert
   */
  export type ApiKeyUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * The filter to search for the ApiKey to update in case it exists.
     */
    where: ApiKeyWhereUniqueInput
    /**
     * In case the ApiKey found by the `where` argument doesn't exist, create a new ApiKey with this data.
     */
    create: XOR<ApiKeyCreateInput, ApiKeyUncheckedCreateInput>
    /**
     * In case the ApiKey was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ApiKeyUpdateInput, ApiKeyUncheckedUpdateInput>
  }

  /**
   * ApiKey delete
   */
  export type ApiKeyDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    /**
     * Filter which ApiKey to delete.
     */
    where: ApiKeyWhereUniqueInput
  }

  /**
   * ApiKey deleteMany
   */
  export type ApiKeyDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ApiKeys to delete
     */
    where?: ApiKeyWhereInput
    /**
     * Limit how many ApiKeys to delete.
     */
    limit?: number
  }

  /**
   * ApiKey without action
   */
  export type ApiKeyDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
  }


  /**
   * Model AssetProfileResolution
   */

  export type AggregateAssetProfileResolution = {
    _count: AssetProfileResolutionCountAggregateOutputType | null
    _avg: AssetProfileResolutionAvgAggregateOutputType | null
    _sum: AssetProfileResolutionSumAggregateOutputType | null
    _min: AssetProfileResolutionMinAggregateOutputType | null
    _max: AssetProfileResolutionMaxAggregateOutputType | null
  }

  export type AssetProfileResolutionAvgAggregateOutputType = {
    requestCount: number | null
  }

  export type AssetProfileResolutionSumAggregateOutputType = {
    requestCount: number | null
  }

  export type AssetProfileResolutionMinAggregateOutputType = {
    createdAt: Date | null
    currency: string | null
    dataSourceOrigin: $Enums.DataSource | null
    dataSourceTarget: $Enums.DataSource | null
    id: string | null
    requestCount: number | null
    symbolOrigin: string | null
    symbolTarget: string | null
    updatedAt: Date | null
  }

  export type AssetProfileResolutionMaxAggregateOutputType = {
    createdAt: Date | null
    currency: string | null
    dataSourceOrigin: $Enums.DataSource | null
    dataSourceTarget: $Enums.DataSource | null
    id: string | null
    requestCount: number | null
    symbolOrigin: string | null
    symbolTarget: string | null
    updatedAt: Date | null
  }

  export type AssetProfileResolutionCountAggregateOutputType = {
    createdAt: number
    currency: number
    dataSourceOrigin: number
    dataSourceTarget: number
    id: number
    requestCount: number
    symbolOrigin: number
    symbolTarget: number
    updatedAt: number
    _all: number
  }


  export type AssetProfileResolutionAvgAggregateInputType = {
    requestCount?: true
  }

  export type AssetProfileResolutionSumAggregateInputType = {
    requestCount?: true
  }

  export type AssetProfileResolutionMinAggregateInputType = {
    createdAt?: true
    currency?: true
    dataSourceOrigin?: true
    dataSourceTarget?: true
    id?: true
    requestCount?: true
    symbolOrigin?: true
    symbolTarget?: true
    updatedAt?: true
  }

  export type AssetProfileResolutionMaxAggregateInputType = {
    createdAt?: true
    currency?: true
    dataSourceOrigin?: true
    dataSourceTarget?: true
    id?: true
    requestCount?: true
    symbolOrigin?: true
    symbolTarget?: true
    updatedAt?: true
  }

  export type AssetProfileResolutionCountAggregateInputType = {
    createdAt?: true
    currency?: true
    dataSourceOrigin?: true
    dataSourceTarget?: true
    id?: true
    requestCount?: true
    symbolOrigin?: true
    symbolTarget?: true
    updatedAt?: true
    _all?: true
  }

  export type AssetProfileResolutionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AssetProfileResolution to aggregate.
     */
    where?: AssetProfileResolutionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AssetProfileResolutions to fetch.
     */
    orderBy?: AssetProfileResolutionOrderByWithRelationInput | AssetProfileResolutionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AssetProfileResolutionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AssetProfileResolutions 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` AssetProfileResolutions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned AssetProfileResolutions
    **/
    _count?: true | AssetProfileResolutionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AssetProfileResolutionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AssetProfileResolutionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AssetProfileResolutionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AssetProfileResolutionMaxAggregateInputType
  }

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




  export type AssetProfileResolutionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AssetProfileResolutionWhereInput
    orderBy?: AssetProfileResolutionOrderByWithAggregationInput | AssetProfileResolutionOrderByWithAggregationInput[]
    by: AssetProfileResolutionScalarFieldEnum[] | AssetProfileResolutionScalarFieldEnum
    having?: AssetProfileResolutionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AssetProfileResolutionCountAggregateInputType | true
    _avg?: AssetProfileResolutionAvgAggregateInputType
    _sum?: AssetProfileResolutionSumAggregateInputType
    _min?: AssetProfileResolutionMinAggregateInputType
    _max?: AssetProfileResolutionMaxAggregateInputType
  }

  export type AssetProfileResolutionGroupByOutputType = {
    createdAt: Date
    currency: string
    dataSourceOrigin: $Enums.DataSource
    dataSourceTarget: $Enums.DataSource
    id: string
    requestCount: number
    symbolOrigin: string
    symbolTarget: string
    updatedAt: Date
    _count: AssetProfileResolutionCountAggregateOutputType | null
    _avg: AssetProfileResolutionAvgAggregateOutputType | null
    _sum: AssetProfileResolutionSumAggregateOutputType | null
    _min: AssetProfileResolutionMinAggregateOutputType | null
    _max: AssetProfileResolutionMaxAggregateOutputType | null
  }

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


  export type AssetProfileResolutionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    currency?: boolean
    dataSourceOrigin?: boolean
    dataSourceTarget?: boolean
    id?: boolean
    requestCount?: boolean
    symbolOrigin?: boolean
    symbolTarget?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["assetProfileResolution"]>

  export type AssetProfileResolutionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    currency?: boolean
    dataSourceOrigin?: boolean
    dataSourceTarget?: boolean
    id?: boolean
    requestCount?: boolean
    symbolOrigin?: boolean
    symbolTarget?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["assetProfileResolution"]>

  export type AssetProfileResolutionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    currency?: boolean
    dataSourceOrigin?: boolean
    dataSourceTarget?: boolean
    id?: boolean
    requestCount?: boolean
    symbolOrigin?: boolean
    symbolTarget?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["assetProfileResolution"]>

  export type AssetProfileResolutionSelectScalar = {
    createdAt?: boolean
    currency?: boolean
    dataSourceOrigin?: boolean
    dataSourceTarget?: boolean
    id?: boolean
    requestCount?: boolean
    symbolOrigin?: boolean
    symbolTarget?: boolean
    updatedAt?: boolean
  }

  export type AssetProfileResolutionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"createdAt" | "currency" | "dataSourceOrigin" | "dataSourceTarget" | "id" | "requestCount" | "symbolOrigin" | "symbolTarget" | "updatedAt", ExtArgs["result"]["assetProfileResolution"]>

  export type $AssetProfileResolutionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AssetProfileResolution"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      createdAt: Date
      currency: string
      dataSourceOrigin: $Enums.DataSource
      dataSourceTarget: $Enums.DataSource
      id: string
      requestCount: number
      symbolOrigin: string
      symbolTarget: string
      updatedAt: Date
    }, ExtArgs["result"]["assetProfileResolution"]>
    composites: {}
  }

  type AssetProfileResolutionGetPayload<S extends boolean | null | undefined | AssetProfileResolutionDefaultArgs> = $Result.GetResult<Prisma.$AssetProfileResolutionPayload, S>

  type AssetProfileResolutionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<AssetProfileResolutionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: AssetProfileResolutionCountAggregateInputType | true
    }

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

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

    /**
     * Find the first AssetProfileResolution 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 {AssetProfileResolutionFindFirstArgs} args - Arguments to find a AssetProfileResolution
     * @example
     * // Get one AssetProfileResolution
     * const assetProfileResolution = await prisma.assetProfileResolution.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AssetProfileResolutionFindFirstArgs>(args?: SelectSubset<T, AssetProfileResolutionFindFirstArgs<ExtArgs>>): Prisma__AssetProfileResolutionClient<$Result.GetResult<Prisma.$AssetProfileResolutionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first AssetProfileResolution 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 {AssetProfileResolutionFindFirstOrThrowArgs} args - Arguments to find a AssetProfileResolution
     * @example
     * // Get one AssetProfileResolution
     * const assetProfileResolution = await prisma.assetProfileResolution.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AssetProfileResolutionFindFirstOrThrowArgs>(args?: SelectSubset<T, AssetProfileResolutionFindFirstOrThrowArgs<ExtArgs>>): Prisma__AssetProfileResolutionClient<$Result.GetResult<Prisma.$AssetProfileResolutionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more AssetProfileResolutions 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 {AssetProfileResolutionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all AssetProfileResolutions
     * const assetProfileResolutions = await prisma.assetProfileResolution.findMany()
     * 
     * // Get first 10 AssetProfileResolutions
     * const assetProfileResolutions = await prisma.assetProfileResolution.findMany({ take: 10 })
     * 
     * // Only select the `createdAt`
     * const assetProfileResolutionWithCreatedAtOnly = await prisma.assetProfileResolution.findMany({ select: { createdAt: true } })
     * 
     */
    findMany<T extends AssetProfileResolutionFindManyArgs>(args?: SelectSubset<T, AssetProfileResolutionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AssetProfileResolutionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a AssetProfileResolution.
     * @param {AssetProfileResolutionCreateArgs} args - Arguments to create a AssetProfileResolution.
     * @example
     * // Create one AssetProfileResolution
     * const AssetProfileResolution = await prisma.assetProfileResolution.create({
     *   data: {
     *     // ... data to create a AssetProfileResolution
     *   }
     * })
     * 
     */
    create<T extends AssetProfileResolutionCreateArgs>(args: SelectSubset<T, AssetProfileResolutionCreateArgs<ExtArgs>>): Prisma__AssetProfileResolutionClient<$Result.GetResult<Prisma.$AssetProfileResolutionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many AssetProfileResolutions and returns the data saved in the database.
     * @param {AssetProfileResolutionCreateManyAndReturnArgs} args - Arguments to create many AssetProfileResolutions.
     * @example
     * // Create many AssetProfileResolutions
     * const assetProfileResolution = await prisma.assetProfileResolution.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many AssetProfileResolutions and only return the `createdAt`
     * const assetProfileResolutionWithCreatedAtOnly = await prisma.assetProfileResolution.createManyAndReturn({
     *   select: { createdAt: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends AssetProfileResolutionCreateManyAndReturnArgs>(args?: SelectSubset<T, AssetProfileResolutionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AssetProfileResolutionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a AssetProfileResolution.
     * @param {AssetProfileResolutionDeleteArgs} args - Arguments to delete one AssetProfileResolution.
     * @example
     * // Delete one AssetProfileResolution
     * const AssetProfileResolution = await prisma.assetProfileResolution.delete({
     *   where: {
     *     // ... filter to delete one AssetProfileResolution
     *   }
     * })
     * 
     */
    delete<T extends AssetProfileResolutionDeleteArgs>(args: SelectSubset<T, AssetProfileResolutionDeleteArgs<ExtArgs>>): Prisma__AssetProfileResolutionClient<$Result.GetResult<Prisma.$AssetProfileResolutionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one AssetProfileResolution.
     * @param {AssetProfileResolutionUpdateArgs} args - Arguments to update one AssetProfileResolution.
     * @example
     * // Update one AssetProfileResolution
     * const assetProfileResolution = await prisma.assetProfileResolution.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AssetProfileResolutionUpdateArgs>(args: SelectSubset<T, AssetProfileResolutionUpdateArgs<ExtArgs>>): Prisma__AssetProfileResolutionClient<$Result.GetResult<Prisma.$AssetProfileResolutionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more AssetProfileResolutions and returns the data updated in the database.
     * @param {AssetProfileResolutionUpdateManyAndReturnArgs} args - Arguments to update many AssetProfileResolutions.
     * @example
     * // Update many AssetProfileResolutions
     * const assetProfileResolution = await prisma.assetProfileResolution.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more AssetProfileResolutions and only return the `createdAt`
     * const assetProfileResolutionWithCreatedAtOnly = await prisma.assetProfileResolution.updateManyAndReturn({
     *   select: { createdAt: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends AssetProfileResolutionUpdateManyAndReturnArgs>(args: SelectSubset<T, AssetProfileResolutionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AssetProfileResolutionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a AssetProfileResolution.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AssetProfileResolutionAggregateArgs} 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 AssetProfileResolutionAggregateArgs>(args: Subset<T, AssetProfileResolutionAggregateArgs>): Prisma.PrismaPromise<GetAssetProfileResolutionAggregateType<T>>

    /**
     * Group by AssetProfileResolution.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AssetProfileResolutionGroupByArgs} 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 AssetProfileResolutionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AssetProfileResolutionGroupByArgs['orderBy'] }
        : { orderBy?: AssetProfileResolutionGroupByArgs['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, AssetProfileResolutionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAssetProfileResolutionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the AssetProfileResolution model
   */
  readonly fields: AssetProfileResolutionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for AssetProfileResolution.
   * 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__AssetProfileResolutionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> 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 AssetProfileResolution model
   */
  interface AssetProfileResolutionFieldRefs {
    readonly createdAt: FieldRef<"AssetProfileResolution", 'DateTime'>
    readonly currency: FieldRef<"AssetProfileResolution", 'String'>
    readonly dataSourceOrigin: FieldRef<"AssetProfileResolution", 'DataSource'>
    readonly dataSourceTarget: FieldRef<"AssetProfileResolution", 'DataSource'>
    readonly id: FieldRef<"AssetProfileResolution", 'String'>
    readonly requestCount: FieldRef<"AssetProfileResolution", 'Int'>
    readonly symbolOrigin: FieldRef<"AssetProfileResolution", 'String'>
    readonly symbolTarget: FieldRef<"AssetProfileResolution", 'String'>
    readonly updatedAt: FieldRef<"AssetProfileResolution", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * AssetProfileResolution findUnique
   */
  export type AssetProfileResolutionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * Filter, which AssetProfileResolution to fetch.
     */
    where: AssetProfileResolutionWhereUniqueInput
  }

  /**
   * AssetProfileResolution findUniqueOrThrow
   */
  export type AssetProfileResolutionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * Filter, which AssetProfileResolution to fetch.
     */
    where: AssetProfileResolutionWhereUniqueInput
  }

  /**
   * AssetProfileResolution findFirst
   */
  export type AssetProfileResolutionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * Filter, which AssetProfileResolution to fetch.
     */
    where?: AssetProfileResolutionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AssetProfileResolutions to fetch.
     */
    orderBy?: AssetProfileResolutionOrderByWithRelationInput | AssetProfileResolutionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AssetProfileResolutions.
     */
    cursor?: AssetProfileResolutionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AssetProfileResolutions 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` AssetProfileResolutions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of AssetProfileResolutions.
     */
    distinct?: AssetProfileResolutionScalarFieldEnum | AssetProfileResolutionScalarFieldEnum[]
  }

  /**
   * AssetProfileResolution findFirstOrThrow
   */
  export type AssetProfileResolutionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * Filter, which AssetProfileResolution to fetch.
     */
    where?: AssetProfileResolutionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AssetProfileResolutions to fetch.
     */
    orderBy?: AssetProfileResolutionOrderByWithRelationInput | AssetProfileResolutionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AssetProfileResolutions.
     */
    cursor?: AssetProfileResolutionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AssetProfileResolutions 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` AssetProfileResolutions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of AssetProfileResolutions.
     */
    distinct?: AssetProfileResolutionScalarFieldEnum | AssetProfileResolutionScalarFieldEnum[]
  }

  /**
   * AssetProfileResolution findMany
   */
  export type AssetProfileResolutionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * Filter, which AssetProfileResolutions to fetch.
     */
    where?: AssetProfileResolutionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AssetProfileResolutions to fetch.
     */
    orderBy?: AssetProfileResolutionOrderByWithRelationInput | AssetProfileResolutionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing AssetProfileResolutions.
     */
    cursor?: AssetProfileResolutionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AssetProfileResolutions 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` AssetProfileResolutions.
     */
    skip?: number
    distinct?: AssetProfileResolutionScalarFieldEnum | AssetProfileResolutionScalarFieldEnum[]
  }

  /**
   * AssetProfileResolution create
   */
  export type AssetProfileResolutionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * The data needed to create a AssetProfileResolution.
     */
    data: XOR<AssetProfileResolutionCreateInput, AssetProfileResolutionUncheckedCreateInput>
  }

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

  /**
   * AssetProfileResolution createManyAndReturn
   */
  export type AssetProfileResolutionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * The data used to create many AssetProfileResolutions.
     */
    data: AssetProfileResolutionCreateManyInput | AssetProfileResolutionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * AssetProfileResolution update
   */
  export type AssetProfileResolutionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * The data needed to update a AssetProfileResolution.
     */
    data: XOR<AssetProfileResolutionUpdateInput, AssetProfileResolutionUncheckedUpdateInput>
    /**
     * Choose, which AssetProfileResolution to update.
     */
    where: AssetProfileResolutionWhereUniqueInput
  }

  /**
   * AssetProfileResolution updateMany
   */
  export type AssetProfileResolutionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AssetProfileResolutions.
     */
    data: XOR<AssetProfileResolutionUpdateManyMutationInput, AssetProfileResolutionUncheckedUpdateManyInput>
    /**
     * Filter which AssetProfileResolutions to update
     */
    where?: AssetProfileResolutionWhereInput
    /**
     * Limit how many AssetProfileResolutions to update.
     */
    limit?: number
  }

  /**
   * AssetProfileResolution updateManyAndReturn
   */
  export type AssetProfileResolutionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * The data used to update AssetProfileResolutions.
     */
    data: XOR<AssetProfileResolutionUpdateManyMutationInput, AssetProfileResolutionUncheckedUpdateManyInput>
    /**
     * Filter which AssetProfileResolutions to update
     */
    where?: AssetProfileResolutionWhereInput
    /**
     * Limit how many AssetProfileResolutions to update.
     */
    limit?: number
  }

  /**
   * AssetProfileResolution upsert
   */
  export type AssetProfileResolutionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * The filter to search for the AssetProfileResolution to update in case it exists.
     */
    where: AssetProfileResolutionWhereUniqueInput
    /**
     * In case the AssetProfileResolution found by the `where` argument doesn't exist, create a new AssetProfileResolution with this data.
     */
    create: XOR<AssetProfileResolutionCreateInput, AssetProfileResolutionUncheckedCreateInput>
    /**
     * In case the AssetProfileResolution was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AssetProfileResolutionUpdateInput, AssetProfileResolutionUncheckedUpdateInput>
  }

  /**
   * AssetProfileResolution delete
   */
  export type AssetProfileResolutionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
    /**
     * Filter which AssetProfileResolution to delete.
     */
    where: AssetProfileResolutionWhereUniqueInput
  }

  /**
   * AssetProfileResolution deleteMany
   */
  export type AssetProfileResolutionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AssetProfileResolutions to delete
     */
    where?: AssetProfileResolutionWhereInput
    /**
     * Limit how many AssetProfileResolutions to delete.
     */
    limit?: number
  }

  /**
   * AssetProfileResolution without action
   */
  export type AssetProfileResolutionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AssetProfileResolution
     */
    select?: AssetProfileResolutionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AssetProfileResolution
     */
    omit?: AssetProfileResolutionOmit<ExtArgs> | null
  }


  /**
   * Model AuthDevice
   */

  export type AggregateAuthDevice = {
    _count: AuthDeviceCountAggregateOutputType | null
    _avg: AuthDeviceAvgAggregateOutputType | null
    _sum: AuthDeviceSumAggregateOutputType | null
    _min: AuthDeviceMinAggregateOutputType | null
    _max: AuthDeviceMaxAggregateOutputType | null
  }

  export type AuthDeviceAvgAggregateOutputType = {
    counter: number | null
  }

  export type AuthDeviceSumAggregateOutputType = {
    counter: number | null
  }

  export type AuthDeviceMinAggregateOutputType = {
    createdAt: Date | null
    credentialId: Bytes | null
    credentialPublicKey: Bytes | null
    counter: number | null
    id: string | null
    updatedAt: Date | null
    userId: string | null
  }

  export type AuthDeviceMaxAggregateOutputType = {
    createdAt: Date | null
    credentialId: Bytes | null
    credentialPublicKey: Bytes | null
    counter: number | null
    id: string | null
    updatedAt: Date | null
    userId: string | null
  }

  export type AuthDeviceCountAggregateOutputType = {
    createdAt: number
    credentialId: number
    credentialPublicKey: number
    counter: number
    id: number
    updatedAt: number
    userId: number
    _all: number
  }


  export type AuthDeviceAvgAggregateInputType = {
    counter?: true
  }

  export type AuthDeviceSumAggregateInputType = {
    counter?: true
  }

  export type AuthDeviceMinAggregateInputType = {
    createdAt?: true
    credentialId?: true
    credentialPublicKey?: true
    counter?: true
    id?: true
    updatedAt?: true
    userId?: true
  }

  export type AuthDeviceMaxAggregateInputType = {
    createdAt?: true
    credentialId?: true
    credentialPublicKey?: true
    counter?: true
    id?: true
    updatedAt?: true
    userId?: true
  }

  export type AuthDeviceCountAggregateInputType = {
    createdAt?: true
    credentialId?: true
    credentialPublicKey?: true
    counter?: true
    id?: true
    updatedAt?: true
    userId?: true
    _all?: true
  }

  export type AuthDeviceAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AuthDevice to aggregate.
     */
    where?: AuthDeviceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AuthDevices to fetch.
     */
    orderBy?: AuthDeviceOrderByWithRelationInput | AuthDeviceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AuthDeviceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AuthDevices 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` AuthDevices.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned AuthDevices
    **/
    _count?: true | AuthDeviceCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AuthDeviceAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AuthDeviceSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AuthDeviceMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AuthDeviceMaxAggregateInputType
  }

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




  export type AuthDeviceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AuthDeviceWhereInput
    orderBy?: AuthDeviceOrderByWithAggregationInput | AuthDeviceOrderByWithAggregationInput[]
    by: AuthDeviceScalarFieldEnum[] | AuthDeviceScalarFieldEnum
    having?: AuthDeviceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AuthDeviceCountAggregateInputType | true
    _avg?: AuthDeviceAvgAggregateInputType
    _sum?: AuthDeviceSumAggregateInputType
    _min?: AuthDeviceMinAggregateInputType
    _max?: AuthDeviceMaxAggregateInputType
  }

  export type AuthDeviceGroupByOutputType = {
    createdAt: Date
    credentialId: Bytes
    credentialPublicKey: Bytes
    counter: number
    id: string
    updatedAt: Date
    userId: string
    _count: AuthDeviceCountAggregateOutputType | null
    _avg: AuthDeviceAvgAggregateOutputType | null
    _sum: AuthDeviceSumAggregateOutputType | null
    _min: AuthDeviceMinAggregateOutputType | null
    _max: AuthDeviceMaxAggregateOutputType | null
  }

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


  export type AuthDeviceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    credentialId?: boolean
    credentialPublicKey?: boolean
    counter?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["authDevice"]>

  export type AuthDeviceSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    credentialId?: boolean
    credentialPublicKey?: boolean
    counter?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["authDevice"]>

  export type AuthDeviceSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    credentialId?: boolean
    credentialPublicKey?: boolean
    counter?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["authDevice"]>

  export type AuthDeviceSelectScalar = {
    createdAt?: boolean
    credentialId?: boolean
    credentialPublicKey?: boolean
    counter?: boolean
    id?: boolean
    updatedAt?: boolean
    userId?: boolean
  }

  export type AuthDeviceOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"createdAt" | "credentialId" | "credentialPublicKey" | "counter" | "id" | "updatedAt" | "userId", ExtArgs["result"]["authDevice"]>
  export type AuthDeviceInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AuthDeviceIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type AuthDeviceIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $AuthDevicePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AuthDevice"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      createdAt: Date
      credentialId: Prisma.Bytes
      credentialPublicKey: Prisma.Bytes
      counter: number
      id: string
      updatedAt: Date
      userId: string
    }, ExtArgs["result"]["authDevice"]>
    composites: {}
  }

  type AuthDeviceGetPayload<S extends boolean | null | undefined | AuthDeviceDefaultArgs> = $Result.GetResult<Prisma.$AuthDevicePayload, S>

  type AuthDeviceCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<AuthDeviceFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: AuthDeviceCountAggregateInputType | true
    }

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

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

    /**
     * Find the first AuthDevice 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 {AuthDeviceFindFirstArgs} args - Arguments to find a AuthDevice
     * @example
     * // Get one AuthDevice
     * const authDevice = await prisma.authDevice.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends AuthDeviceFindFirstArgs>(args?: SelectSubset<T, AuthDeviceFindFirstArgs<ExtArgs>>): Prisma__AuthDeviceClient<$Result.GetResult<Prisma.$AuthDevicePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first AuthDevice 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 {AuthDeviceFindFirstOrThrowArgs} args - Arguments to find a AuthDevice
     * @example
     * // Get one AuthDevice
     * const authDevice = await prisma.authDevice.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends AuthDeviceFindFirstOrThrowArgs>(args?: SelectSubset<T, AuthDeviceFindFirstOrThrowArgs<ExtArgs>>): Prisma__AuthDeviceClient<$Result.GetResult<Prisma.$AuthDevicePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more AuthDevices 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 {AuthDeviceFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all AuthDevices
     * const authDevices = await prisma.authDevice.findMany()
     * 
     * // Get first 10 AuthDevices
     * const authDevices = await prisma.authDevice.findMany({ take: 10 })
     * 
     * // Only select the `createdAt`
     * const authDeviceWithCreatedAtOnly = await prisma.authDevice.findMany({ select: { createdAt: true } })
     * 
     */
    findMany<T extends AuthDeviceFindManyArgs>(args?: SelectSubset<T, AuthDeviceFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AuthDevicePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a AuthDevice.
     * @param {AuthDeviceCreateArgs} args - Arguments to create a AuthDevice.
     * @example
     * // Create one AuthDevice
     * const AuthDevice = await prisma.authDevice.create({
     *   data: {
     *     // ... data to create a AuthDevice
     *   }
     * })
     * 
     */
    create<T extends AuthDeviceCreateArgs>(args: SelectSubset<T, AuthDeviceCreateArgs<ExtArgs>>): Prisma__AuthDeviceClient<$Result.GetResult<Prisma.$AuthDevicePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many AuthDevices and returns the data saved in the database.
     * @param {AuthDeviceCreateManyAndReturnArgs} args - Arguments to create many AuthDevices.
     * @example
     * // Create many AuthDevices
     * const authDevice = await prisma.authDevice.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many AuthDevices and only return the `createdAt`
     * const authDeviceWithCreatedAtOnly = await prisma.authDevice.createManyAndReturn({
     *   select: { createdAt: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends AuthDeviceCreateManyAndReturnArgs>(args?: SelectSubset<T, AuthDeviceCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AuthDevicePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a AuthDevice.
     * @param {AuthDeviceDeleteArgs} args - Arguments to delete one AuthDevice.
     * @example
     * // Delete one AuthDevice
     * const AuthDevice = await prisma.authDevice.delete({
     *   where: {
     *     // ... filter to delete one AuthDevice
     *   }
     * })
     * 
     */
    delete<T extends AuthDeviceDeleteArgs>(args: SelectSubset<T, AuthDeviceDeleteArgs<ExtArgs>>): Prisma__AuthDeviceClient<$Result.GetResult<Prisma.$AuthDevicePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one AuthDevice.
     * @param {AuthDeviceUpdateArgs} args - Arguments to update one AuthDevice.
     * @example
     * // Update one AuthDevice
     * const authDevice = await prisma.authDevice.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends AuthDeviceUpdateArgs>(args: SelectSubset<T, AuthDeviceUpdateArgs<ExtArgs>>): Prisma__AuthDeviceClient<$Result.GetResult<Prisma.$AuthDevicePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more AuthDevices and returns the data updated in the database.
     * @param {AuthDeviceUpdateManyAndReturnArgs} args - Arguments to update many AuthDevices.
     * @example
     * // Update many AuthDevices
     * const authDevice = await prisma.authDevice.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more AuthDevices and only return the `createdAt`
     * const authDeviceWithCreatedAtOnly = await prisma.authDevice.updateManyAndReturn({
     *   select: { createdAt: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends AuthDeviceUpdateManyAndReturnArgs>(args: SelectSubset<T, AuthDeviceUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AuthDevicePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a AuthDevice.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AuthDeviceAggregateArgs} 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 AuthDeviceAggregateArgs>(args: Subset<T, AuthDeviceAggregateArgs>): Prisma.PrismaPromise<GetAuthDeviceAggregateType<T>>

    /**
     * Group by AuthDevice.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AuthDeviceGroupByArgs} 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 AuthDeviceGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AuthDeviceGroupByArgs['orderBy'] }
        : { orderBy?: AuthDeviceGroupByArgs['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, AuthDeviceGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAuthDeviceGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the AuthDevice model
   */
  readonly fields: AuthDeviceFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for AuthDevice.
   * 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__AuthDeviceClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 AuthDevice model
   */
  interface AuthDeviceFieldRefs {
    readonly createdAt: FieldRef<"AuthDevice", 'DateTime'>
    readonly credentialId: FieldRef<"AuthDevice", 'Bytes'>
    readonly credentialPublicKey: FieldRef<"AuthDevice", 'Bytes'>
    readonly counter: FieldRef<"AuthDevice", 'Int'>
    readonly id: FieldRef<"AuthDevice", 'String'>
    readonly updatedAt: FieldRef<"AuthDevice", 'DateTime'>
    readonly userId: FieldRef<"AuthDevice", 'String'>
  }
    

  // Custom InputTypes
  /**
   * AuthDevice findUnique
   */
  export type AuthDeviceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
    /**
     * Filter, which AuthDevice to fetch.
     */
    where: AuthDeviceWhereUniqueInput
  }

  /**
   * AuthDevice findUniqueOrThrow
   */
  export type AuthDeviceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
    /**
     * Filter, which AuthDevice to fetch.
     */
    where: AuthDeviceWhereUniqueInput
  }

  /**
   * AuthDevice findFirst
   */
  export type AuthDeviceFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
    /**
     * Filter, which AuthDevice to fetch.
     */
    where?: AuthDeviceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AuthDevices to fetch.
     */
    orderBy?: AuthDeviceOrderByWithRelationInput | AuthDeviceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AuthDevices.
     */
    cursor?: AuthDeviceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AuthDevices 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` AuthDevices.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of AuthDevices.
     */
    distinct?: AuthDeviceScalarFieldEnum | AuthDeviceScalarFieldEnum[]
  }

  /**
   * AuthDevice findFirstOrThrow
   */
  export type AuthDeviceFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
    /**
     * Filter, which AuthDevice to fetch.
     */
    where?: AuthDeviceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AuthDevices to fetch.
     */
    orderBy?: AuthDeviceOrderByWithRelationInput | AuthDeviceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for AuthDevices.
     */
    cursor?: AuthDeviceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AuthDevices 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` AuthDevices.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of AuthDevices.
     */
    distinct?: AuthDeviceScalarFieldEnum | AuthDeviceScalarFieldEnum[]
  }

  /**
   * AuthDevice findMany
   */
  export type AuthDeviceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
    /**
     * Filter, which AuthDevices to fetch.
     */
    where?: AuthDeviceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AuthDevices to fetch.
     */
    orderBy?: AuthDeviceOrderByWithRelationInput | AuthDeviceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing AuthDevices.
     */
    cursor?: AuthDeviceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AuthDevices 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` AuthDevices.
     */
    skip?: number
    distinct?: AuthDeviceScalarFieldEnum | AuthDeviceScalarFieldEnum[]
  }

  /**
   * AuthDevice create
   */
  export type AuthDeviceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
    /**
     * The data needed to create a AuthDevice.
     */
    data: XOR<AuthDeviceCreateInput, AuthDeviceUncheckedCreateInput>
  }

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

  /**
   * AuthDevice createManyAndReturn
   */
  export type AuthDeviceCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * The data used to create many AuthDevices.
     */
    data: AuthDeviceCreateManyInput | AuthDeviceCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * AuthDevice update
   */
  export type AuthDeviceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
    /**
     * The data needed to update a AuthDevice.
     */
    data: XOR<AuthDeviceUpdateInput, AuthDeviceUncheckedUpdateInput>
    /**
     * Choose, which AuthDevice to update.
     */
    where: AuthDeviceWhereUniqueInput
  }

  /**
   * AuthDevice updateMany
   */
  export type AuthDeviceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AuthDevices.
     */
    data: XOR<AuthDeviceUpdateManyMutationInput, AuthDeviceUncheckedUpdateManyInput>
    /**
     * Filter which AuthDevices to update
     */
    where?: AuthDeviceWhereInput
    /**
     * Limit how many AuthDevices to update.
     */
    limit?: number
  }

  /**
   * AuthDevice updateManyAndReturn
   */
  export type AuthDeviceUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * The data used to update AuthDevices.
     */
    data: XOR<AuthDeviceUpdateManyMutationInput, AuthDeviceUncheckedUpdateManyInput>
    /**
     * Filter which AuthDevices to update
     */
    where?: AuthDeviceWhereInput
    /**
     * Limit how many AuthDevices to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * AuthDevice upsert
   */
  export type AuthDeviceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
    /**
     * The filter to search for the AuthDevice to update in case it exists.
     */
    where: AuthDeviceWhereUniqueInput
    /**
     * In case the AuthDevice found by the `where` argument doesn't exist, create a new AuthDevice with this data.
     */
    create: XOR<AuthDeviceCreateInput, AuthDeviceUncheckedCreateInput>
    /**
     * In case the AuthDevice was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AuthDeviceUpdateInput, AuthDeviceUncheckedUpdateInput>
  }

  /**
   * AuthDevice delete
   */
  export type AuthDeviceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
    /**
     * Filter which AuthDevice to delete.
     */
    where: AuthDeviceWhereUniqueInput
  }

  /**
   * AuthDevice deleteMany
   */
  export type AuthDeviceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AuthDevices to delete
     */
    where?: AuthDeviceWhereInput
    /**
     * Limit how many AuthDevices to delete.
     */
    limit?: number
  }

  /**
   * AuthDevice without action
   */
  export type AuthDeviceDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
  }


  /**
   * Model MarketData
   */

  export type AggregateMarketData = {
    _count: MarketDataCountAggregateOutputType | null
    _avg: MarketDataAvgAggregateOutputType | null
    _sum: MarketDataSumAggregateOutputType | null
    _min: MarketDataMinAggregateOutputType | null
    _max: MarketDataMaxAggregateOutputType | null
  }

  export type MarketDataAvgAggregateOutputType = {
    marketPrice: number | null
  }

  export type MarketDataSumAggregateOutputType = {
    marketPrice: number | null
  }

  export type MarketDataMinAggregateOutputType = {
    createdAt: Date | null
    dataSource: $Enums.DataSource | null
    date: Date | null
    id: string | null
    marketPrice: number | null
    state: $Enums.MarketDataState | null
    symbol: string | null
  }

  export type MarketDataMaxAggregateOutputType = {
    createdAt: Date | null
    dataSource: $Enums.DataSource | null
    date: Date | null
    id: string | null
    marketPrice: number | null
    state: $Enums.MarketDataState | null
    symbol: string | null
  }

  export type MarketDataCountAggregateOutputType = {
    createdAt: number
    dataSource: number
    date: number
    id: number
    marketPrice: number
    state: number
    symbol: number
    _all: number
  }


  export type MarketDataAvgAggregateInputType = {
    marketPrice?: true
  }

  export type MarketDataSumAggregateInputType = {
    marketPrice?: true
  }

  export type MarketDataMinAggregateInputType = {
    createdAt?: true
    dataSource?: true
    date?: true
    id?: true
    marketPrice?: true
    state?: true
    symbol?: true
  }

  export type MarketDataMaxAggregateInputType = {
    createdAt?: true
    dataSource?: true
    date?: true
    id?: true
    marketPrice?: true
    state?: true
    symbol?: true
  }

  export type MarketDataCountAggregateInputType = {
    createdAt?: true
    dataSource?: true
    date?: true
    id?: true
    marketPrice?: true
    state?: true
    symbol?: true
    _all?: true
  }

  export type MarketDataAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MarketData to aggregate.
     */
    where?: MarketDataWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MarketData to fetch.
     */
    orderBy?: MarketDataOrderByWithRelationInput | MarketDataOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MarketDataWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MarketData 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` MarketData.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MarketData
    **/
    _count?: true | MarketDataCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MarketDataAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MarketDataSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MarketDataMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MarketDataMaxAggregateInputType
  }

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




  export type MarketDataGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MarketDataWhereInput
    orderBy?: MarketDataOrderByWithAggregationInput | MarketDataOrderByWithAggregationInput[]
    by: MarketDataScalarFieldEnum[] | MarketDataScalarFieldEnum
    having?: MarketDataScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MarketDataCountAggregateInputType | true
    _avg?: MarketDataAvgAggregateInputType
    _sum?: MarketDataSumAggregateInputType
    _min?: MarketDataMinAggregateInputType
    _max?: MarketDataMaxAggregateInputType
  }

  export type MarketDataGroupByOutputType = {
    createdAt: Date
    dataSource: $Enums.DataSource
    date: Date
    id: string
    marketPrice: number
    state: $Enums.MarketDataState
    symbol: string
    _count: MarketDataCountAggregateOutputType | null
    _avg: MarketDataAvgAggregateOutputType | null
    _sum: MarketDataSumAggregateOutputType | null
    _min: MarketDataMinAggregateOutputType | null
    _max: MarketDataMaxAggregateOutputType | null
  }

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


  export type MarketDataSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    dataSource?: boolean
    date?: boolean
    id?: boolean
    marketPrice?: boolean
    state?: boolean
    symbol?: boolean
  }, ExtArgs["result"]["marketData"]>

  export type MarketDataSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    dataSource?: boolean
    date?: boolean
    id?: boolean
    marketPrice?: boolean
    state?: boolean
    symbol?: boolean
  }, ExtArgs["result"]["marketData"]>

  export type MarketDataSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    dataSource?: boolean
    date?: boolean
    id?: boolean
    marketPrice?: boolean
    state?: boolean
    symbol?: boolean
  }, ExtArgs["result"]["marketData"]>

  export type MarketDataSelectScalar = {
    createdAt?: boolean
    dataSource?: boolean
    date?: boolean
    id?: boolean
    marketPrice?: boolean
    state?: boolean
    symbol?: boolean
  }

  export type MarketDataOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"createdAt" | "dataSource" | "date" | "id" | "marketPrice" | "state" | "symbol", ExtArgs["result"]["marketData"]>

  export type $MarketDataPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MarketData"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      createdAt: Date
      dataSource: $Enums.DataSource
      date: Date
      id: string
      marketPrice: number
      state: $Enums.MarketDataState
      symbol: string
    }, ExtArgs["result"]["marketData"]>
    composites: {}
  }

  type MarketDataGetPayload<S extends boolean | null | undefined | MarketDataDefaultArgs> = $Result.GetResult<Prisma.$MarketDataPayload, S>

  type MarketDataCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<MarketDataFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: MarketDataCountAggregateInputType | true
    }

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

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

    /**
     * Find the first MarketData 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 {MarketDataFindFirstArgs} args - Arguments to find a MarketData
     * @example
     * // Get one MarketData
     * const marketData = await prisma.marketData.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends MarketDataFindFirstArgs>(args?: SelectSubset<T, MarketDataFindFirstArgs<ExtArgs>>): Prisma__MarketDataClient<$Result.GetResult<Prisma.$MarketDataPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first MarketData 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 {MarketDataFindFirstOrThrowArgs} args - Arguments to find a MarketData
     * @example
     * // Get one MarketData
     * const marketData = await prisma.marketData.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends MarketDataFindFirstOrThrowArgs>(args?: SelectSubset<T, MarketDataFindFirstOrThrowArgs<ExtArgs>>): Prisma__MarketDataClient<$Result.GetResult<Prisma.$MarketDataPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more MarketData 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 {MarketDataFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all MarketData
     * const marketData = await prisma.marketData.findMany()
     * 
     * // Get first 10 MarketData
     * const marketData = await prisma.marketData.findMany({ take: 10 })
     * 
     * // Only select the `createdAt`
     * const marketDataWithCreatedAtOnly = await prisma.marketData.findMany({ select: { createdAt: true } })
     * 
     */
    findMany<T extends MarketDataFindManyArgs>(args?: SelectSubset<T, MarketDataFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MarketDataPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a MarketData.
     * @param {MarketDataCreateArgs} args - Arguments to create a MarketData.
     * @example
     * // Create one MarketData
     * const MarketData = await prisma.marketData.create({
     *   data: {
     *     // ... data to create a MarketData
     *   }
     * })
     * 
     */
    create<T extends MarketDataCreateArgs>(args: SelectSubset<T, MarketDataCreateArgs<ExtArgs>>): Prisma__MarketDataClient<$Result.GetResult<Prisma.$MarketDataPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many MarketData and returns the data saved in the database.
     * @param {MarketDataCreateManyAndReturnArgs} args - Arguments to create many MarketData.
     * @example
     * // Create many MarketData
     * const marketData = await prisma.marketData.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many MarketData and only return the `createdAt`
     * const marketDataWithCreatedAtOnly = await prisma.marketData.createManyAndReturn({
     *   select: { createdAt: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends MarketDataCreateManyAndReturnArgs>(args?: SelectSubset<T, MarketDataCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MarketDataPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a MarketData.
     * @param {MarketDataDeleteArgs} args - Arguments to delete one MarketData.
     * @example
     * // Delete one MarketData
     * const MarketData = await prisma.marketData.delete({
     *   where: {
     *     // ... filter to delete one MarketData
     *   }
     * })
     * 
     */
    delete<T extends MarketDataDeleteArgs>(args: SelectSubset<T, MarketDataDeleteArgs<ExtArgs>>): Prisma__MarketDataClient<$Result.GetResult<Prisma.$MarketDataPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one MarketData.
     * @param {MarketDataUpdateArgs} args - Arguments to update one MarketData.
     * @example
     * // Update one MarketData
     * const marketData = await prisma.marketData.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends MarketDataUpdateArgs>(args: SelectSubset<T, MarketDataUpdateArgs<ExtArgs>>): Prisma__MarketDataClient<$Result.GetResult<Prisma.$MarketDataPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more MarketData and returns the data updated in the database.
     * @param {MarketDataUpdateManyAndReturnArgs} args - Arguments to update many MarketData.
     * @example
     * // Update many MarketData
     * const marketData = await prisma.marketData.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more MarketData and only return the `createdAt`
     * const marketDataWithCreatedAtOnly = await prisma.marketData.updateManyAndReturn({
     *   select: { createdAt: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends MarketDataUpdateManyAndReturnArgs>(args: SelectSubset<T, MarketDataUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MarketDataPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a MarketData.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MarketDataAggregateArgs} 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 MarketDataAggregateArgs>(args: Subset<T, MarketDataAggregateArgs>): Prisma.PrismaPromise<GetMarketDataAggregateType<T>>

    /**
     * Group by MarketData.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MarketDataGroupByArgs} 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 MarketDataGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: MarketDataGroupByArgs['orderBy'] }
        : { orderBy?: MarketDataGroupByArgs['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, MarketDataGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMarketDataGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the MarketData model
   */
  readonly fields: MarketDataFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for MarketData.
   * 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__MarketDataClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> 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 MarketData model
   */
  interface MarketDataFieldRefs {
    readonly createdAt: FieldRef<"MarketData", 'DateTime'>
    readonly dataSource: FieldRef<"MarketData", 'DataSource'>
    readonly date: FieldRef<"MarketData", 'DateTime'>
    readonly id: FieldRef<"MarketData", 'String'>
    readonly marketPrice: FieldRef<"MarketData", 'Float'>
    readonly state: FieldRef<"MarketData", 'MarketDataState'>
    readonly symbol: FieldRef<"MarketData", 'String'>
  }
    

  // Custom InputTypes
  /**
   * MarketData findUnique
   */
  export type MarketDataFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * Filter, which MarketData to fetch.
     */
    where: MarketDataWhereUniqueInput
  }

  /**
   * MarketData findUniqueOrThrow
   */
  export type MarketDataFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * Filter, which MarketData to fetch.
     */
    where: MarketDataWhereUniqueInput
  }

  /**
   * MarketData findFirst
   */
  export type MarketDataFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * Filter, which MarketData to fetch.
     */
    where?: MarketDataWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MarketData to fetch.
     */
    orderBy?: MarketDataOrderByWithRelationInput | MarketDataOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MarketData.
     */
    cursor?: MarketDataWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MarketData 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` MarketData.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MarketData.
     */
    distinct?: MarketDataScalarFieldEnum | MarketDataScalarFieldEnum[]
  }

  /**
   * MarketData findFirstOrThrow
   */
  export type MarketDataFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * Filter, which MarketData to fetch.
     */
    where?: MarketDataWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MarketData to fetch.
     */
    orderBy?: MarketDataOrderByWithRelationInput | MarketDataOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MarketData.
     */
    cursor?: MarketDataWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MarketData 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` MarketData.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MarketData.
     */
    distinct?: MarketDataScalarFieldEnum | MarketDataScalarFieldEnum[]
  }

  /**
   * MarketData findMany
   */
  export type MarketDataFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * Filter, which MarketData to fetch.
     */
    where?: MarketDataWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MarketData to fetch.
     */
    orderBy?: MarketDataOrderByWithRelationInput | MarketDataOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing MarketData.
     */
    cursor?: MarketDataWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MarketData 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` MarketData.
     */
    skip?: number
    distinct?: MarketDataScalarFieldEnum | MarketDataScalarFieldEnum[]
  }

  /**
   * MarketData create
   */
  export type MarketDataCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * The data needed to create a MarketData.
     */
    data: XOR<MarketDataCreateInput, MarketDataUncheckedCreateInput>
  }

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

  /**
   * MarketData createManyAndReturn
   */
  export type MarketDataCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * The data used to create many MarketData.
     */
    data: MarketDataCreateManyInput | MarketDataCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * MarketData update
   */
  export type MarketDataUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * The data needed to update a MarketData.
     */
    data: XOR<MarketDataUpdateInput, MarketDataUncheckedUpdateInput>
    /**
     * Choose, which MarketData to update.
     */
    where: MarketDataWhereUniqueInput
  }

  /**
   * MarketData updateMany
   */
  export type MarketDataUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MarketData.
     */
    data: XOR<MarketDataUpdateManyMutationInput, MarketDataUncheckedUpdateManyInput>
    /**
     * Filter which MarketData to update
     */
    where?: MarketDataWhereInput
    /**
     * Limit how many MarketData to update.
     */
    limit?: number
  }

  /**
   * MarketData updateManyAndReturn
   */
  export type MarketDataUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * The data used to update MarketData.
     */
    data: XOR<MarketDataUpdateManyMutationInput, MarketDataUncheckedUpdateManyInput>
    /**
     * Filter which MarketData to update
     */
    where?: MarketDataWhereInput
    /**
     * Limit how many MarketData to update.
     */
    limit?: number
  }

  /**
   * MarketData upsert
   */
  export type MarketDataUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * The filter to search for the MarketData to update in case it exists.
     */
    where: MarketDataWhereUniqueInput
    /**
     * In case the MarketData found by the `where` argument doesn't exist, create a new MarketData with this data.
     */
    create: XOR<MarketDataCreateInput, MarketDataUncheckedCreateInput>
    /**
     * In case the MarketData was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MarketDataUpdateInput, MarketDataUncheckedUpdateInput>
  }

  /**
   * MarketData delete
   */
  export type MarketDataDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
    /**
     * Filter which MarketData to delete.
     */
    where: MarketDataWhereUniqueInput
  }

  /**
   * MarketData deleteMany
   */
  export type MarketDataDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MarketData to delete
     */
    where?: MarketDataWhereInput
    /**
     * Limit how many MarketData to delete.
     */
    limit?: number
  }

  /**
   * MarketData without action
   */
  export type MarketDataDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MarketData
     */
    select?: MarketDataSelect<ExtArgs> | null
    /**
     * Omit specific fields from the MarketData
     */
    omit?: MarketDataOmit<ExtArgs> | null
  }


  /**
   * Model Order
   */

  export type AggregateOrder = {
    _count: OrderCountAggregateOutputType | null
    _avg: OrderAvgAggregateOutputType | null
    _sum: OrderSumAggregateOutputType | null
    _min: OrderMinAggregateOutputType | null
    _max: OrderMaxAggregateOutputType | null
  }

  export type OrderAvgAggregateOutputType = {
    fee: number | null
    quantity: number | null
    unitPrice: number | null
  }

  export type OrderSumAggregateOutputType = {
    fee: number | null
    quantity: number | null
    unitPrice: number | null
  }

  export type OrderMinAggregateOutputType = {
    accountId: string | null
    accountUserId: string | null
    comment: string | null
    createdAt: Date | null
    currency: string | null
    date: Date | null
    fee: number | null
    id: string | null
    isDraft: boolean | null
    quantity: number | null
    symbolProfileId: string | null
    type: $Enums.Type | null
    unitPrice: number | null
    updatedAt: Date | null
    userId: string | null
  }

  export type OrderMaxAggregateOutputType = {
    accountId: string | null
    accountUserId: string | null
    comment: string | null
    createdAt: Date | null
    currency: string | null
    date: Date | null
    fee: number | null
    id: string | null
    isDraft: boolean | null
    quantity: number | null
    symbolProfileId: string | null
    type: $Enums.Type | null
    unitPrice: number | null
    updatedAt: Date | null
    userId: string | null
  }

  export type OrderCountAggregateOutputType = {
    accountId: number
    accountUserId: number
    comment: number
    createdAt: number
    currency: number
    date: number
    fee: number
    id: number
    isDraft: number
    quantity: number
    symbolProfileId: number
    type: number
    unitPrice: number
    updatedAt: number
    userId: number
    _all: number
  }


  export type OrderAvgAggregateInputType = {
    fee?: true
    quantity?: true
    unitPrice?: true
  }

  export type OrderSumAggregateInputType = {
    fee?: true
    quantity?: true
    unitPrice?: true
  }

  export type OrderMinAggregateInputType = {
    accountId?: true
    accountUserId?: true
    comment?: true
    createdAt?: true
    currency?: true
    date?: true
    fee?: true
    id?: true
    isDraft?: true
    quantity?: true
    symbolProfileId?: true
    type?: true
    unitPrice?: true
    updatedAt?: true
    userId?: true
  }

  export type OrderMaxAggregateInputType = {
    accountId?: true
    accountUserId?: true
    comment?: true
    createdAt?: true
    currency?: true
    date?: true
    fee?: true
    id?: true
    isDraft?: true
    quantity?: true
    symbolProfileId?: true
    type?: true
    unitPrice?: true
    updatedAt?: true
    userId?: true
  }

  export type OrderCountAggregateInputType = {
    accountId?: true
    accountUserId?: true
    comment?: true
    createdAt?: true
    currency?: true
    date?: true
    fee?: true
    id?: true
    isDraft?: true
    quantity?: true
    symbolProfileId?: true
    type?: true
    unitPrice?: true
    updatedAt?: true
    userId?: true
    _all?: true
  }

  export type OrderAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Order to aggregate.
     */
    where?: OrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Orders to fetch.
     */
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: OrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Orders 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` Orders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Orders
    **/
    _count?: true | OrderCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: OrderAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: OrderSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: OrderMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: OrderMaxAggregateInputType
  }

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




  export type OrderGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderWhereInput
    orderBy?: OrderOrderByWithAggregationInput | OrderOrderByWithAggregationInput[]
    by: OrderScalarFieldEnum[] | OrderScalarFieldEnum
    having?: OrderScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OrderCountAggregateInputType | true
    _avg?: OrderAvgAggregateInputType
    _sum?: OrderSumAggregateInputType
    _min?: OrderMinAggregateInputType
    _max?: OrderMaxAggregateInputType
  }

  export type OrderGroupByOutputType = {
    accountId: string | null
    accountUserId: string | null
    comment: string | null
    createdAt: Date
    currency: string | null
    date: Date
    fee: number
    id: string
    isDraft: boolean
    quantity: number
    symbolProfileId: string
    type: $Enums.Type
    unitPrice: number
    updatedAt: Date
    userId: string
    _count: OrderCountAggregateOutputType | null
    _avg: OrderAvgAggregateOutputType | null
    _sum: OrderSumAggregateOutputType | null
    _min: OrderMinAggregateOutputType | null
    _max: OrderMaxAggregateOutputType | null
  }

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


  export type OrderSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    accountId?: boolean
    accountUserId?: boolean
    comment?: boolean
    createdAt?: boolean
    currency?: boolean
    date?: boolean
    fee?: boolean
    id?: boolean
    isDraft?: boolean
    quantity?: boolean
    symbolProfileId?: boolean
    type?: boolean
    unitPrice?: boolean
    updatedAt?: boolean
    userId?: boolean
    account?: boolean | Order$accountArgs<ExtArgs>
    tags?: boolean | Order$tagsArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
    _count?: boolean | OrderCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["order"]>

  export type OrderSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    accountId?: boolean
    accountUserId?: boolean
    comment?: boolean
    createdAt?: boolean
    currency?: boolean
    date?: boolean
    fee?: boolean
    id?: boolean
    isDraft?: boolean
    quantity?: boolean
    symbolProfileId?: boolean
    type?: boolean
    unitPrice?: boolean
    updatedAt?: boolean
    userId?: boolean
    account?: boolean | Order$accountArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["order"]>

  export type OrderSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    accountId?: boolean
    accountUserId?: boolean
    comment?: boolean
    createdAt?: boolean
    currency?: boolean
    date?: boolean
    fee?: boolean
    id?: boolean
    isDraft?: boolean
    quantity?: boolean
    symbolProfileId?: boolean
    type?: boolean
    unitPrice?: boolean
    updatedAt?: boolean
    userId?: boolean
    account?: boolean | Order$accountArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["order"]>

  export type OrderSelectScalar = {
    accountId?: boolean
    accountUserId?: boolean
    comment?: boolean
    createdAt?: boolean
    currency?: boolean
    date?: boolean
    fee?: boolean
    id?: boolean
    isDraft?: boolean
    quantity?: boolean
    symbolProfileId?: boolean
    type?: boolean
    unitPrice?: boolean
    updatedAt?: boolean
    userId?: boolean
  }

  export type OrderOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"accountId" | "accountUserId" | "comment" | "createdAt" | "currency" | "date" | "fee" | "id" | "isDraft" | "quantity" | "symbolProfileId" | "type" | "unitPrice" | "updatedAt" | "userId", ExtArgs["result"]["order"]>
  export type OrderInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    account?: boolean | Order$accountArgs<ExtArgs>
    tags?: boolean | Order$tagsArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
    _count?: boolean | OrderCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type OrderIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    account?: boolean | Order$accountArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
  }
  export type OrderIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    account?: boolean | Order$accountArgs<ExtArgs>
    user?: boolean | UserDefaultArgs<ExtArgs>
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
  }

  export type $OrderPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Order"
    objects: {
      account: Prisma.$AccountPayload<ExtArgs> | null
      tags: Prisma.$TagPayload<ExtArgs>[]
      user: Prisma.$UserPayload<ExtArgs>
      SymbolProfile: Prisma.$SymbolProfilePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      accountId: string | null
      accountUserId: string | null
      comment: string | null
      createdAt: Date
      currency: string | null
      date: Date
      fee: number
      id: string
      isDraft: boolean
      quantity: number
      symbolProfileId: string
      type: $Enums.Type
      unitPrice: number
      updatedAt: Date
      userId: string
    }, ExtArgs["result"]["order"]>
    composites: {}
  }

  type OrderGetPayload<S extends boolean | null | undefined | OrderDefaultArgs> = $Result.GetResult<Prisma.$OrderPayload, S>

  type OrderCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<OrderFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: OrderCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Order 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 {OrderFindFirstArgs} args - Arguments to find a Order
     * @example
     * // Get one Order
     * const order = await prisma.order.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends OrderFindFirstArgs>(args?: SelectSubset<T, OrderFindFirstArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Order 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 {OrderFindFirstOrThrowArgs} args - Arguments to find a Order
     * @example
     * // Get one Order
     * const order = await prisma.order.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends OrderFindFirstOrThrowArgs>(args?: SelectSubset<T, OrderFindFirstOrThrowArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Orders 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 {OrderFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Orders
     * const orders = await prisma.order.findMany()
     * 
     * // Get first 10 Orders
     * const orders = await prisma.order.findMany({ take: 10 })
     * 
     * // Only select the `accountId`
     * const orderWithAccountIdOnly = await prisma.order.findMany({ select: { accountId: true } })
     * 
     */
    findMany<T extends OrderFindManyArgs>(args?: SelectSubset<T, OrderFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Order.
     * @param {OrderCreateArgs} args - Arguments to create a Order.
     * @example
     * // Create one Order
     * const Order = await prisma.order.create({
     *   data: {
     *     // ... data to create a Order
     *   }
     * })
     * 
     */
    create<T extends OrderCreateArgs>(args: SelectSubset<T, OrderCreateArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Orders and returns the data saved in the database.
     * @param {OrderCreateManyAndReturnArgs} args - Arguments to create many Orders.
     * @example
     * // Create many Orders
     * const order = await prisma.order.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Orders and only return the `accountId`
     * const orderWithAccountIdOnly = await prisma.order.createManyAndReturn({
     *   select: { accountId: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends OrderCreateManyAndReturnArgs>(args?: SelectSubset<T, OrderCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Order.
     * @param {OrderDeleteArgs} args - Arguments to delete one Order.
     * @example
     * // Delete one Order
     * const Order = await prisma.order.delete({
     *   where: {
     *     // ... filter to delete one Order
     *   }
     * })
     * 
     */
    delete<T extends OrderDeleteArgs>(args: SelectSubset<T, OrderDeleteArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Order.
     * @param {OrderUpdateArgs} args - Arguments to update one Order.
     * @example
     * // Update one Order
     * const order = await prisma.order.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends OrderUpdateArgs>(args: SelectSubset<T, OrderUpdateArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more Orders and returns the data updated in the database.
     * @param {OrderUpdateManyAndReturnArgs} args - Arguments to update many Orders.
     * @example
     * // Update many Orders
     * const order = await prisma.order.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Orders and only return the `accountId`
     * const orderWithAccountIdOnly = await prisma.order.updateManyAndReturn({
     *   select: { accountId: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends OrderUpdateManyAndReturnArgs>(args: SelectSubset<T, OrderUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a Order.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {OrderAggregateArgs} 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 OrderAggregateArgs>(args: Subset<T, OrderAggregateArgs>): Prisma.PrismaPromise<GetOrderAggregateType<T>>

    /**
     * Group by Order.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {OrderGroupByArgs} 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 OrderGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: OrderGroupByArgs['orderBy'] }
        : { orderBy?: OrderGroupByArgs['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, OrderGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetOrderGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Order model
   */
  readonly fields: OrderFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Order.
   * 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__OrderClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    account<T extends Order$accountArgs<ExtArgs> = {}>(args?: Subset<T, Order$accountArgs<ExtArgs>>): Prisma__AccountClient<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    tags<T extends Order$tagsArgs<ExtArgs> = {}>(args?: Subset<T, Order$tagsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    SymbolProfile<T extends SymbolProfileDefaultArgs<ExtArgs> = {}>(args?: Subset<T, SymbolProfileDefaultArgs<ExtArgs>>): Prisma__SymbolProfileClient<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 Order model
   */
  interface OrderFieldRefs {
    readonly accountId: FieldRef<"Order", 'String'>
    readonly accountUserId: FieldRef<"Order", 'String'>
    readonly comment: FieldRef<"Order", 'String'>
    readonly createdAt: FieldRef<"Order", 'DateTime'>
    readonly currency: FieldRef<"Order", 'String'>
    readonly date: FieldRef<"Order", 'DateTime'>
    readonly fee: FieldRef<"Order", 'Float'>
    readonly id: FieldRef<"Order", 'String'>
    readonly isDraft: FieldRef<"Order", 'Boolean'>
    readonly quantity: FieldRef<"Order", 'Float'>
    readonly symbolProfileId: FieldRef<"Order", 'String'>
    readonly type: FieldRef<"Order", 'Type'>
    readonly unitPrice: FieldRef<"Order", 'Float'>
    readonly updatedAt: FieldRef<"Order", 'DateTime'>
    readonly userId: FieldRef<"Order", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Order findUnique
   */
  export type OrderFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * Filter, which Order to fetch.
     */
    where: OrderWhereUniqueInput
  }

  /**
   * Order findUniqueOrThrow
   */
  export type OrderFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * Filter, which Order to fetch.
     */
    where: OrderWhereUniqueInput
  }

  /**
   * Order findFirst
   */
  export type OrderFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * Filter, which Order to fetch.
     */
    where?: OrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Orders to fetch.
     */
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Orders.
     */
    cursor?: OrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Orders 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` Orders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Orders.
     */
    distinct?: OrderScalarFieldEnum | OrderScalarFieldEnum[]
  }

  /**
   * Order findFirstOrThrow
   */
  export type OrderFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * Filter, which Order to fetch.
     */
    where?: OrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Orders to fetch.
     */
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Orders.
     */
    cursor?: OrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Orders 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` Orders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Orders.
     */
    distinct?: OrderScalarFieldEnum | OrderScalarFieldEnum[]
  }

  /**
   * Order findMany
   */
  export type OrderFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * Filter, which Orders to fetch.
     */
    where?: OrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Orders to fetch.
     */
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Orders.
     */
    cursor?: OrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Orders 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` Orders.
     */
    skip?: number
    distinct?: OrderScalarFieldEnum | OrderScalarFieldEnum[]
  }

  /**
   * Order create
   */
  export type OrderCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * The data needed to create a Order.
     */
    data: XOR<OrderCreateInput, OrderUncheckedCreateInput>
  }

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

  /**
   * Order createManyAndReturn
   */
  export type OrderCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * The data used to create many Orders.
     */
    data: OrderCreateManyInput | OrderCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Order update
   */
  export type OrderUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * The data needed to update a Order.
     */
    data: XOR<OrderUpdateInput, OrderUncheckedUpdateInput>
    /**
     * Choose, which Order to update.
     */
    where: OrderWhereUniqueInput
  }

  /**
   * Order updateMany
   */
  export type OrderUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Orders.
     */
    data: XOR<OrderUpdateManyMutationInput, OrderUncheckedUpdateManyInput>
    /**
     * Filter which Orders to update
     */
    where?: OrderWhereInput
    /**
     * Limit how many Orders to update.
     */
    limit?: number
  }

  /**
   * Order updateManyAndReturn
   */
  export type OrderUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * The data used to update Orders.
     */
    data: XOR<OrderUpdateManyMutationInput, OrderUncheckedUpdateManyInput>
    /**
     * Filter which Orders to update
     */
    where?: OrderWhereInput
    /**
     * Limit how many Orders to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Order upsert
   */
  export type OrderUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * The filter to search for the Order to update in case it exists.
     */
    where: OrderWhereUniqueInput
    /**
     * In case the Order found by the `where` argument doesn't exist, create a new Order with this data.
     */
    create: XOR<OrderCreateInput, OrderUncheckedCreateInput>
    /**
     * In case the Order was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OrderUpdateInput, OrderUncheckedUpdateInput>
  }

  /**
   * Order delete
   */
  export type OrderDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * Filter which Order to delete.
     */
    where: OrderWhereUniqueInput
  }

  /**
   * Order deleteMany
   */
  export type OrderDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Orders to delete
     */
    where?: OrderWhereInput
    /**
     * Limit how many Orders to delete.
     */
    limit?: number
  }

  /**
   * Order.account
   */
  export type Order$accountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    where?: AccountWhereInput
  }

  /**
   * Order.tags
   */
  export type Order$tagsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    where?: TagWhereInput
    orderBy?: TagOrderByWithRelationInput | TagOrderByWithRelationInput[]
    cursor?: TagWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TagScalarFieldEnum | TagScalarFieldEnum[]
  }

  /**
   * Order without action
   */
  export type OrderDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
  }


  /**
   * Model Platform
   */

  export type AggregatePlatform = {
    _count: PlatformCountAggregateOutputType | null
    _min: PlatformMinAggregateOutputType | null
    _max: PlatformMaxAggregateOutputType | null
  }

  export type PlatformMinAggregateOutputType = {
    id: string | null
    name: string | null
    url: string | null
  }

  export type PlatformMaxAggregateOutputType = {
    id: string | null
    name: string | null
    url: string | null
  }

  export type PlatformCountAggregateOutputType = {
    id: number
    name: number
    url: number
    _all: number
  }


  export type PlatformMinAggregateInputType = {
    id?: true
    name?: true
    url?: true
  }

  export type PlatformMaxAggregateInputType = {
    id?: true
    name?: true
    url?: true
  }

  export type PlatformCountAggregateInputType = {
    id?: true
    name?: true
    url?: true
    _all?: true
  }

  export type PlatformAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Platform to aggregate.
     */
    where?: PlatformWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Platforms to fetch.
     */
    orderBy?: PlatformOrderByWithRelationInput | PlatformOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PlatformWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Platforms 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` Platforms.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Platforms
    **/
    _count?: true | PlatformCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PlatformMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PlatformMaxAggregateInputType
  }

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




  export type PlatformGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PlatformWhereInput
    orderBy?: PlatformOrderByWithAggregationInput | PlatformOrderByWithAggregationInput[]
    by: PlatformScalarFieldEnum[] | PlatformScalarFieldEnum
    having?: PlatformScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PlatformCountAggregateInputType | true
    _min?: PlatformMinAggregateInputType
    _max?: PlatformMaxAggregateInputType
  }

  export type PlatformGroupByOutputType = {
    id: string
    name: string | null
    url: string
    _count: PlatformCountAggregateOutputType | null
    _min: PlatformMinAggregateOutputType | null
    _max: PlatformMaxAggregateOutputType | null
  }

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


  export type PlatformSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    url?: boolean
    accounts?: boolean | Platform$accountsArgs<ExtArgs>
    _count?: boolean | PlatformCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["platform"]>

  export type PlatformSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    url?: boolean
  }, ExtArgs["result"]["platform"]>

  export type PlatformSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    url?: boolean
  }, ExtArgs["result"]["platform"]>

  export type PlatformSelectScalar = {
    id?: boolean
    name?: boolean
    url?: boolean
  }

  export type PlatformOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "url", ExtArgs["result"]["platform"]>
  export type PlatformInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    accounts?: boolean | Platform$accountsArgs<ExtArgs>
    _count?: boolean | PlatformCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type PlatformIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type PlatformIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $PlatformPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Platform"
    objects: {
      accounts: Prisma.$AccountPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string | null
      url: string
    }, ExtArgs["result"]["platform"]>
    composites: {}
  }

  type PlatformGetPayload<S extends boolean | null | undefined | PlatformDefaultArgs> = $Result.GetResult<Prisma.$PlatformPayload, S>

  type PlatformCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<PlatformFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: PlatformCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Platform 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 {PlatformFindFirstArgs} args - Arguments to find a Platform
     * @example
     * // Get one Platform
     * const platform = await prisma.platform.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends PlatformFindFirstArgs>(args?: SelectSubset<T, PlatformFindFirstArgs<ExtArgs>>): Prisma__PlatformClient<$Result.GetResult<Prisma.$PlatformPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Platform 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 {PlatformFindFirstOrThrowArgs} args - Arguments to find a Platform
     * @example
     * // Get one Platform
     * const platform = await prisma.platform.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends PlatformFindFirstOrThrowArgs>(args?: SelectSubset<T, PlatformFindFirstOrThrowArgs<ExtArgs>>): Prisma__PlatformClient<$Result.GetResult<Prisma.$PlatformPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Platforms 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 {PlatformFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Platforms
     * const platforms = await prisma.platform.findMany()
     * 
     * // Get first 10 Platforms
     * const platforms = await prisma.platform.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const platformWithIdOnly = await prisma.platform.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends PlatformFindManyArgs>(args?: SelectSubset<T, PlatformFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlatformPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Platform.
     * @param {PlatformCreateArgs} args - Arguments to create a Platform.
     * @example
     * // Create one Platform
     * const Platform = await prisma.platform.create({
     *   data: {
     *     // ... data to create a Platform
     *   }
     * })
     * 
     */
    create<T extends PlatformCreateArgs>(args: SelectSubset<T, PlatformCreateArgs<ExtArgs>>): Prisma__PlatformClient<$Result.GetResult<Prisma.$PlatformPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Platforms and returns the data saved in the database.
     * @param {PlatformCreateManyAndReturnArgs} args - Arguments to create many Platforms.
     * @example
     * // Create many Platforms
     * const platform = await prisma.platform.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Platforms and only return the `id`
     * const platformWithIdOnly = await prisma.platform.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends PlatformCreateManyAndReturnArgs>(args?: SelectSubset<T, PlatformCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlatformPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Platform.
     * @param {PlatformDeleteArgs} args - Arguments to delete one Platform.
     * @example
     * // Delete one Platform
     * const Platform = await prisma.platform.delete({
     *   where: {
     *     // ... filter to delete one Platform
     *   }
     * })
     * 
     */
    delete<T extends PlatformDeleteArgs>(args: SelectSubset<T, PlatformDeleteArgs<ExtArgs>>): Prisma__PlatformClient<$Result.GetResult<Prisma.$PlatformPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Platform.
     * @param {PlatformUpdateArgs} args - Arguments to update one Platform.
     * @example
     * // Update one Platform
     * const platform = await prisma.platform.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PlatformUpdateArgs>(args: SelectSubset<T, PlatformUpdateArgs<ExtArgs>>): Prisma__PlatformClient<$Result.GetResult<Prisma.$PlatformPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more Platforms and returns the data updated in the database.
     * @param {PlatformUpdateManyAndReturnArgs} args - Arguments to update many Platforms.
     * @example
     * // Update many Platforms
     * const platform = await prisma.platform.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Platforms and only return the `id`
     * const platformWithIdOnly = await prisma.platform.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PlatformUpdateManyAndReturnArgs>(args: SelectSubset<T, PlatformUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PlatformPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a Platform.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PlatformAggregateArgs} 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 PlatformAggregateArgs>(args: Subset<T, PlatformAggregateArgs>): Prisma.PrismaPromise<GetPlatformAggregateType<T>>

    /**
     * Group by Platform.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PlatformGroupByArgs} 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 PlatformGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: PlatformGroupByArgs['orderBy'] }
        : { orderBy?: PlatformGroupByArgs['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, PlatformGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPlatformGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Platform model
   */
  readonly fields: PlatformFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Platform.
   * 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__PlatformClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    accounts<T extends Platform$accountsArgs<ExtArgs> = {}>(args?: Subset<T, Platform$accountsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 Platform model
   */
  interface PlatformFieldRefs {
    readonly id: FieldRef<"Platform", 'String'>
    readonly name: FieldRef<"Platform", 'String'>
    readonly url: FieldRef<"Platform", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Platform findUnique
   */
  export type PlatformFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
    /**
     * Filter, which Platform to fetch.
     */
    where: PlatformWhereUniqueInput
  }

  /**
   * Platform findUniqueOrThrow
   */
  export type PlatformFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
    /**
     * Filter, which Platform to fetch.
     */
    where: PlatformWhereUniqueInput
  }

  /**
   * Platform findFirst
   */
  export type PlatformFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
    /**
     * Filter, which Platform to fetch.
     */
    where?: PlatformWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Platforms to fetch.
     */
    orderBy?: PlatformOrderByWithRelationInput | PlatformOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Platforms.
     */
    cursor?: PlatformWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Platforms 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` Platforms.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Platforms.
     */
    distinct?: PlatformScalarFieldEnum | PlatformScalarFieldEnum[]
  }

  /**
   * Platform findFirstOrThrow
   */
  export type PlatformFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
    /**
     * Filter, which Platform to fetch.
     */
    where?: PlatformWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Platforms to fetch.
     */
    orderBy?: PlatformOrderByWithRelationInput | PlatformOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Platforms.
     */
    cursor?: PlatformWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Platforms 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` Platforms.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Platforms.
     */
    distinct?: PlatformScalarFieldEnum | PlatformScalarFieldEnum[]
  }

  /**
   * Platform findMany
   */
  export type PlatformFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
    /**
     * Filter, which Platforms to fetch.
     */
    where?: PlatformWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Platforms to fetch.
     */
    orderBy?: PlatformOrderByWithRelationInput | PlatformOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Platforms.
     */
    cursor?: PlatformWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Platforms 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` Platforms.
     */
    skip?: number
    distinct?: PlatformScalarFieldEnum | PlatformScalarFieldEnum[]
  }

  /**
   * Platform create
   */
  export type PlatformCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
    /**
     * The data needed to create a Platform.
     */
    data: XOR<PlatformCreateInput, PlatformUncheckedCreateInput>
  }

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

  /**
   * Platform createManyAndReturn
   */
  export type PlatformCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * The data used to create many Platforms.
     */
    data: PlatformCreateManyInput | PlatformCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Platform update
   */
  export type PlatformUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
    /**
     * The data needed to update a Platform.
     */
    data: XOR<PlatformUpdateInput, PlatformUncheckedUpdateInput>
    /**
     * Choose, which Platform to update.
     */
    where: PlatformWhereUniqueInput
  }

  /**
   * Platform updateMany
   */
  export type PlatformUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Platforms.
     */
    data: XOR<PlatformUpdateManyMutationInput, PlatformUncheckedUpdateManyInput>
    /**
     * Filter which Platforms to update
     */
    where?: PlatformWhereInput
    /**
     * Limit how many Platforms to update.
     */
    limit?: number
  }

  /**
   * Platform updateManyAndReturn
   */
  export type PlatformUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * The data used to update Platforms.
     */
    data: XOR<PlatformUpdateManyMutationInput, PlatformUncheckedUpdateManyInput>
    /**
     * Filter which Platforms to update
     */
    where?: PlatformWhereInput
    /**
     * Limit how many Platforms to update.
     */
    limit?: number
  }

  /**
   * Platform upsert
   */
  export type PlatformUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
    /**
     * The filter to search for the Platform to update in case it exists.
     */
    where: PlatformWhereUniqueInput
    /**
     * In case the Platform found by the `where` argument doesn't exist, create a new Platform with this data.
     */
    create: XOR<PlatformCreateInput, PlatformUncheckedCreateInput>
    /**
     * In case the Platform was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PlatformUpdateInput, PlatformUncheckedUpdateInput>
  }

  /**
   * Platform delete
   */
  export type PlatformDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
    /**
     * Filter which Platform to delete.
     */
    where: PlatformWhereUniqueInput
  }

  /**
   * Platform deleteMany
   */
  export type PlatformDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Platforms to delete
     */
    where?: PlatformWhereInput
    /**
     * Limit how many Platforms to delete.
     */
    limit?: number
  }

  /**
   * Platform.accounts
   */
  export type Platform$accountsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    where?: AccountWhereInput
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    cursor?: AccountWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

  /**
   * Platform without action
   */
  export type PlatformDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Platform
     */
    select?: PlatformSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Platform
     */
    omit?: PlatformOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PlatformInclude<ExtArgs> | null
  }


  /**
   * Model Property
   */

  export type AggregateProperty = {
    _count: PropertyCountAggregateOutputType | null
    _min: PropertyMinAggregateOutputType | null
    _max: PropertyMaxAggregateOutputType | null
  }

  export type PropertyMinAggregateOutputType = {
    key: string | null
    value: string | null
  }

  export type PropertyMaxAggregateOutputType = {
    key: string | null
    value: string | null
  }

  export type PropertyCountAggregateOutputType = {
    key: number
    value: number
    _all: number
  }


  export type PropertyMinAggregateInputType = {
    key?: true
    value?: true
  }

  export type PropertyMaxAggregateInputType = {
    key?: true
    value?: true
  }

  export type PropertyCountAggregateInputType = {
    key?: true
    value?: true
    _all?: true
  }

  export type PropertyAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Property to aggregate.
     */
    where?: PropertyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Properties to fetch.
     */
    orderBy?: PropertyOrderByWithRelationInput | PropertyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PropertyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Properties 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` Properties.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Properties
    **/
    _count?: true | PropertyCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PropertyMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PropertyMaxAggregateInputType
  }

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




  export type PropertyGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PropertyWhereInput
    orderBy?: PropertyOrderByWithAggregationInput | PropertyOrderByWithAggregationInput[]
    by: PropertyScalarFieldEnum[] | PropertyScalarFieldEnum
    having?: PropertyScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PropertyCountAggregateInputType | true
    _min?: PropertyMinAggregateInputType
    _max?: PropertyMaxAggregateInputType
  }

  export type PropertyGroupByOutputType = {
    key: string
    value: string
    _count: PropertyCountAggregateOutputType | null
    _min: PropertyMinAggregateOutputType | null
    _max: PropertyMaxAggregateOutputType | null
  }

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


  export type PropertySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    key?: boolean
    value?: boolean
  }, ExtArgs["result"]["property"]>

  export type PropertySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    key?: boolean
    value?: boolean
  }, ExtArgs["result"]["property"]>

  export type PropertySelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    key?: boolean
    value?: boolean
  }, ExtArgs["result"]["property"]>

  export type PropertySelectScalar = {
    key?: boolean
    value?: boolean
  }

  export type PropertyOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"key" | "value", ExtArgs["result"]["property"]>

  export type $PropertyPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Property"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      key: string
      value: string
    }, ExtArgs["result"]["property"]>
    composites: {}
  }

  type PropertyGetPayload<S extends boolean | null | undefined | PropertyDefaultArgs> = $Result.GetResult<Prisma.$PropertyPayload, S>

  type PropertyCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<PropertyFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: PropertyCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Property 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 {PropertyFindFirstArgs} args - Arguments to find a Property
     * @example
     * // Get one Property
     * const property = await prisma.property.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends PropertyFindFirstArgs>(args?: SelectSubset<T, PropertyFindFirstArgs<ExtArgs>>): Prisma__PropertyClient<$Result.GetResult<Prisma.$PropertyPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Property 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 {PropertyFindFirstOrThrowArgs} args - Arguments to find a Property
     * @example
     * // Get one Property
     * const property = await prisma.property.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends PropertyFindFirstOrThrowArgs>(args?: SelectSubset<T, PropertyFindFirstOrThrowArgs<ExtArgs>>): Prisma__PropertyClient<$Result.GetResult<Prisma.$PropertyPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Properties 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 {PropertyFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Properties
     * const properties = await prisma.property.findMany()
     * 
     * // Get first 10 Properties
     * const properties = await prisma.property.findMany({ take: 10 })
     * 
     * // Only select the `key`
     * const propertyWithKeyOnly = await prisma.property.findMany({ select: { key: true } })
     * 
     */
    findMany<T extends PropertyFindManyArgs>(args?: SelectSubset<T, PropertyFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PropertyPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Property.
     * @param {PropertyCreateArgs} args - Arguments to create a Property.
     * @example
     * // Create one Property
     * const Property = await prisma.property.create({
     *   data: {
     *     // ... data to create a Property
     *   }
     * })
     * 
     */
    create<T extends PropertyCreateArgs>(args: SelectSubset<T, PropertyCreateArgs<ExtArgs>>): Prisma__PropertyClient<$Result.GetResult<Prisma.$PropertyPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Properties and returns the data saved in the database.
     * @param {PropertyCreateManyAndReturnArgs} args - Arguments to create many Properties.
     * @example
     * // Create many Properties
     * const property = await prisma.property.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Properties and only return the `key`
     * const propertyWithKeyOnly = await prisma.property.createManyAndReturn({
     *   select: { key: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends PropertyCreateManyAndReturnArgs>(args?: SelectSubset<T, PropertyCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PropertyPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Property.
     * @param {PropertyDeleteArgs} args - Arguments to delete one Property.
     * @example
     * // Delete one Property
     * const Property = await prisma.property.delete({
     *   where: {
     *     // ... filter to delete one Property
     *   }
     * })
     * 
     */
    delete<T extends PropertyDeleteArgs>(args: SelectSubset<T, PropertyDeleteArgs<ExtArgs>>): Prisma__PropertyClient<$Result.GetResult<Prisma.$PropertyPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Property.
     * @param {PropertyUpdateArgs} args - Arguments to update one Property.
     * @example
     * // Update one Property
     * const property = await prisma.property.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends PropertyUpdateArgs>(args: SelectSubset<T, PropertyUpdateArgs<ExtArgs>>): Prisma__PropertyClient<$Result.GetResult<Prisma.$PropertyPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more Properties and returns the data updated in the database.
     * @param {PropertyUpdateManyAndReturnArgs} args - Arguments to update many Properties.
     * @example
     * // Update many Properties
     * const property = await prisma.property.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Properties and only return the `key`
     * const propertyWithKeyOnly = await prisma.property.updateManyAndReturn({
     *   select: { key: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends PropertyUpdateManyAndReturnArgs>(args: SelectSubset<T, PropertyUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PropertyPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a Property.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PropertyAggregateArgs} 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 PropertyAggregateArgs>(args: Subset<T, PropertyAggregateArgs>): Prisma.PrismaPromise<GetPropertyAggregateType<T>>

    /**
     * Group by Property.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PropertyGroupByArgs} 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 PropertyGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: PropertyGroupByArgs['orderBy'] }
        : { orderBy?: PropertyGroupByArgs['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, PropertyGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPropertyGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Property model
   */
  readonly fields: PropertyFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Property.
   * 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__PropertyClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> 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 Property model
   */
  interface PropertyFieldRefs {
    readonly key: FieldRef<"Property", 'String'>
    readonly value: FieldRef<"Property", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Property findUnique
   */
  export type PropertyFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * Filter, which Property to fetch.
     */
    where: PropertyWhereUniqueInput
  }

  /**
   * Property findUniqueOrThrow
   */
  export type PropertyFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * Filter, which Property to fetch.
     */
    where: PropertyWhereUniqueInput
  }

  /**
   * Property findFirst
   */
  export type PropertyFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * Filter, which Property to fetch.
     */
    where?: PropertyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Properties to fetch.
     */
    orderBy?: PropertyOrderByWithRelationInput | PropertyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Properties.
     */
    cursor?: PropertyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Properties 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` Properties.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Properties.
     */
    distinct?: PropertyScalarFieldEnum | PropertyScalarFieldEnum[]
  }

  /**
   * Property findFirstOrThrow
   */
  export type PropertyFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * Filter, which Property to fetch.
     */
    where?: PropertyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Properties to fetch.
     */
    orderBy?: PropertyOrderByWithRelationInput | PropertyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Properties.
     */
    cursor?: PropertyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Properties 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` Properties.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Properties.
     */
    distinct?: PropertyScalarFieldEnum | PropertyScalarFieldEnum[]
  }

  /**
   * Property findMany
   */
  export type PropertyFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * Filter, which Properties to fetch.
     */
    where?: PropertyWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Properties to fetch.
     */
    orderBy?: PropertyOrderByWithRelationInput | PropertyOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Properties.
     */
    cursor?: PropertyWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Properties 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` Properties.
     */
    skip?: number
    distinct?: PropertyScalarFieldEnum | PropertyScalarFieldEnum[]
  }

  /**
   * Property create
   */
  export type PropertyCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * The data needed to create a Property.
     */
    data: XOR<PropertyCreateInput, PropertyUncheckedCreateInput>
  }

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

  /**
   * Property createManyAndReturn
   */
  export type PropertyCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * The data used to create many Properties.
     */
    data: PropertyCreateManyInput | PropertyCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Property update
   */
  export type PropertyUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * The data needed to update a Property.
     */
    data: XOR<PropertyUpdateInput, PropertyUncheckedUpdateInput>
    /**
     * Choose, which Property to update.
     */
    where: PropertyWhereUniqueInput
  }

  /**
   * Property updateMany
   */
  export type PropertyUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Properties.
     */
    data: XOR<PropertyUpdateManyMutationInput, PropertyUncheckedUpdateManyInput>
    /**
     * Filter which Properties to update
     */
    where?: PropertyWhereInput
    /**
     * Limit how many Properties to update.
     */
    limit?: number
  }

  /**
   * Property updateManyAndReturn
   */
  export type PropertyUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * The data used to update Properties.
     */
    data: XOR<PropertyUpdateManyMutationInput, PropertyUncheckedUpdateManyInput>
    /**
     * Filter which Properties to update
     */
    where?: PropertyWhereInput
    /**
     * Limit how many Properties to update.
     */
    limit?: number
  }

  /**
   * Property upsert
   */
  export type PropertyUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * The filter to search for the Property to update in case it exists.
     */
    where: PropertyWhereUniqueInput
    /**
     * In case the Property found by the `where` argument doesn't exist, create a new Property with this data.
     */
    create: XOR<PropertyCreateInput, PropertyUncheckedCreateInput>
    /**
     * In case the Property was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PropertyUpdateInput, PropertyUncheckedUpdateInput>
  }

  /**
   * Property delete
   */
  export type PropertyDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
    /**
     * Filter which Property to delete.
     */
    where: PropertyWhereUniqueInput
  }

  /**
   * Property deleteMany
   */
  export type PropertyDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Properties to delete
     */
    where?: PropertyWhereInput
    /**
     * Limit how many Properties to delete.
     */
    limit?: number
  }

  /**
   * Property without action
   */
  export type PropertyDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Property
     */
    select?: PropertySelect<ExtArgs> | null
    /**
     * Omit specific fields from the Property
     */
    omit?: PropertyOmit<ExtArgs> | null
  }


  /**
   * Model Settings
   */

  export type AggregateSettings = {
    _count: SettingsCountAggregateOutputType | null
    _min: SettingsMinAggregateOutputType | null
    _max: SettingsMaxAggregateOutputType | null
  }

  export type SettingsMinAggregateOutputType = {
    updatedAt: Date | null
    userId: string | null
  }

  export type SettingsMaxAggregateOutputType = {
    updatedAt: Date | null
    userId: string | null
  }

  export type SettingsCountAggregateOutputType = {
    settings: number
    updatedAt: number
    userId: number
    _all: number
  }


  export type SettingsMinAggregateInputType = {
    updatedAt?: true
    userId?: true
  }

  export type SettingsMaxAggregateInputType = {
    updatedAt?: true
    userId?: true
  }

  export type SettingsCountAggregateInputType = {
    settings?: true
    updatedAt?: true
    userId?: true
    _all?: true
  }

  export type SettingsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Settings to aggregate.
     */
    where?: SettingsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Settings to fetch.
     */
    orderBy?: SettingsOrderByWithRelationInput | SettingsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SettingsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Settings 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` Settings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Settings
    **/
    _count?: true | SettingsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SettingsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SettingsMaxAggregateInputType
  }

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




  export type SettingsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SettingsWhereInput
    orderBy?: SettingsOrderByWithAggregationInput | SettingsOrderByWithAggregationInput[]
    by: SettingsScalarFieldEnum[] | SettingsScalarFieldEnum
    having?: SettingsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SettingsCountAggregateInputType | true
    _min?: SettingsMinAggregateInputType
    _max?: SettingsMaxAggregateInputType
  }

  export type SettingsGroupByOutputType = {
    settings: JsonValue | null
    updatedAt: Date
    userId: string
    _count: SettingsCountAggregateOutputType | null
    _min: SettingsMinAggregateOutputType | null
    _max: SettingsMaxAggregateOutputType | null
  }

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


  export type SettingsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    settings?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["settings"]>

  export type SettingsSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    settings?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["settings"]>

  export type SettingsSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    settings?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["settings"]>

  export type SettingsSelectScalar = {
    settings?: boolean
    updatedAt?: boolean
    userId?: boolean
  }

  export type SettingsOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"settings" | "updatedAt" | "userId", ExtArgs["result"]["settings"]>
  export type SettingsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type SettingsIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type SettingsIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $SettingsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Settings"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      settings: Prisma.JsonValue | null
      updatedAt: Date
      userId: string
    }, ExtArgs["result"]["settings"]>
    composites: {}
  }

  type SettingsGetPayload<S extends boolean | null | undefined | SettingsDefaultArgs> = $Result.GetResult<Prisma.$SettingsPayload, S>

  type SettingsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<SettingsFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: SettingsCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Settings 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 {SettingsFindFirstArgs} args - Arguments to find a Settings
     * @example
     * // Get one Settings
     * const settings = await prisma.settings.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends SettingsFindFirstArgs>(args?: SelectSubset<T, SettingsFindFirstArgs<ExtArgs>>): Prisma__SettingsClient<$Result.GetResult<Prisma.$SettingsPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Settings 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 {SettingsFindFirstOrThrowArgs} args - Arguments to find a Settings
     * @example
     * // Get one Settings
     * const settings = await prisma.settings.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends SettingsFindFirstOrThrowArgs>(args?: SelectSubset<T, SettingsFindFirstOrThrowArgs<ExtArgs>>): Prisma__SettingsClient<$Result.GetResult<Prisma.$SettingsPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Settings 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 {SettingsFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Settings
     * const settings = await prisma.settings.findMany()
     * 
     * // Get first 10 Settings
     * const settings = await prisma.settings.findMany({ take: 10 })
     * 
     * // Only select the `settings`
     * const settingsWithSettingsOnly = await prisma.settings.findMany({ select: { settings: true } })
     * 
     */
    findMany<T extends SettingsFindManyArgs>(args?: SelectSubset<T, SettingsFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SettingsPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Settings.
     * @param {SettingsCreateArgs} args - Arguments to create a Settings.
     * @example
     * // Create one Settings
     * const Settings = await prisma.settings.create({
     *   data: {
     *     // ... data to create a Settings
     *   }
     * })
     * 
     */
    create<T extends SettingsCreateArgs>(args: SelectSubset<T, SettingsCreateArgs<ExtArgs>>): Prisma__SettingsClient<$Result.GetResult<Prisma.$SettingsPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Settings and returns the data saved in the database.
     * @param {SettingsCreateManyAndReturnArgs} args - Arguments to create many Settings.
     * @example
     * // Create many Settings
     * const settings = await prisma.settings.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Settings and only return the `settings`
     * const settingsWithSettingsOnly = await prisma.settings.createManyAndReturn({
     *   select: { settings: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends SettingsCreateManyAndReturnArgs>(args?: SelectSubset<T, SettingsCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SettingsPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Settings.
     * @param {SettingsDeleteArgs} args - Arguments to delete one Settings.
     * @example
     * // Delete one Settings
     * const Settings = await prisma.settings.delete({
     *   where: {
     *     // ... filter to delete one Settings
     *   }
     * })
     * 
     */
    delete<T extends SettingsDeleteArgs>(args: SelectSubset<T, SettingsDeleteArgs<ExtArgs>>): Prisma__SettingsClient<$Result.GetResult<Prisma.$SettingsPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Settings.
     * @param {SettingsUpdateArgs} args - Arguments to update one Settings.
     * @example
     * // Update one Settings
     * const settings = await prisma.settings.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SettingsUpdateArgs>(args: SelectSubset<T, SettingsUpdateArgs<ExtArgs>>): Prisma__SettingsClient<$Result.GetResult<Prisma.$SettingsPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more Settings and returns the data updated in the database.
     * @param {SettingsUpdateManyAndReturnArgs} args - Arguments to update many Settings.
     * @example
     * // Update many Settings
     * const settings = await prisma.settings.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Settings and only return the `settings`
     * const settingsWithSettingsOnly = await prisma.settings.updateManyAndReturn({
     *   select: { settings: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends SettingsUpdateManyAndReturnArgs>(args: SelectSubset<T, SettingsUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SettingsPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a Settings.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SettingsAggregateArgs} 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 SettingsAggregateArgs>(args: Subset<T, SettingsAggregateArgs>): Prisma.PrismaPromise<GetSettingsAggregateType<T>>

    /**
     * Group by Settings.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SettingsGroupByArgs} 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 SettingsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SettingsGroupByArgs['orderBy'] }
        : { orderBy?: SettingsGroupByArgs['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, SettingsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSettingsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Settings model
   */
  readonly fields: SettingsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Settings.
   * 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__SettingsClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 Settings model
   */
  interface SettingsFieldRefs {
    readonly settings: FieldRef<"Settings", 'Json'>
    readonly updatedAt: FieldRef<"Settings", 'DateTime'>
    readonly userId: FieldRef<"Settings", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Settings findUnique
   */
  export type SettingsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
    /**
     * Filter, which Settings to fetch.
     */
    where: SettingsWhereUniqueInput
  }

  /**
   * Settings findUniqueOrThrow
   */
  export type SettingsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
    /**
     * Filter, which Settings to fetch.
     */
    where: SettingsWhereUniqueInput
  }

  /**
   * Settings findFirst
   */
  export type SettingsFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
    /**
     * Filter, which Settings to fetch.
     */
    where?: SettingsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Settings to fetch.
     */
    orderBy?: SettingsOrderByWithRelationInput | SettingsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Settings.
     */
    cursor?: SettingsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Settings 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` Settings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Settings.
     */
    distinct?: SettingsScalarFieldEnum | SettingsScalarFieldEnum[]
  }

  /**
   * Settings findFirstOrThrow
   */
  export type SettingsFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
    /**
     * Filter, which Settings to fetch.
     */
    where?: SettingsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Settings to fetch.
     */
    orderBy?: SettingsOrderByWithRelationInput | SettingsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Settings.
     */
    cursor?: SettingsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Settings 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` Settings.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Settings.
     */
    distinct?: SettingsScalarFieldEnum | SettingsScalarFieldEnum[]
  }

  /**
   * Settings findMany
   */
  export type SettingsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
    /**
     * Filter, which Settings to fetch.
     */
    where?: SettingsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Settings to fetch.
     */
    orderBy?: SettingsOrderByWithRelationInput | SettingsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Settings.
     */
    cursor?: SettingsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Settings 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` Settings.
     */
    skip?: number
    distinct?: SettingsScalarFieldEnum | SettingsScalarFieldEnum[]
  }

  /**
   * Settings create
   */
  export type SettingsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
    /**
     * The data needed to create a Settings.
     */
    data: XOR<SettingsCreateInput, SettingsUncheckedCreateInput>
  }

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

  /**
   * Settings createManyAndReturn
   */
  export type SettingsCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * The data used to create many Settings.
     */
    data: SettingsCreateManyInput | SettingsCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Settings update
   */
  export type SettingsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
    /**
     * The data needed to update a Settings.
     */
    data: XOR<SettingsUpdateInput, SettingsUncheckedUpdateInput>
    /**
     * Choose, which Settings to update.
     */
    where: SettingsWhereUniqueInput
  }

  /**
   * Settings updateMany
   */
  export type SettingsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Settings.
     */
    data: XOR<SettingsUpdateManyMutationInput, SettingsUncheckedUpdateManyInput>
    /**
     * Filter which Settings to update
     */
    where?: SettingsWhereInput
    /**
     * Limit how many Settings to update.
     */
    limit?: number
  }

  /**
   * Settings updateManyAndReturn
   */
  export type SettingsUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * The data used to update Settings.
     */
    data: XOR<SettingsUpdateManyMutationInput, SettingsUncheckedUpdateManyInput>
    /**
     * Filter which Settings to update
     */
    where?: SettingsWhereInput
    /**
     * Limit how many Settings to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Settings upsert
   */
  export type SettingsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
    /**
     * The filter to search for the Settings to update in case it exists.
     */
    where: SettingsWhereUniqueInput
    /**
     * In case the Settings found by the `where` argument doesn't exist, create a new Settings with this data.
     */
    create: XOR<SettingsCreateInput, SettingsUncheckedCreateInput>
    /**
     * In case the Settings was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SettingsUpdateInput, SettingsUncheckedUpdateInput>
  }

  /**
   * Settings delete
   */
  export type SettingsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
    /**
     * Filter which Settings to delete.
     */
    where: SettingsWhereUniqueInput
  }

  /**
   * Settings deleteMany
   */
  export type SettingsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Settings to delete
     */
    where?: SettingsWhereInput
    /**
     * Limit how many Settings to delete.
     */
    limit?: number
  }

  /**
   * Settings without action
   */
  export type SettingsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
  }


  /**
   * Model SymbolProfile
   */

  export type AggregateSymbolProfile = {
    _count: SymbolProfileCountAggregateOutputType | null
    _min: SymbolProfileMinAggregateOutputType | null
    _max: SymbolProfileMaxAggregateOutputType | null
  }

  export type SymbolProfileMinAggregateOutputType = {
    assetClass: $Enums.AssetClass | null
    assetSubClass: $Enums.AssetSubClass | null
    comment: string | null
    createdAt: Date | null
    currency: string | null
    cusip: string | null
    dataSource: $Enums.DataSource | null
    figi: string | null
    figiComposite: string | null
    figiShareClass: string | null
    id: string | null
    isActive: boolean | null
    isin: string | null
    name: string | null
    updatedAt: Date | null
    symbol: string | null
    url: string | null
    userId: string | null
  }

  export type SymbolProfileMaxAggregateOutputType = {
    assetClass: $Enums.AssetClass | null
    assetSubClass: $Enums.AssetSubClass | null
    comment: string | null
    createdAt: Date | null
    currency: string | null
    cusip: string | null
    dataSource: $Enums.DataSource | null
    figi: string | null
    figiComposite: string | null
    figiShareClass: string | null
    id: string | null
    isActive: boolean | null
    isin: string | null
    name: string | null
    updatedAt: Date | null
    symbol: string | null
    url: string | null
    userId: string | null
  }

  export type SymbolProfileCountAggregateOutputType = {
    assetClass: number
    assetSubClass: number
    comment: number
    countries: number
    createdAt: number
    currency: number
    cusip: number
    dataSource: number
    figi: number
    figiComposite: number
    figiShareClass: number
    holdings: number
    id: number
    isActive: number
    isin: number
    name: number
    updatedAt: number
    scraperConfiguration: number
    sectors: number
    symbol: number
    symbolMapping: number
    url: number
    userId: number
    _all: number
  }


  export type SymbolProfileMinAggregateInputType = {
    assetClass?: true
    assetSubClass?: true
    comment?: true
    createdAt?: true
    currency?: true
    cusip?: true
    dataSource?: true
    figi?: true
    figiComposite?: true
    figiShareClass?: true
    id?: true
    isActive?: true
    isin?: true
    name?: true
    updatedAt?: true
    symbol?: true
    url?: true
    userId?: true
  }

  export type SymbolProfileMaxAggregateInputType = {
    assetClass?: true
    assetSubClass?: true
    comment?: true
    createdAt?: true
    currency?: true
    cusip?: true
    dataSource?: true
    figi?: true
    figiComposite?: true
    figiShareClass?: true
    id?: true
    isActive?: true
    isin?: true
    name?: true
    updatedAt?: true
    symbol?: true
    url?: true
    userId?: true
  }

  export type SymbolProfileCountAggregateInputType = {
    assetClass?: true
    assetSubClass?: true
    comment?: true
    countries?: true
    createdAt?: true
    currency?: true
    cusip?: true
    dataSource?: true
    figi?: true
    figiComposite?: true
    figiShareClass?: true
    holdings?: true
    id?: true
    isActive?: true
    isin?: true
    name?: true
    updatedAt?: true
    scraperConfiguration?: true
    sectors?: true
    symbol?: true
    symbolMapping?: true
    url?: true
    userId?: true
    _all?: true
  }

  export type SymbolProfileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SymbolProfile to aggregate.
     */
    where?: SymbolProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SymbolProfiles to fetch.
     */
    orderBy?: SymbolProfileOrderByWithRelationInput | SymbolProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SymbolProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SymbolProfiles 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` SymbolProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned SymbolProfiles
    **/
    _count?: true | SymbolProfileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SymbolProfileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SymbolProfileMaxAggregateInputType
  }

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




  export type SymbolProfileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SymbolProfileWhereInput
    orderBy?: SymbolProfileOrderByWithAggregationInput | SymbolProfileOrderByWithAggregationInput[]
    by: SymbolProfileScalarFieldEnum[] | SymbolProfileScalarFieldEnum
    having?: SymbolProfileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SymbolProfileCountAggregateInputType | true
    _min?: SymbolProfileMinAggregateInputType
    _max?: SymbolProfileMaxAggregateInputType
  }

  export type SymbolProfileGroupByOutputType = {
    assetClass: $Enums.AssetClass | null
    assetSubClass: $Enums.AssetSubClass | null
    comment: string | null
    countries: JsonValue | null
    createdAt: Date
    currency: string
    cusip: string | null
    dataSource: $Enums.DataSource
    figi: string | null
    figiComposite: string | null
    figiShareClass: string | null
    holdings: JsonValue | null
    id: string
    isActive: boolean
    isin: string | null
    name: string | null
    updatedAt: Date
    scraperConfiguration: JsonValue | null
    sectors: JsonValue | null
    symbol: string
    symbolMapping: JsonValue | null
    url: string | null
    userId: string | null
    _count: SymbolProfileCountAggregateOutputType | null
    _min: SymbolProfileMinAggregateOutputType | null
    _max: SymbolProfileMaxAggregateOutputType | null
  }

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


  export type SymbolProfileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    assetClass?: boolean
    assetSubClass?: boolean
    comment?: boolean
    countries?: boolean
    createdAt?: boolean
    currency?: boolean
    cusip?: boolean
    dataSource?: boolean
    figi?: boolean
    figiComposite?: boolean
    figiShareClass?: boolean
    holdings?: boolean
    id?: boolean
    isActive?: boolean
    isin?: boolean
    name?: boolean
    updatedAt?: boolean
    scraperConfiguration?: boolean
    sectors?: boolean
    symbol?: boolean
    symbolMapping?: boolean
    url?: boolean
    userId?: boolean
    activities?: boolean | SymbolProfile$activitiesArgs<ExtArgs>
    user?: boolean | SymbolProfile$userArgs<ExtArgs>
    watchedBy?: boolean | SymbolProfile$watchedByArgs<ExtArgs>
    SymbolProfileOverrides?: boolean | SymbolProfile$SymbolProfileOverridesArgs<ExtArgs>
    _count?: boolean | SymbolProfileCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["symbolProfile"]>

  export type SymbolProfileSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    assetClass?: boolean
    assetSubClass?: boolean
    comment?: boolean
    countries?: boolean
    createdAt?: boolean
    currency?: boolean
    cusip?: boolean
    dataSource?: boolean
    figi?: boolean
    figiComposite?: boolean
    figiShareClass?: boolean
    holdings?: boolean
    id?: boolean
    isActive?: boolean
    isin?: boolean
    name?: boolean
    updatedAt?: boolean
    scraperConfiguration?: boolean
    sectors?: boolean
    symbol?: boolean
    symbolMapping?: boolean
    url?: boolean
    userId?: boolean
    user?: boolean | SymbolProfile$userArgs<ExtArgs>
  }, ExtArgs["result"]["symbolProfile"]>

  export type SymbolProfileSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    assetClass?: boolean
    assetSubClass?: boolean
    comment?: boolean
    countries?: boolean
    createdAt?: boolean
    currency?: boolean
    cusip?: boolean
    dataSource?: boolean
    figi?: boolean
    figiComposite?: boolean
    figiShareClass?: boolean
    holdings?: boolean
    id?: boolean
    isActive?: boolean
    isin?: boolean
    name?: boolean
    updatedAt?: boolean
    scraperConfiguration?: boolean
    sectors?: boolean
    symbol?: boolean
    symbolMapping?: boolean
    url?: boolean
    userId?: boolean
    user?: boolean | SymbolProfile$userArgs<ExtArgs>
  }, ExtArgs["result"]["symbolProfile"]>

  export type SymbolProfileSelectScalar = {
    assetClass?: boolean
    assetSubClass?: boolean
    comment?: boolean
    countries?: boolean
    createdAt?: boolean
    currency?: boolean
    cusip?: boolean
    dataSource?: boolean
    figi?: boolean
    figiComposite?: boolean
    figiShareClass?: boolean
    holdings?: boolean
    id?: boolean
    isActive?: boolean
    isin?: boolean
    name?: boolean
    updatedAt?: boolean
    scraperConfiguration?: boolean
    sectors?: boolean
    symbol?: boolean
    symbolMapping?: boolean
    url?: boolean
    userId?: boolean
  }

  export type SymbolProfileOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"assetClass" | "assetSubClass" | "comment" | "countries" | "createdAt" | "currency" | "cusip" | "dataSource" | "figi" | "figiComposite" | "figiShareClass" | "holdings" | "id" | "isActive" | "isin" | "name" | "updatedAt" | "scraperConfiguration" | "sectors" | "symbol" | "symbolMapping" | "url" | "userId", ExtArgs["result"]["symbolProfile"]>
  export type SymbolProfileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    activities?: boolean | SymbolProfile$activitiesArgs<ExtArgs>
    user?: boolean | SymbolProfile$userArgs<ExtArgs>
    watchedBy?: boolean | SymbolProfile$watchedByArgs<ExtArgs>
    SymbolProfileOverrides?: boolean | SymbolProfile$SymbolProfileOverridesArgs<ExtArgs>
    _count?: boolean | SymbolProfileCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type SymbolProfileIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | SymbolProfile$userArgs<ExtArgs>
  }
  export type SymbolProfileIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | SymbolProfile$userArgs<ExtArgs>
  }

  export type $SymbolProfilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SymbolProfile"
    objects: {
      activities: Prisma.$OrderPayload<ExtArgs>[]
      user: Prisma.$UserPayload<ExtArgs> | null
      watchedBy: Prisma.$UserPayload<ExtArgs>[]
      SymbolProfileOverrides: Prisma.$SymbolProfileOverridesPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      assetClass: $Enums.AssetClass | null
      assetSubClass: $Enums.AssetSubClass | null
      comment: string | null
      countries: Prisma.JsonValue | null
      createdAt: Date
      currency: string
      cusip: string | null
      dataSource: $Enums.DataSource
      figi: string | null
      figiComposite: string | null
      figiShareClass: string | null
      holdings: Prisma.JsonValue | null
      id: string
      isActive: boolean
      isin: string | null
      name: string | null
      updatedAt: Date
      scraperConfiguration: Prisma.JsonValue | null
      sectors: Prisma.JsonValue | null
      symbol: string
      symbolMapping: Prisma.JsonValue | null
      url: string | null
      userId: string | null
    }, ExtArgs["result"]["symbolProfile"]>
    composites: {}
  }

  type SymbolProfileGetPayload<S extends boolean | null | undefined | SymbolProfileDefaultArgs> = $Result.GetResult<Prisma.$SymbolProfilePayload, S>

  type SymbolProfileCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<SymbolProfileFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: SymbolProfileCountAggregateInputType | true
    }

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

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

    /**
     * Find the first SymbolProfile 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 {SymbolProfileFindFirstArgs} args - Arguments to find a SymbolProfile
     * @example
     * // Get one SymbolProfile
     * const symbolProfile = await prisma.symbolProfile.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends SymbolProfileFindFirstArgs>(args?: SelectSubset<T, SymbolProfileFindFirstArgs<ExtArgs>>): Prisma__SymbolProfileClient<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first SymbolProfile 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 {SymbolProfileFindFirstOrThrowArgs} args - Arguments to find a SymbolProfile
     * @example
     * // Get one SymbolProfile
     * const symbolProfile = await prisma.symbolProfile.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends SymbolProfileFindFirstOrThrowArgs>(args?: SelectSubset<T, SymbolProfileFindFirstOrThrowArgs<ExtArgs>>): Prisma__SymbolProfileClient<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more SymbolProfiles 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 {SymbolProfileFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all SymbolProfiles
     * const symbolProfiles = await prisma.symbolProfile.findMany()
     * 
     * // Get first 10 SymbolProfiles
     * const symbolProfiles = await prisma.symbolProfile.findMany({ take: 10 })
     * 
     * // Only select the `comment`
     * const symbolProfileWithCommentOnly = await prisma.symbolProfile.findMany({ select: { comment: true } })
     * 
     */
    findMany<T extends SymbolProfileFindManyArgs>(args?: SelectSubset<T, SymbolProfileFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a SymbolProfile.
     * @param {SymbolProfileCreateArgs} args - Arguments to create a SymbolProfile.
     * @example
     * // Create one SymbolProfile
     * const SymbolProfile = await prisma.symbolProfile.create({
     *   data: {
     *     // ... data to create a SymbolProfile
     *   }
     * })
     * 
     */
    create<T extends SymbolProfileCreateArgs>(args: SelectSubset<T, SymbolProfileCreateArgs<ExtArgs>>): Prisma__SymbolProfileClient<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many SymbolProfiles and returns the data saved in the database.
     * @param {SymbolProfileCreateManyAndReturnArgs} args - Arguments to create many SymbolProfiles.
     * @example
     * // Create many SymbolProfiles
     * const symbolProfile = await prisma.symbolProfile.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many SymbolProfiles and only return the `comment`
     * const symbolProfileWithCommentOnly = await prisma.symbolProfile.createManyAndReturn({
     *   select: { comment: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends SymbolProfileCreateManyAndReturnArgs>(args?: SelectSubset<T, SymbolProfileCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a SymbolProfile.
     * @param {SymbolProfileDeleteArgs} args - Arguments to delete one SymbolProfile.
     * @example
     * // Delete one SymbolProfile
     * const SymbolProfile = await prisma.symbolProfile.delete({
     *   where: {
     *     // ... filter to delete one SymbolProfile
     *   }
     * })
     * 
     */
    delete<T extends SymbolProfileDeleteArgs>(args: SelectSubset<T, SymbolProfileDeleteArgs<ExtArgs>>): Prisma__SymbolProfileClient<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one SymbolProfile.
     * @param {SymbolProfileUpdateArgs} args - Arguments to update one SymbolProfile.
     * @example
     * // Update one SymbolProfile
     * const symbolProfile = await prisma.symbolProfile.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SymbolProfileUpdateArgs>(args: SelectSubset<T, SymbolProfileUpdateArgs<ExtArgs>>): Prisma__SymbolProfileClient<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more SymbolProfiles and returns the data updated in the database.
     * @param {SymbolProfileUpdateManyAndReturnArgs} args - Arguments to update many SymbolProfiles.
     * @example
     * // Update many SymbolProfiles
     * const symbolProfile = await prisma.symbolProfile.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more SymbolProfiles and only return the `comment`
     * const symbolProfileWithCommentOnly = await prisma.symbolProfile.updateManyAndReturn({
     *   select: { comment: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends SymbolProfileUpdateManyAndReturnArgs>(args: SelectSubset<T, SymbolProfileUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a SymbolProfile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SymbolProfileAggregateArgs} 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 SymbolProfileAggregateArgs>(args: Subset<T, SymbolProfileAggregateArgs>): Prisma.PrismaPromise<GetSymbolProfileAggregateType<T>>

    /**
     * Group by SymbolProfile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SymbolProfileGroupByArgs} 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 SymbolProfileGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SymbolProfileGroupByArgs['orderBy'] }
        : { orderBy?: SymbolProfileGroupByArgs['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, SymbolProfileGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSymbolProfileGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the SymbolProfile model
   */
  readonly fields: SymbolProfileFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for SymbolProfile.
   * 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__SymbolProfileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    activities<T extends SymbolProfile$activitiesArgs<ExtArgs> = {}>(args?: Subset<T, SymbolProfile$activitiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    user<T extends SymbolProfile$userArgs<ExtArgs> = {}>(args?: Subset<T, SymbolProfile$userArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    watchedBy<T extends SymbolProfile$watchedByArgs<ExtArgs> = {}>(args?: Subset<T, SymbolProfile$watchedByArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    SymbolProfileOverrides<T extends SymbolProfile$SymbolProfileOverridesArgs<ExtArgs> = {}>(args?: Subset<T, SymbolProfile$SymbolProfileOverridesArgs<ExtArgs>>): Prisma__SymbolProfileOverridesClient<$Result.GetResult<Prisma.$SymbolProfileOverridesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 SymbolProfile model
   */
  interface SymbolProfileFieldRefs {
    readonly assetClass: FieldRef<"SymbolProfile", 'AssetClass'>
    readonly assetSubClass: FieldRef<"SymbolProfile", 'AssetSubClass'>
    readonly comment: FieldRef<"SymbolProfile", 'String'>
    readonly countries: FieldRef<"SymbolProfile", 'Json'>
    readonly createdAt: FieldRef<"SymbolProfile", 'DateTime'>
    readonly currency: FieldRef<"SymbolProfile", 'String'>
    readonly cusip: FieldRef<"SymbolProfile", 'String'>
    readonly dataSource: FieldRef<"SymbolProfile", 'DataSource'>
    readonly figi: FieldRef<"SymbolProfile", 'String'>
    readonly figiComposite: FieldRef<"SymbolProfile", 'String'>
    readonly figiShareClass: FieldRef<"SymbolProfile", 'String'>
    readonly holdings: FieldRef<"SymbolProfile", 'Json'>
    readonly id: FieldRef<"SymbolProfile", 'String'>
    readonly isActive: FieldRef<"SymbolProfile", 'Boolean'>
    readonly isin: FieldRef<"SymbolProfile", 'String'>
    readonly name: FieldRef<"SymbolProfile", 'String'>
    readonly updatedAt: FieldRef<"SymbolProfile", 'DateTime'>
    readonly scraperConfiguration: FieldRef<"SymbolProfile", 'Json'>
    readonly sectors: FieldRef<"SymbolProfile", 'Json'>
    readonly symbol: FieldRef<"SymbolProfile", 'String'>
    readonly symbolMapping: FieldRef<"SymbolProfile", 'Json'>
    readonly url: FieldRef<"SymbolProfile", 'String'>
    readonly userId: FieldRef<"SymbolProfile", 'String'>
  }
    

  // Custom InputTypes
  /**
   * SymbolProfile findUnique
   */
  export type SymbolProfileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    /**
     * Filter, which SymbolProfile to fetch.
     */
    where: SymbolProfileWhereUniqueInput
  }

  /**
   * SymbolProfile findUniqueOrThrow
   */
  export type SymbolProfileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    /**
     * Filter, which SymbolProfile to fetch.
     */
    where: SymbolProfileWhereUniqueInput
  }

  /**
   * SymbolProfile findFirst
   */
  export type SymbolProfileFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    /**
     * Filter, which SymbolProfile to fetch.
     */
    where?: SymbolProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SymbolProfiles to fetch.
     */
    orderBy?: SymbolProfileOrderByWithRelationInput | SymbolProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SymbolProfiles.
     */
    cursor?: SymbolProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SymbolProfiles 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` SymbolProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SymbolProfiles.
     */
    distinct?: SymbolProfileScalarFieldEnum | SymbolProfileScalarFieldEnum[]
  }

  /**
   * SymbolProfile findFirstOrThrow
   */
  export type SymbolProfileFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    /**
     * Filter, which SymbolProfile to fetch.
     */
    where?: SymbolProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SymbolProfiles to fetch.
     */
    orderBy?: SymbolProfileOrderByWithRelationInput | SymbolProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SymbolProfiles.
     */
    cursor?: SymbolProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SymbolProfiles 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` SymbolProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SymbolProfiles.
     */
    distinct?: SymbolProfileScalarFieldEnum | SymbolProfileScalarFieldEnum[]
  }

  /**
   * SymbolProfile findMany
   */
  export type SymbolProfileFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    /**
     * Filter, which SymbolProfiles to fetch.
     */
    where?: SymbolProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SymbolProfiles to fetch.
     */
    orderBy?: SymbolProfileOrderByWithRelationInput | SymbolProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing SymbolProfiles.
     */
    cursor?: SymbolProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SymbolProfiles 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` SymbolProfiles.
     */
    skip?: number
    distinct?: SymbolProfileScalarFieldEnum | SymbolProfileScalarFieldEnum[]
  }

  /**
   * SymbolProfile create
   */
  export type SymbolProfileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    /**
     * The data needed to create a SymbolProfile.
     */
    data: XOR<SymbolProfileCreateInput, SymbolProfileUncheckedCreateInput>
  }

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

  /**
   * SymbolProfile createManyAndReturn
   */
  export type SymbolProfileCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * The data used to create many SymbolProfiles.
     */
    data: SymbolProfileCreateManyInput | SymbolProfileCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * SymbolProfile update
   */
  export type SymbolProfileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    /**
     * The data needed to update a SymbolProfile.
     */
    data: XOR<SymbolProfileUpdateInput, SymbolProfileUncheckedUpdateInput>
    /**
     * Choose, which SymbolProfile to update.
     */
    where: SymbolProfileWhereUniqueInput
  }

  /**
   * SymbolProfile updateMany
   */
  export type SymbolProfileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SymbolProfiles.
     */
    data: XOR<SymbolProfileUpdateManyMutationInput, SymbolProfileUncheckedUpdateManyInput>
    /**
     * Filter which SymbolProfiles to update
     */
    where?: SymbolProfileWhereInput
    /**
     * Limit how many SymbolProfiles to update.
     */
    limit?: number
  }

  /**
   * SymbolProfile updateManyAndReturn
   */
  export type SymbolProfileUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * The data used to update SymbolProfiles.
     */
    data: XOR<SymbolProfileUpdateManyMutationInput, SymbolProfileUncheckedUpdateManyInput>
    /**
     * Filter which SymbolProfiles to update
     */
    where?: SymbolProfileWhereInput
    /**
     * Limit how many SymbolProfiles to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * SymbolProfile upsert
   */
  export type SymbolProfileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    /**
     * The filter to search for the SymbolProfile to update in case it exists.
     */
    where: SymbolProfileWhereUniqueInput
    /**
     * In case the SymbolProfile found by the `where` argument doesn't exist, create a new SymbolProfile with this data.
     */
    create: XOR<SymbolProfileCreateInput, SymbolProfileUncheckedCreateInput>
    /**
     * In case the SymbolProfile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SymbolProfileUpdateInput, SymbolProfileUncheckedUpdateInput>
  }

  /**
   * SymbolProfile delete
   */
  export type SymbolProfileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    /**
     * Filter which SymbolProfile to delete.
     */
    where: SymbolProfileWhereUniqueInput
  }

  /**
   * SymbolProfile deleteMany
   */
  export type SymbolProfileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SymbolProfiles to delete
     */
    where?: SymbolProfileWhereInput
    /**
     * Limit how many SymbolProfiles to delete.
     */
    limit?: number
  }

  /**
   * SymbolProfile.activities
   */
  export type SymbolProfile$activitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    where?: OrderWhereInput
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    cursor?: OrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OrderScalarFieldEnum | OrderScalarFieldEnum[]
  }

  /**
   * SymbolProfile.user
   */
  export type SymbolProfile$userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
  }

  /**
   * SymbolProfile.watchedBy
   */
  export type SymbolProfile$watchedByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    cursor?: UserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * SymbolProfile.SymbolProfileOverrides
   */
  export type SymbolProfile$SymbolProfileOverridesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
    where?: SymbolProfileOverridesWhereInput
  }

  /**
   * SymbolProfile without action
   */
  export type SymbolProfileDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
  }


  /**
   * Model SymbolProfileOverrides
   */

  export type AggregateSymbolProfileOverrides = {
    _count: SymbolProfileOverridesCountAggregateOutputType | null
    _min: SymbolProfileOverridesMinAggregateOutputType | null
    _max: SymbolProfileOverridesMaxAggregateOutputType | null
  }

  export type SymbolProfileOverridesMinAggregateOutputType = {
    assetClass: $Enums.AssetClass | null
    assetSubClass: $Enums.AssetSubClass | null
    name: string | null
    symbolProfileId: string | null
    updatedAt: Date | null
    url: string | null
  }

  export type SymbolProfileOverridesMaxAggregateOutputType = {
    assetClass: $Enums.AssetClass | null
    assetSubClass: $Enums.AssetSubClass | null
    name: string | null
    symbolProfileId: string | null
    updatedAt: Date | null
    url: string | null
  }

  export type SymbolProfileOverridesCountAggregateOutputType = {
    assetClass: number
    assetSubClass: number
    countries: number
    holdings: number
    name: number
    sectors: number
    symbolProfileId: number
    updatedAt: number
    url: number
    _all: number
  }


  export type SymbolProfileOverridesMinAggregateInputType = {
    assetClass?: true
    assetSubClass?: true
    name?: true
    symbolProfileId?: true
    updatedAt?: true
    url?: true
  }

  export type SymbolProfileOverridesMaxAggregateInputType = {
    assetClass?: true
    assetSubClass?: true
    name?: true
    symbolProfileId?: true
    updatedAt?: true
    url?: true
  }

  export type SymbolProfileOverridesCountAggregateInputType = {
    assetClass?: true
    assetSubClass?: true
    countries?: true
    holdings?: true
    name?: true
    sectors?: true
    symbolProfileId?: true
    updatedAt?: true
    url?: true
    _all?: true
  }

  export type SymbolProfileOverridesAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SymbolProfileOverrides to aggregate.
     */
    where?: SymbolProfileOverridesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SymbolProfileOverrides to fetch.
     */
    orderBy?: SymbolProfileOverridesOrderByWithRelationInput | SymbolProfileOverridesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SymbolProfileOverridesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SymbolProfileOverrides 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` SymbolProfileOverrides.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned SymbolProfileOverrides
    **/
    _count?: true | SymbolProfileOverridesCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SymbolProfileOverridesMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SymbolProfileOverridesMaxAggregateInputType
  }

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




  export type SymbolProfileOverridesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SymbolProfileOverridesWhereInput
    orderBy?: SymbolProfileOverridesOrderByWithAggregationInput | SymbolProfileOverridesOrderByWithAggregationInput[]
    by: SymbolProfileOverridesScalarFieldEnum[] | SymbolProfileOverridesScalarFieldEnum
    having?: SymbolProfileOverridesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SymbolProfileOverridesCountAggregateInputType | true
    _min?: SymbolProfileOverridesMinAggregateInputType
    _max?: SymbolProfileOverridesMaxAggregateInputType
  }

  export type SymbolProfileOverridesGroupByOutputType = {
    assetClass: $Enums.AssetClass | null
    assetSubClass: $Enums.AssetSubClass | null
    countries: JsonValue | null
    holdings: JsonValue | null
    name: string | null
    sectors: JsonValue | null
    symbolProfileId: string
    updatedAt: Date
    url: string | null
    _count: SymbolProfileOverridesCountAggregateOutputType | null
    _min: SymbolProfileOverridesMinAggregateOutputType | null
    _max: SymbolProfileOverridesMaxAggregateOutputType | null
  }

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


  export type SymbolProfileOverridesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    assetClass?: boolean
    assetSubClass?: boolean
    countries?: boolean
    holdings?: boolean
    name?: boolean
    sectors?: boolean
    symbolProfileId?: boolean
    updatedAt?: boolean
    url?: boolean
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["symbolProfileOverrides"]>

  export type SymbolProfileOverridesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    assetClass?: boolean
    assetSubClass?: boolean
    countries?: boolean
    holdings?: boolean
    name?: boolean
    sectors?: boolean
    symbolProfileId?: boolean
    updatedAt?: boolean
    url?: boolean
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["symbolProfileOverrides"]>

  export type SymbolProfileOverridesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    assetClass?: boolean
    assetSubClass?: boolean
    countries?: boolean
    holdings?: boolean
    name?: boolean
    sectors?: boolean
    symbolProfileId?: boolean
    updatedAt?: boolean
    url?: boolean
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["symbolProfileOverrides"]>

  export type SymbolProfileOverridesSelectScalar = {
    assetClass?: boolean
    assetSubClass?: boolean
    countries?: boolean
    holdings?: boolean
    name?: boolean
    sectors?: boolean
    symbolProfileId?: boolean
    updatedAt?: boolean
    url?: boolean
  }

  export type SymbolProfileOverridesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"assetClass" | "assetSubClass" | "countries" | "holdings" | "name" | "sectors" | "symbolProfileId" | "updatedAt" | "url", ExtArgs["result"]["symbolProfileOverrides"]>
  export type SymbolProfileOverridesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
  }
  export type SymbolProfileOverridesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
  }
  export type SymbolProfileOverridesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    SymbolProfile?: boolean | SymbolProfileDefaultArgs<ExtArgs>
  }

  export type $SymbolProfileOverridesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SymbolProfileOverrides"
    objects: {
      SymbolProfile: Prisma.$SymbolProfilePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      assetClass: $Enums.AssetClass | null
      assetSubClass: $Enums.AssetSubClass | null
      countries: Prisma.JsonValue | null
      holdings: Prisma.JsonValue | null
      name: string | null
      sectors: Prisma.JsonValue | null
      symbolProfileId: string
      updatedAt: Date
      url: string | null
    }, ExtArgs["result"]["symbolProfileOverrides"]>
    composites: {}
  }

  type SymbolProfileOverridesGetPayload<S extends boolean | null | undefined | SymbolProfileOverridesDefaultArgs> = $Result.GetResult<Prisma.$SymbolProfileOverridesPayload, S>

  type SymbolProfileOverridesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<SymbolProfileOverridesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: SymbolProfileOverridesCountAggregateInputType | true
    }

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

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

    /**
     * Find the first SymbolProfileOverrides 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 {SymbolProfileOverridesFindFirstArgs} args - Arguments to find a SymbolProfileOverrides
     * @example
     * // Get one SymbolProfileOverrides
     * const symbolProfileOverrides = await prisma.symbolProfileOverrides.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends SymbolProfileOverridesFindFirstArgs>(args?: SelectSubset<T, SymbolProfileOverridesFindFirstArgs<ExtArgs>>): Prisma__SymbolProfileOverridesClient<$Result.GetResult<Prisma.$SymbolProfileOverridesPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first SymbolProfileOverrides 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 {SymbolProfileOverridesFindFirstOrThrowArgs} args - Arguments to find a SymbolProfileOverrides
     * @example
     * // Get one SymbolProfileOverrides
     * const symbolProfileOverrides = await prisma.symbolProfileOverrides.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends SymbolProfileOverridesFindFirstOrThrowArgs>(args?: SelectSubset<T, SymbolProfileOverridesFindFirstOrThrowArgs<ExtArgs>>): Prisma__SymbolProfileOverridesClient<$Result.GetResult<Prisma.$SymbolProfileOverridesPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more SymbolProfileOverrides 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 {SymbolProfileOverridesFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all SymbolProfileOverrides
     * const symbolProfileOverrides = await prisma.symbolProfileOverrides.findMany()
     * 
     * // Get first 10 SymbolProfileOverrides
     * const symbolProfileOverrides = await prisma.symbolProfileOverrides.findMany({ take: 10 })
     * 
     * // Only select the `countries`
     * const symbolProfileOverridesWithCountriesOnly = await prisma.symbolProfileOverrides.findMany({ select: { countries: true } })
     * 
     */
    findMany<T extends SymbolProfileOverridesFindManyArgs>(args?: SelectSubset<T, SymbolProfileOverridesFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SymbolProfileOverridesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a SymbolProfileOverrides.
     * @param {SymbolProfileOverridesCreateArgs} args - Arguments to create a SymbolProfileOverrides.
     * @example
     * // Create one SymbolProfileOverrides
     * const SymbolProfileOverrides = await prisma.symbolProfileOverrides.create({
     *   data: {
     *     // ... data to create a SymbolProfileOverrides
     *   }
     * })
     * 
     */
    create<T extends SymbolProfileOverridesCreateArgs>(args: SelectSubset<T, SymbolProfileOverridesCreateArgs<ExtArgs>>): Prisma__SymbolProfileOverridesClient<$Result.GetResult<Prisma.$SymbolProfileOverridesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many SymbolProfileOverrides and returns the data saved in the database.
     * @param {SymbolProfileOverridesCreateManyAndReturnArgs} args - Arguments to create many SymbolProfileOverrides.
     * @example
     * // Create many SymbolProfileOverrides
     * const symbolProfileOverrides = await prisma.symbolProfileOverrides.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many SymbolProfileOverrides and only return the `countries`
     * const symbolProfileOverridesWithCountriesOnly = await prisma.symbolProfileOverrides.createManyAndReturn({
     *   select: { countries: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends SymbolProfileOverridesCreateManyAndReturnArgs>(args?: SelectSubset<T, SymbolProfileOverridesCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SymbolProfileOverridesPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a SymbolProfileOverrides.
     * @param {SymbolProfileOverridesDeleteArgs} args - Arguments to delete one SymbolProfileOverrides.
     * @example
     * // Delete one SymbolProfileOverrides
     * const SymbolProfileOverrides = await prisma.symbolProfileOverrides.delete({
     *   where: {
     *     // ... filter to delete one SymbolProfileOverrides
     *   }
     * })
     * 
     */
    delete<T extends SymbolProfileOverridesDeleteArgs>(args: SelectSubset<T, SymbolProfileOverridesDeleteArgs<ExtArgs>>): Prisma__SymbolProfileOverridesClient<$Result.GetResult<Prisma.$SymbolProfileOverridesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one SymbolProfileOverrides.
     * @param {SymbolProfileOverridesUpdateArgs} args - Arguments to update one SymbolProfileOverrides.
     * @example
     * // Update one SymbolProfileOverrides
     * const symbolProfileOverrides = await prisma.symbolProfileOverrides.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SymbolProfileOverridesUpdateArgs>(args: SelectSubset<T, SymbolProfileOverridesUpdateArgs<ExtArgs>>): Prisma__SymbolProfileOverridesClient<$Result.GetResult<Prisma.$SymbolProfileOverridesPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more SymbolProfileOverrides and returns the data updated in the database.
     * @param {SymbolProfileOverridesUpdateManyAndReturnArgs} args - Arguments to update many SymbolProfileOverrides.
     * @example
     * // Update many SymbolProfileOverrides
     * const symbolProfileOverrides = await prisma.symbolProfileOverrides.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more SymbolProfileOverrides and only return the `countries`
     * const symbolProfileOverridesWithCountriesOnly = await prisma.symbolProfileOverrides.updateManyAndReturn({
     *   select: { countries: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends SymbolProfileOverridesUpdateManyAndReturnArgs>(args: SelectSubset<T, SymbolProfileOverridesUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SymbolProfileOverridesPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a SymbolProfileOverrides.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SymbolProfileOverridesAggregateArgs} 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 SymbolProfileOverridesAggregateArgs>(args: Subset<T, SymbolProfileOverridesAggregateArgs>): Prisma.PrismaPromise<GetSymbolProfileOverridesAggregateType<T>>

    /**
     * Group by SymbolProfileOverrides.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SymbolProfileOverridesGroupByArgs} 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 SymbolProfileOverridesGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SymbolProfileOverridesGroupByArgs['orderBy'] }
        : { orderBy?: SymbolProfileOverridesGroupByArgs['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, SymbolProfileOverridesGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSymbolProfileOverridesGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the SymbolProfileOverrides model
   */
  readonly fields: SymbolProfileOverridesFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for SymbolProfileOverrides.
   * 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__SymbolProfileOverridesClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    SymbolProfile<T extends SymbolProfileDefaultArgs<ExtArgs> = {}>(args?: Subset<T, SymbolProfileDefaultArgs<ExtArgs>>): Prisma__SymbolProfileClient<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 SymbolProfileOverrides model
   */
  interface SymbolProfileOverridesFieldRefs {
    readonly assetClass: FieldRef<"SymbolProfileOverrides", 'AssetClass'>
    readonly assetSubClass: FieldRef<"SymbolProfileOverrides", 'AssetSubClass'>
    readonly countries: FieldRef<"SymbolProfileOverrides", 'Json'>
    readonly holdings: FieldRef<"SymbolProfileOverrides", 'Json'>
    readonly name: FieldRef<"SymbolProfileOverrides", 'String'>
    readonly sectors: FieldRef<"SymbolProfileOverrides", 'Json'>
    readonly symbolProfileId: FieldRef<"SymbolProfileOverrides", 'String'>
    readonly updatedAt: FieldRef<"SymbolProfileOverrides", 'DateTime'>
    readonly url: FieldRef<"SymbolProfileOverrides", 'String'>
  }
    

  // Custom InputTypes
  /**
   * SymbolProfileOverrides findUnique
   */
  export type SymbolProfileOverridesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
    /**
     * Filter, which SymbolProfileOverrides to fetch.
     */
    where: SymbolProfileOverridesWhereUniqueInput
  }

  /**
   * SymbolProfileOverrides findUniqueOrThrow
   */
  export type SymbolProfileOverridesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
    /**
     * Filter, which SymbolProfileOverrides to fetch.
     */
    where: SymbolProfileOverridesWhereUniqueInput
  }

  /**
   * SymbolProfileOverrides findFirst
   */
  export type SymbolProfileOverridesFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
    /**
     * Filter, which SymbolProfileOverrides to fetch.
     */
    where?: SymbolProfileOverridesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SymbolProfileOverrides to fetch.
     */
    orderBy?: SymbolProfileOverridesOrderByWithRelationInput | SymbolProfileOverridesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SymbolProfileOverrides.
     */
    cursor?: SymbolProfileOverridesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SymbolProfileOverrides 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` SymbolProfileOverrides.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SymbolProfileOverrides.
     */
    distinct?: SymbolProfileOverridesScalarFieldEnum | SymbolProfileOverridesScalarFieldEnum[]
  }

  /**
   * SymbolProfileOverrides findFirstOrThrow
   */
  export type SymbolProfileOverridesFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
    /**
     * Filter, which SymbolProfileOverrides to fetch.
     */
    where?: SymbolProfileOverridesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SymbolProfileOverrides to fetch.
     */
    orderBy?: SymbolProfileOverridesOrderByWithRelationInput | SymbolProfileOverridesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SymbolProfileOverrides.
     */
    cursor?: SymbolProfileOverridesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SymbolProfileOverrides 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` SymbolProfileOverrides.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SymbolProfileOverrides.
     */
    distinct?: SymbolProfileOverridesScalarFieldEnum | SymbolProfileOverridesScalarFieldEnum[]
  }

  /**
   * SymbolProfileOverrides findMany
   */
  export type SymbolProfileOverridesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
    /**
     * Filter, which SymbolProfileOverrides to fetch.
     */
    where?: SymbolProfileOverridesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SymbolProfileOverrides to fetch.
     */
    orderBy?: SymbolProfileOverridesOrderByWithRelationInput | SymbolProfileOverridesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing SymbolProfileOverrides.
     */
    cursor?: SymbolProfileOverridesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SymbolProfileOverrides 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` SymbolProfileOverrides.
     */
    skip?: number
    distinct?: SymbolProfileOverridesScalarFieldEnum | SymbolProfileOverridesScalarFieldEnum[]
  }

  /**
   * SymbolProfileOverrides create
   */
  export type SymbolProfileOverridesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
    /**
     * The data needed to create a SymbolProfileOverrides.
     */
    data: XOR<SymbolProfileOverridesCreateInput, SymbolProfileOverridesUncheckedCreateInput>
  }

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

  /**
   * SymbolProfileOverrides createManyAndReturn
   */
  export type SymbolProfileOverridesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * The data used to create many SymbolProfileOverrides.
     */
    data: SymbolProfileOverridesCreateManyInput | SymbolProfileOverridesCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * SymbolProfileOverrides update
   */
  export type SymbolProfileOverridesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
    /**
     * The data needed to update a SymbolProfileOverrides.
     */
    data: XOR<SymbolProfileOverridesUpdateInput, SymbolProfileOverridesUncheckedUpdateInput>
    /**
     * Choose, which SymbolProfileOverrides to update.
     */
    where: SymbolProfileOverridesWhereUniqueInput
  }

  /**
   * SymbolProfileOverrides updateMany
   */
  export type SymbolProfileOverridesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SymbolProfileOverrides.
     */
    data: XOR<SymbolProfileOverridesUpdateManyMutationInput, SymbolProfileOverridesUncheckedUpdateManyInput>
    /**
     * Filter which SymbolProfileOverrides to update
     */
    where?: SymbolProfileOverridesWhereInput
    /**
     * Limit how many SymbolProfileOverrides to update.
     */
    limit?: number
  }

  /**
   * SymbolProfileOverrides updateManyAndReturn
   */
  export type SymbolProfileOverridesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * The data used to update SymbolProfileOverrides.
     */
    data: XOR<SymbolProfileOverridesUpdateManyMutationInput, SymbolProfileOverridesUncheckedUpdateManyInput>
    /**
     * Filter which SymbolProfileOverrides to update
     */
    where?: SymbolProfileOverridesWhereInput
    /**
     * Limit how many SymbolProfileOverrides to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * SymbolProfileOverrides upsert
   */
  export type SymbolProfileOverridesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
    /**
     * The filter to search for the SymbolProfileOverrides to update in case it exists.
     */
    where: SymbolProfileOverridesWhereUniqueInput
    /**
     * In case the SymbolProfileOverrides found by the `where` argument doesn't exist, create a new SymbolProfileOverrides with this data.
     */
    create: XOR<SymbolProfileOverridesCreateInput, SymbolProfileOverridesUncheckedCreateInput>
    /**
     * In case the SymbolProfileOverrides was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SymbolProfileOverridesUpdateInput, SymbolProfileOverridesUncheckedUpdateInput>
  }

  /**
   * SymbolProfileOverrides delete
   */
  export type SymbolProfileOverridesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
    /**
     * Filter which SymbolProfileOverrides to delete.
     */
    where: SymbolProfileOverridesWhereUniqueInput
  }

  /**
   * SymbolProfileOverrides deleteMany
   */
  export type SymbolProfileOverridesDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SymbolProfileOverrides to delete
     */
    where?: SymbolProfileOverridesWhereInput
    /**
     * Limit how many SymbolProfileOverrides to delete.
     */
    limit?: number
  }

  /**
   * SymbolProfileOverrides without action
   */
  export type SymbolProfileOverridesDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfileOverrides
     */
    select?: SymbolProfileOverridesSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfileOverrides
     */
    omit?: SymbolProfileOverridesOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileOverridesInclude<ExtArgs> | null
  }


  /**
   * Model Subscription
   */

  export type AggregateSubscription = {
    _count: SubscriptionCountAggregateOutputType | null
    _avg: SubscriptionAvgAggregateOutputType | null
    _sum: SubscriptionSumAggregateOutputType | null
    _min: SubscriptionMinAggregateOutputType | null
    _max: SubscriptionMaxAggregateOutputType | null
  }

  export type SubscriptionAvgAggregateOutputType = {
    price: number | null
  }

  export type SubscriptionSumAggregateOutputType = {
    price: number | null
  }

  export type SubscriptionMinAggregateOutputType = {
    createdAt: Date | null
    expiresAt: Date | null
    id: string | null
    price: number | null
    updatedAt: Date | null
    userId: string | null
  }

  export type SubscriptionMaxAggregateOutputType = {
    createdAt: Date | null
    expiresAt: Date | null
    id: string | null
    price: number | null
    updatedAt: Date | null
    userId: string | null
  }

  export type SubscriptionCountAggregateOutputType = {
    createdAt: number
    expiresAt: number
    id: number
    price: number
    updatedAt: number
    userId: number
    _all: number
  }


  export type SubscriptionAvgAggregateInputType = {
    price?: true
  }

  export type SubscriptionSumAggregateInputType = {
    price?: true
  }

  export type SubscriptionMinAggregateInputType = {
    createdAt?: true
    expiresAt?: true
    id?: true
    price?: true
    updatedAt?: true
    userId?: true
  }

  export type SubscriptionMaxAggregateInputType = {
    createdAt?: true
    expiresAt?: true
    id?: true
    price?: true
    updatedAt?: true
    userId?: true
  }

  export type SubscriptionCountAggregateInputType = {
    createdAt?: true
    expiresAt?: true
    id?: true
    price?: true
    updatedAt?: true
    userId?: true
    _all?: true
  }

  export type SubscriptionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Subscription to aggregate.
     */
    where?: SubscriptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscriptions to fetch.
     */
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SubscriptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscriptions 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` Subscriptions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Subscriptions
    **/
    _count?: true | SubscriptionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SubscriptionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SubscriptionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SubscriptionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SubscriptionMaxAggregateInputType
  }

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




  export type SubscriptionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SubscriptionWhereInput
    orderBy?: SubscriptionOrderByWithAggregationInput | SubscriptionOrderByWithAggregationInput[]
    by: SubscriptionScalarFieldEnum[] | SubscriptionScalarFieldEnum
    having?: SubscriptionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SubscriptionCountAggregateInputType | true
    _avg?: SubscriptionAvgAggregateInputType
    _sum?: SubscriptionSumAggregateInputType
    _min?: SubscriptionMinAggregateInputType
    _max?: SubscriptionMaxAggregateInputType
  }

  export type SubscriptionGroupByOutputType = {
    createdAt: Date
    expiresAt: Date
    id: string
    price: number | null
    updatedAt: Date
    userId: string
    _count: SubscriptionCountAggregateOutputType | null
    _avg: SubscriptionAvgAggregateOutputType | null
    _sum: SubscriptionSumAggregateOutputType | null
    _min: SubscriptionMinAggregateOutputType | null
    _max: SubscriptionMaxAggregateOutputType | null
  }

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


  export type SubscriptionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    expiresAt?: boolean
    id?: boolean
    price?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["subscription"]>

  export type SubscriptionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    expiresAt?: boolean
    id?: boolean
    price?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["subscription"]>

  export type SubscriptionSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    createdAt?: boolean
    expiresAt?: boolean
    id?: boolean
    price?: boolean
    updatedAt?: boolean
    userId?: boolean
    user?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["subscription"]>

  export type SubscriptionSelectScalar = {
    createdAt?: boolean
    expiresAt?: boolean
    id?: boolean
    price?: boolean
    updatedAt?: boolean
    userId?: boolean
  }

  export type SubscriptionOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"createdAt" | "expiresAt" | "id" | "price" | "updatedAt" | "userId", ExtArgs["result"]["subscription"]>
  export type SubscriptionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type SubscriptionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }
  export type SubscriptionIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $SubscriptionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Subscription"
    objects: {
      user: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      createdAt: Date
      expiresAt: Date
      id: string
      price: number | null
      updatedAt: Date
      userId: string
    }, ExtArgs["result"]["subscription"]>
    composites: {}
  }

  type SubscriptionGetPayload<S extends boolean | null | undefined | SubscriptionDefaultArgs> = $Result.GetResult<Prisma.$SubscriptionPayload, S>

  type SubscriptionCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<SubscriptionFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: SubscriptionCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Subscription 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 {SubscriptionFindFirstArgs} args - Arguments to find a Subscription
     * @example
     * // Get one Subscription
     * const subscription = await prisma.subscription.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends SubscriptionFindFirstArgs>(args?: SelectSubset<T, SubscriptionFindFirstArgs<ExtArgs>>): Prisma__SubscriptionClient<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Subscription 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 {SubscriptionFindFirstOrThrowArgs} args - Arguments to find a Subscription
     * @example
     * // Get one Subscription
     * const subscription = await prisma.subscription.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends SubscriptionFindFirstOrThrowArgs>(args?: SelectSubset<T, SubscriptionFindFirstOrThrowArgs<ExtArgs>>): Prisma__SubscriptionClient<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Subscriptions 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 {SubscriptionFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Subscriptions
     * const subscriptions = await prisma.subscription.findMany()
     * 
     * // Get first 10 Subscriptions
     * const subscriptions = await prisma.subscription.findMany({ take: 10 })
     * 
     * // Only select the `createdAt`
     * const subscriptionWithCreatedAtOnly = await prisma.subscription.findMany({ select: { createdAt: true } })
     * 
     */
    findMany<T extends SubscriptionFindManyArgs>(args?: SelectSubset<T, SubscriptionFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Subscription.
     * @param {SubscriptionCreateArgs} args - Arguments to create a Subscription.
     * @example
     * // Create one Subscription
     * const Subscription = await prisma.subscription.create({
     *   data: {
     *     // ... data to create a Subscription
     *   }
     * })
     * 
     */
    create<T extends SubscriptionCreateArgs>(args: SelectSubset<T, SubscriptionCreateArgs<ExtArgs>>): Prisma__SubscriptionClient<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Subscriptions and returns the data saved in the database.
     * @param {SubscriptionCreateManyAndReturnArgs} args - Arguments to create many Subscriptions.
     * @example
     * // Create many Subscriptions
     * const subscription = await prisma.subscription.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Subscriptions and only return the `createdAt`
     * const subscriptionWithCreatedAtOnly = await prisma.subscription.createManyAndReturn({
     *   select: { createdAt: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends SubscriptionCreateManyAndReturnArgs>(args?: SelectSubset<T, SubscriptionCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Subscription.
     * @param {SubscriptionDeleteArgs} args - Arguments to delete one Subscription.
     * @example
     * // Delete one Subscription
     * const Subscription = await prisma.subscription.delete({
     *   where: {
     *     // ... filter to delete one Subscription
     *   }
     * })
     * 
     */
    delete<T extends SubscriptionDeleteArgs>(args: SelectSubset<T, SubscriptionDeleteArgs<ExtArgs>>): Prisma__SubscriptionClient<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Subscription.
     * @param {SubscriptionUpdateArgs} args - Arguments to update one Subscription.
     * @example
     * // Update one Subscription
     * const subscription = await prisma.subscription.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SubscriptionUpdateArgs>(args: SelectSubset<T, SubscriptionUpdateArgs<ExtArgs>>): Prisma__SubscriptionClient<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more Subscriptions and returns the data updated in the database.
     * @param {SubscriptionUpdateManyAndReturnArgs} args - Arguments to update many Subscriptions.
     * @example
     * // Update many Subscriptions
     * const subscription = await prisma.subscription.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Subscriptions and only return the `createdAt`
     * const subscriptionWithCreatedAtOnly = await prisma.subscription.updateManyAndReturn({
     *   select: { createdAt: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends SubscriptionUpdateManyAndReturnArgs>(args: SelectSubset<T, SubscriptionUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a Subscription.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SubscriptionAggregateArgs} 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 SubscriptionAggregateArgs>(args: Subset<T, SubscriptionAggregateArgs>): Prisma.PrismaPromise<GetSubscriptionAggregateType<T>>

    /**
     * Group by Subscription.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SubscriptionGroupByArgs} 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 SubscriptionGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SubscriptionGroupByArgs['orderBy'] }
        : { orderBy?: SubscriptionGroupByArgs['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, SubscriptionGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSubscriptionGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Subscription model
   */
  readonly fields: SubscriptionFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Subscription.
   * 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__SubscriptionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    user<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 Subscription model
   */
  interface SubscriptionFieldRefs {
    readonly createdAt: FieldRef<"Subscription", 'DateTime'>
    readonly expiresAt: FieldRef<"Subscription", 'DateTime'>
    readonly id: FieldRef<"Subscription", 'String'>
    readonly price: FieldRef<"Subscription", 'Float'>
    readonly updatedAt: FieldRef<"Subscription", 'DateTime'>
    readonly userId: FieldRef<"Subscription", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Subscription findUnique
   */
  export type SubscriptionFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter, which Subscription to fetch.
     */
    where: SubscriptionWhereUniqueInput
  }

  /**
   * Subscription findUniqueOrThrow
   */
  export type SubscriptionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter, which Subscription to fetch.
     */
    where: SubscriptionWhereUniqueInput
  }

  /**
   * Subscription findFirst
   */
  export type SubscriptionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter, which Subscription to fetch.
     */
    where?: SubscriptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscriptions to fetch.
     */
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Subscriptions.
     */
    cursor?: SubscriptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscriptions 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` Subscriptions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Subscriptions.
     */
    distinct?: SubscriptionScalarFieldEnum | SubscriptionScalarFieldEnum[]
  }

  /**
   * Subscription findFirstOrThrow
   */
  export type SubscriptionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter, which Subscription to fetch.
     */
    where?: SubscriptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscriptions to fetch.
     */
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Subscriptions.
     */
    cursor?: SubscriptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscriptions 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` Subscriptions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Subscriptions.
     */
    distinct?: SubscriptionScalarFieldEnum | SubscriptionScalarFieldEnum[]
  }

  /**
   * Subscription findMany
   */
  export type SubscriptionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter, which Subscriptions to fetch.
     */
    where?: SubscriptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscriptions to fetch.
     */
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Subscriptions.
     */
    cursor?: SubscriptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscriptions 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` Subscriptions.
     */
    skip?: number
    distinct?: SubscriptionScalarFieldEnum | SubscriptionScalarFieldEnum[]
  }

  /**
   * Subscription create
   */
  export type SubscriptionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * The data needed to create a Subscription.
     */
    data: XOR<SubscriptionCreateInput, SubscriptionUncheckedCreateInput>
  }

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

  /**
   * Subscription createManyAndReturn
   */
  export type SubscriptionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * The data used to create many Subscriptions.
     */
    data: SubscriptionCreateManyInput | SubscriptionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Subscription update
   */
  export type SubscriptionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * The data needed to update a Subscription.
     */
    data: XOR<SubscriptionUpdateInput, SubscriptionUncheckedUpdateInput>
    /**
     * Choose, which Subscription to update.
     */
    where: SubscriptionWhereUniqueInput
  }

  /**
   * Subscription updateMany
   */
  export type SubscriptionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Subscriptions.
     */
    data: XOR<SubscriptionUpdateManyMutationInput, SubscriptionUncheckedUpdateManyInput>
    /**
     * Filter which Subscriptions to update
     */
    where?: SubscriptionWhereInput
    /**
     * Limit how many Subscriptions to update.
     */
    limit?: number
  }

  /**
   * Subscription updateManyAndReturn
   */
  export type SubscriptionUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * The data used to update Subscriptions.
     */
    data: XOR<SubscriptionUpdateManyMutationInput, SubscriptionUncheckedUpdateManyInput>
    /**
     * Filter which Subscriptions to update
     */
    where?: SubscriptionWhereInput
    /**
     * Limit how many Subscriptions to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Subscription upsert
   */
  export type SubscriptionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * The filter to search for the Subscription to update in case it exists.
     */
    where: SubscriptionWhereUniqueInput
    /**
     * In case the Subscription found by the `where` argument doesn't exist, create a new Subscription with this data.
     */
    create: XOR<SubscriptionCreateInput, SubscriptionUncheckedCreateInput>
    /**
     * In case the Subscription was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SubscriptionUpdateInput, SubscriptionUncheckedUpdateInput>
  }

  /**
   * Subscription delete
   */
  export type SubscriptionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    /**
     * Filter which Subscription to delete.
     */
    where: SubscriptionWhereUniqueInput
  }

  /**
   * Subscription deleteMany
   */
  export type SubscriptionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Subscriptions to delete
     */
    where?: SubscriptionWhereInput
    /**
     * Limit how many Subscriptions to delete.
     */
    limit?: number
  }

  /**
   * Subscription without action
   */
  export type SubscriptionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
  }


  /**
   * Model Tag
   */

  export type AggregateTag = {
    _count: TagCountAggregateOutputType | null
    _min: TagMinAggregateOutputType | null
    _max: TagMaxAggregateOutputType | null
  }

  export type TagMinAggregateOutputType = {
    id: string | null
    name: string | null
    userId: string | null
  }

  export type TagMaxAggregateOutputType = {
    id: string | null
    name: string | null
    userId: string | null
  }

  export type TagCountAggregateOutputType = {
    id: number
    name: number
    userId: number
    _all: number
  }


  export type TagMinAggregateInputType = {
    id?: true
    name?: true
    userId?: true
  }

  export type TagMaxAggregateInputType = {
    id?: true
    name?: true
    userId?: true
  }

  export type TagCountAggregateInputType = {
    id?: true
    name?: true
    userId?: true
    _all?: true
  }

  export type TagAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Tag to aggregate.
     */
    where?: TagWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Tags to fetch.
     */
    orderBy?: TagOrderByWithRelationInput | TagOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TagWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Tags 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` Tags.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Tags
    **/
    _count?: true | TagCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TagMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TagMaxAggregateInputType
  }

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




  export type TagGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TagWhereInput
    orderBy?: TagOrderByWithAggregationInput | TagOrderByWithAggregationInput[]
    by: TagScalarFieldEnum[] | TagScalarFieldEnum
    having?: TagScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TagCountAggregateInputType | true
    _min?: TagMinAggregateInputType
    _max?: TagMaxAggregateInputType
  }

  export type TagGroupByOutputType = {
    id: string
    name: string
    userId: string | null
    _count: TagCountAggregateOutputType | null
    _min: TagMinAggregateOutputType | null
    _max: TagMaxAggregateOutputType | null
  }

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


  export type TagSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    userId?: boolean
    activities?: boolean | Tag$activitiesArgs<ExtArgs>
    user?: boolean | Tag$userArgs<ExtArgs>
    _count?: boolean | TagCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["tag"]>

  export type TagSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    userId?: boolean
    user?: boolean | Tag$userArgs<ExtArgs>
  }, ExtArgs["result"]["tag"]>

  export type TagSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    userId?: boolean
    user?: boolean | Tag$userArgs<ExtArgs>
  }, ExtArgs["result"]["tag"]>

  export type TagSelectScalar = {
    id?: boolean
    name?: boolean
    userId?: boolean
  }

  export type TagOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "userId", ExtArgs["result"]["tag"]>
  export type TagInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    activities?: boolean | Tag$activitiesArgs<ExtArgs>
    user?: boolean | Tag$userArgs<ExtArgs>
    _count?: boolean | TagCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type TagIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | Tag$userArgs<ExtArgs>
  }
  export type TagIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    user?: boolean | Tag$userArgs<ExtArgs>
  }

  export type $TagPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Tag"
    objects: {
      activities: Prisma.$OrderPayload<ExtArgs>[]
      user: Prisma.$UserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      userId: string | null
    }, ExtArgs["result"]["tag"]>
    composites: {}
  }

  type TagGetPayload<S extends boolean | null | undefined | TagDefaultArgs> = $Result.GetResult<Prisma.$TagPayload, S>

  type TagCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<TagFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: TagCountAggregateInputType | true
    }

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

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

    /**
     * Find the first Tag 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 {TagFindFirstArgs} args - Arguments to find a Tag
     * @example
     * // Get one Tag
     * const tag = await prisma.tag.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends TagFindFirstArgs>(args?: SelectSubset<T, TagFindFirstArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first Tag 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 {TagFindFirstOrThrowArgs} args - Arguments to find a Tag
     * @example
     * // Get one Tag
     * const tag = await prisma.tag.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends TagFindFirstOrThrowArgs>(args?: SelectSubset<T, TagFindFirstOrThrowArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Tags 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 {TagFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Tags
     * const tags = await prisma.tag.findMany()
     * 
     * // Get first 10 Tags
     * const tags = await prisma.tag.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const tagWithIdOnly = await prisma.tag.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends TagFindManyArgs>(args?: SelectSubset<T, TagFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a Tag.
     * @param {TagCreateArgs} args - Arguments to create a Tag.
     * @example
     * // Create one Tag
     * const Tag = await prisma.tag.create({
     *   data: {
     *     // ... data to create a Tag
     *   }
     * })
     * 
     */
    create<T extends TagCreateArgs>(args: SelectSubset<T, TagCreateArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Tags and returns the data saved in the database.
     * @param {TagCreateManyAndReturnArgs} args - Arguments to create many Tags.
     * @example
     * // Create many Tags
     * const tag = await prisma.tag.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Tags and only return the `id`
     * const tagWithIdOnly = await prisma.tag.createManyAndReturn({
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends TagCreateManyAndReturnArgs>(args?: SelectSubset<T, TagCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a Tag.
     * @param {TagDeleteArgs} args - Arguments to delete one Tag.
     * @example
     * // Delete one Tag
     * const Tag = await prisma.tag.delete({
     *   where: {
     *     // ... filter to delete one Tag
     *   }
     * })
     * 
     */
    delete<T extends TagDeleteArgs>(args: SelectSubset<T, TagDeleteArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one Tag.
     * @param {TagUpdateArgs} args - Arguments to update one Tag.
     * @example
     * // Update one Tag
     * const tag = await prisma.tag.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends TagUpdateArgs>(args: SelectSubset<T, TagUpdateArgs<ExtArgs>>): Prisma__TagClient<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more Tags and returns the data updated in the database.
     * @param {TagUpdateManyAndReturnArgs} args - Arguments to update many Tags.
     * @example
     * // Update many Tags
     * const tag = await prisma.tag.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Tags and only return the `id`
     * const tagWithIdOnly = await prisma.tag.updateManyAndReturn({
     *   select: { id: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends TagUpdateManyAndReturnArgs>(args: SelectSubset<T, TagUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a Tag.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TagAggregateArgs} 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 TagAggregateArgs>(args: Subset<T, TagAggregateArgs>): Prisma.PrismaPromise<GetTagAggregateType<T>>

    /**
     * Group by Tag.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {TagGroupByArgs} 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 TagGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: TagGroupByArgs['orderBy'] }
        : { orderBy?: TagGroupByArgs['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, TagGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetTagGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Tag model
   */
  readonly fields: TagFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Tag.
   * 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__TagClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    activities<T extends Tag$activitiesArgs<ExtArgs> = {}>(args?: Subset<T, Tag$activitiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    user<T extends Tag$userArgs<ExtArgs> = {}>(args?: Subset<T, Tag$userArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    /**
     * 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 Tag model
   */
  interface TagFieldRefs {
    readonly id: FieldRef<"Tag", 'String'>
    readonly name: FieldRef<"Tag", 'String'>
    readonly userId: FieldRef<"Tag", 'String'>
  }
    

  // Custom InputTypes
  /**
   * Tag findUnique
   */
  export type TagFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * Filter, which Tag to fetch.
     */
    where: TagWhereUniqueInput
  }

  /**
   * Tag findUniqueOrThrow
   */
  export type TagFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * Filter, which Tag to fetch.
     */
    where: TagWhereUniqueInput
  }

  /**
   * Tag findFirst
   */
  export type TagFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * Filter, which Tag to fetch.
     */
    where?: TagWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Tags to fetch.
     */
    orderBy?: TagOrderByWithRelationInput | TagOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Tags.
     */
    cursor?: TagWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Tags 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` Tags.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Tags.
     */
    distinct?: TagScalarFieldEnum | TagScalarFieldEnum[]
  }

  /**
   * Tag findFirstOrThrow
   */
  export type TagFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * Filter, which Tag to fetch.
     */
    where?: TagWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Tags to fetch.
     */
    orderBy?: TagOrderByWithRelationInput | TagOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Tags.
     */
    cursor?: TagWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Tags 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` Tags.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Tags.
     */
    distinct?: TagScalarFieldEnum | TagScalarFieldEnum[]
  }

  /**
   * Tag findMany
   */
  export type TagFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * Filter, which Tags to fetch.
     */
    where?: TagWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Tags to fetch.
     */
    orderBy?: TagOrderByWithRelationInput | TagOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Tags.
     */
    cursor?: TagWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Tags 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` Tags.
     */
    skip?: number
    distinct?: TagScalarFieldEnum | TagScalarFieldEnum[]
  }

  /**
   * Tag create
   */
  export type TagCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * The data needed to create a Tag.
     */
    data: XOR<TagCreateInput, TagUncheckedCreateInput>
  }

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

  /**
   * Tag createManyAndReturn
   */
  export type TagCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * The data used to create many Tags.
     */
    data: TagCreateManyInput | TagCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Tag update
   */
  export type TagUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * The data needed to update a Tag.
     */
    data: XOR<TagUpdateInput, TagUncheckedUpdateInput>
    /**
     * Choose, which Tag to update.
     */
    where: TagWhereUniqueInput
  }

  /**
   * Tag updateMany
   */
  export type TagUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Tags.
     */
    data: XOR<TagUpdateManyMutationInput, TagUncheckedUpdateManyInput>
    /**
     * Filter which Tags to update
     */
    where?: TagWhereInput
    /**
     * Limit how many Tags to update.
     */
    limit?: number
  }

  /**
   * Tag updateManyAndReturn
   */
  export type TagUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * The data used to update Tags.
     */
    data: XOR<TagUpdateManyMutationInput, TagUncheckedUpdateManyInput>
    /**
     * Filter which Tags to update
     */
    where?: TagWhereInput
    /**
     * Limit how many Tags to update.
     */
    limit?: number
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagIncludeUpdateManyAndReturn<ExtArgs> | null
  }

  /**
   * Tag upsert
   */
  export type TagUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * The filter to search for the Tag to update in case it exists.
     */
    where: TagWhereUniqueInput
    /**
     * In case the Tag found by the `where` argument doesn't exist, create a new Tag with this data.
     */
    create: XOR<TagCreateInput, TagUncheckedCreateInput>
    /**
     * In case the Tag was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TagUpdateInput, TagUncheckedUpdateInput>
  }

  /**
   * Tag delete
   */
  export type TagDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    /**
     * Filter which Tag to delete.
     */
    where: TagWhereUniqueInput
  }

  /**
   * Tag deleteMany
   */
  export type TagDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Tags to delete
     */
    where?: TagWhereInput
    /**
     * Limit how many Tags to delete.
     */
    limit?: number
  }

  /**
   * Tag.activities
   */
  export type Tag$activitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    where?: OrderWhereInput
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    cursor?: OrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OrderScalarFieldEnum | OrderScalarFieldEnum[]
  }

  /**
   * Tag.user
   */
  export type Tag$userArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    where?: UserWhereInput
  }

  /**
   * Tag without action
   */
  export type TagDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
  }


  /**
   * Model User
   */

  export type AggregateUser = {
    _count: UserCountAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

  export type UserMinAggregateOutputType = {
    accessToken: string | null
    authChallenge: string | null
    createdAt: Date | null
    id: string | null
    provider: $Enums.Provider | null
    role: $Enums.Role | null
    thirdPartyId: string | null
    updatedAt: Date | null
  }

  export type UserMaxAggregateOutputType = {
    accessToken: string | null
    authChallenge: string | null
    createdAt: Date | null
    id: string | null
    provider: $Enums.Provider | null
    role: $Enums.Role | null
    thirdPartyId: string | null
    updatedAt: Date | null
  }

  export type UserCountAggregateOutputType = {
    accessToken: number
    authChallenge: number
    createdAt: number
    id: number
    provider: number
    role: number
    thirdPartyId: number
    updatedAt: number
    _all: number
  }


  export type UserMinAggregateInputType = {
    accessToken?: true
    authChallenge?: true
    createdAt?: true
    id?: true
    provider?: true
    role?: true
    thirdPartyId?: true
    updatedAt?: true
  }

  export type UserMaxAggregateInputType = {
    accessToken?: true
    authChallenge?: true
    createdAt?: true
    id?: true
    provider?: true
    role?: true
    thirdPartyId?: true
    updatedAt?: true
  }

  export type UserCountAggregateInputType = {
    accessToken?: true
    authChallenge?: true
    createdAt?: true
    id?: true
    provider?: true
    role?: true
    thirdPartyId?: true
    updatedAt?: true
    _all?: true
  }

  export type UserAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which User to aggregate.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users 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` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Users
    **/
    _count?: true | UserCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UserMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UserMaxAggregateInputType
  }

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




  export type UserGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserWhereInput
    orderBy?: UserOrderByWithAggregationInput | UserOrderByWithAggregationInput[]
    by: UserScalarFieldEnum[] | UserScalarFieldEnum
    having?: UserScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UserCountAggregateInputType | true
    _min?: UserMinAggregateInputType
    _max?: UserMaxAggregateInputType
  }

  export type UserGroupByOutputType = {
    accessToken: string | null
    authChallenge: string | null
    createdAt: Date
    id: string
    provider: $Enums.Provider
    role: $Enums.Role
    thirdPartyId: string | null
    updatedAt: Date
    _count: UserCountAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

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


  export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    accessToken?: boolean
    authChallenge?: boolean
    createdAt?: boolean
    id?: boolean
    provider?: boolean
    role?: boolean
    thirdPartyId?: boolean
    updatedAt?: boolean
    accessesGet?: boolean | User$accessesGetArgs<ExtArgs>
    accessesGive?: boolean | User$accessesGiveArgs<ExtArgs>
    accounts?: boolean | User$accountsArgs<ExtArgs>
    activities?: boolean | User$activitiesArgs<ExtArgs>
    analytics?: boolean | User$analyticsArgs<ExtArgs>
    apiKeys?: boolean | User$apiKeysArgs<ExtArgs>
    authDevices?: boolean | User$authDevicesArgs<ExtArgs>
    settings?: boolean | User$settingsArgs<ExtArgs>
    subscriptions?: boolean | User$subscriptionsArgs<ExtArgs>
    tags?: boolean | User$tagsArgs<ExtArgs>
    watchlist?: boolean | User$watchlistArgs<ExtArgs>
    SymbolProfile?: boolean | User$SymbolProfileArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>

  export type UserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    accessToken?: boolean
    authChallenge?: boolean
    createdAt?: boolean
    id?: boolean
    provider?: boolean
    role?: boolean
    thirdPartyId?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    accessToken?: boolean
    authChallenge?: boolean
    createdAt?: boolean
    id?: boolean
    provider?: boolean
    role?: boolean
    thirdPartyId?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["user"]>

  export type UserSelectScalar = {
    accessToken?: boolean
    authChallenge?: boolean
    createdAt?: boolean
    id?: boolean
    provider?: boolean
    role?: boolean
    thirdPartyId?: boolean
    updatedAt?: boolean
  }

  export type UserOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"accessToken" | "authChallenge" | "createdAt" | "id" | "provider" | "role" | "thirdPartyId" | "updatedAt", ExtArgs["result"]["user"]>
  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    accessesGet?: boolean | User$accessesGetArgs<ExtArgs>
    accessesGive?: boolean | User$accessesGiveArgs<ExtArgs>
    accounts?: boolean | User$accountsArgs<ExtArgs>
    activities?: boolean | User$activitiesArgs<ExtArgs>
    analytics?: boolean | User$analyticsArgs<ExtArgs>
    apiKeys?: boolean | User$apiKeysArgs<ExtArgs>
    authDevices?: boolean | User$authDevicesArgs<ExtArgs>
    settings?: boolean | User$settingsArgs<ExtArgs>
    subscriptions?: boolean | User$subscriptionsArgs<ExtArgs>
    tags?: boolean | User$tagsArgs<ExtArgs>
    watchlist?: boolean | User$watchlistArgs<ExtArgs>
    SymbolProfile?: boolean | User$SymbolProfileArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type UserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
  export type UserIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      accessesGet: Prisma.$AccessPayload<ExtArgs>[]
      accessesGive: Prisma.$AccessPayload<ExtArgs>[]
      accounts: Prisma.$AccountPayload<ExtArgs>[]
      activities: Prisma.$OrderPayload<ExtArgs>[]
      analytics: Prisma.$AnalyticsPayload<ExtArgs> | null
      apiKeys: Prisma.$ApiKeyPayload<ExtArgs>[]
      authDevices: Prisma.$AuthDevicePayload<ExtArgs>[]
      settings: Prisma.$SettingsPayload<ExtArgs> | null
      subscriptions: Prisma.$SubscriptionPayload<ExtArgs>[]
      tags: Prisma.$TagPayload<ExtArgs>[]
      watchlist: Prisma.$SymbolProfilePayload<ExtArgs>[]
      SymbolProfile: Prisma.$SymbolProfilePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      accessToken: string | null
      authChallenge: string | null
      createdAt: Date
      id: string
      provider: $Enums.Provider
      role: $Enums.Role
      thirdPartyId: string | null
      updatedAt: Date
    }, ExtArgs["result"]["user"]>
    composites: {}
  }

  type UserGetPayload<S extends boolean | null | undefined | UserDefaultArgs> = $Result.GetResult<Prisma.$UserPayload, S>

  type UserCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
    Omit<UserFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
      select?: UserCountAggregateInputType | true
    }

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

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

    /**
     * Find the first User 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 {UserFindFirstArgs} args - Arguments to find a User
     * @example
     * // Get one User
     * const user = await prisma.user.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends UserFindFirstArgs>(args?: SelectSubset<T, UserFindFirstArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>

    /**
     * Find the first User 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 {UserFindFirstOrThrowArgs} args - Arguments to find a User
     * @example
     * // Get one User
     * const user = await prisma.user.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends UserFindFirstOrThrowArgs>(args?: SelectSubset<T, UserFindFirstOrThrowArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Find zero or more Users 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 {UserFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Users
     * const users = await prisma.user.findMany()
     * 
     * // Get first 10 Users
     * const users = await prisma.user.findMany({ take: 10 })
     * 
     * // Only select the `accessToken`
     * const userWithAccessTokenOnly = await prisma.user.findMany({ select: { accessToken: true } })
     * 
     */
    findMany<T extends UserFindManyArgs>(args?: SelectSubset<T, UserFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>

    /**
     * Create a User.
     * @param {UserCreateArgs} args - Arguments to create a User.
     * @example
     * // Create one User
     * const User = await prisma.user.create({
     *   data: {
     *     // ... data to create a User
     *   }
     * })
     * 
     */
    create<T extends UserCreateArgs>(args: SelectSubset<T, UserCreateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

    /**
     * Create many Users and returns the data saved in the database.
     * @param {UserCreateManyAndReturnArgs} args - Arguments to create many Users.
     * @example
     * // Create many Users
     * const user = await prisma.user.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Users and only return the `accessToken`
     * const userWithAccessTokenOnly = await prisma.user.createManyAndReturn({
     *   select: { accessToken: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends UserCreateManyAndReturnArgs>(args?: SelectSubset<T, UserCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>

    /**
     * Delete a User.
     * @param {UserDeleteArgs} args - Arguments to delete one User.
     * @example
     * // Delete one User
     * const User = await prisma.user.delete({
     *   where: {
     *     // ... filter to delete one User
     *   }
     * })
     * 
     */
    delete<T extends UserDeleteArgs>(args: SelectSubset<T, UserDeleteArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

    /**
     * Update one User.
     * @param {UserUpdateArgs} args - Arguments to update one User.
     * @example
     * // Update one User
     * const user = await prisma.user.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends UserUpdateArgs>(args: SelectSubset<T, UserUpdateArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>

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

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

    /**
     * Update zero or more Users and returns the data updated in the database.
     * @param {UserUpdateManyAndReturnArgs} args - Arguments to update many Users.
     * @example
     * // Update many Users
     * const user = await prisma.user.updateManyAndReturn({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Update zero or more Users and only return the `accessToken`
     * const userWithAccessTokenOnly = await prisma.user.updateManyAndReturn({
     *   select: { accessToken: true },
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    updateManyAndReturn<T extends UserUpdateManyAndReturnArgs>(args: SelectSubset<T, UserUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>

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


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

    /**
     * Allows you to perform aggregations operations on a User.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserAggregateArgs} 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 UserAggregateArgs>(args: Subset<T, UserAggregateArgs>): Prisma.PrismaPromise<GetUserAggregateType<T>>

    /**
     * Group by User.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UserGroupByArgs} 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 UserGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: UserGroupByArgs['orderBy'] }
        : { orderBy?: UserGroupByArgs['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, UserGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUserGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the User model
   */
  readonly fields: UserFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for User.
   * 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__UserClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    accessesGet<T extends User$accessesGetArgs<ExtArgs> = {}>(args?: Subset<T, User$accessesGetArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccessPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    accessesGive<T extends User$accessesGiveArgs<ExtArgs> = {}>(args?: Subset<T, User$accessesGiveArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccessPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    accounts<T extends User$accountsArgs<ExtArgs> = {}>(args?: Subset<T, User$accountsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AccountPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    activities<T extends User$activitiesArgs<ExtArgs> = {}>(args?: Subset<T, User$activitiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    analytics<T extends User$analyticsArgs<ExtArgs> = {}>(args?: Subset<T, User$analyticsArgs<ExtArgs>>): Prisma__AnalyticsClient<$Result.GetResult<Prisma.$AnalyticsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    apiKeys<T extends User$apiKeysArgs<ExtArgs> = {}>(args?: Subset<T, User$apiKeysArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ApiKeyPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    authDevices<T extends User$authDevicesArgs<ExtArgs> = {}>(args?: Subset<T, User$authDevicesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AuthDevicePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    settings<T extends User$settingsArgs<ExtArgs> = {}>(args?: Subset<T, User$settingsArgs<ExtArgs>>): Prisma__SettingsClient<$Result.GetResult<Prisma.$SettingsPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
    subscriptions<T extends User$subscriptionsArgs<ExtArgs> = {}>(args?: Subset<T, User$subscriptionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubscriptionPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    tags<T extends User$tagsArgs<ExtArgs> = {}>(args?: Subset<T, User$tagsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$TagPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    watchlist<T extends User$watchlistArgs<ExtArgs> = {}>(args?: Subset<T, User$watchlistArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    SymbolProfile<T extends User$SymbolProfileArgs<ExtArgs> = {}>(args?: Subset<T, User$SymbolProfileArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SymbolProfilePayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
    /**
     * 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 User model
   */
  interface UserFieldRefs {
    readonly accessToken: FieldRef<"User", 'String'>
    readonly authChallenge: FieldRef<"User", 'String'>
    readonly createdAt: FieldRef<"User", 'DateTime'>
    readonly id: FieldRef<"User", 'String'>
    readonly provider: FieldRef<"User", 'Provider'>
    readonly role: FieldRef<"User", 'Role'>
    readonly thirdPartyId: FieldRef<"User", 'String'>
    readonly updatedAt: FieldRef<"User", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * User findUnique
   */
  export type UserFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User findUniqueOrThrow
   */
  export type UserFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User findFirst
   */
  export type UserFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users 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` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Users.
     */
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User findFirstOrThrow
   */
  export type UserFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which User to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users 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` Users.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Users.
     */
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User findMany
   */
  export type UserFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter, which Users to fetch.
     */
    where?: UserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Users to fetch.
     */
    orderBy?: UserOrderByWithRelationInput | UserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Users.
     */
    cursor?: UserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Users 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` Users.
     */
    skip?: number
    distinct?: UserScalarFieldEnum | UserScalarFieldEnum[]
  }

  /**
   * User create
   */
  export type UserCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * The data needed to create a User.
     */
    data: XOR<UserCreateInput, UserUncheckedCreateInput>
  }

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

  /**
   * User createManyAndReturn
   */
  export type UserCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * The data used to create many Users.
     */
    data: UserCreateManyInput | UserCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * User update
   */
  export type UserUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * The data needed to update a User.
     */
    data: XOR<UserUpdateInput, UserUncheckedUpdateInput>
    /**
     * Choose, which User to update.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User updateMany
   */
  export type UserUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Users.
     */
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
    /**
     * Filter which Users to update
     */
    where?: UserWhereInput
    /**
     * Limit how many Users to update.
     */
    limit?: number
  }

  /**
   * User updateManyAndReturn
   */
  export type UserUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelectUpdateManyAndReturn<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * The data used to update Users.
     */
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyInput>
    /**
     * Filter which Users to update
     */
    where?: UserWhereInput
    /**
     * Limit how many Users to update.
     */
    limit?: number
  }

  /**
   * User upsert
   */
  export type UserUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * The filter to search for the User to update in case it exists.
     */
    where: UserWhereUniqueInput
    /**
     * In case the User found by the `where` argument doesn't exist, create a new User with this data.
     */
    create: XOR<UserCreateInput, UserUncheckedCreateInput>
    /**
     * In case the User was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UserUpdateInput, UserUncheckedUpdateInput>
  }

  /**
   * User delete
   */
  export type UserDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
    /**
     * Filter which User to delete.
     */
    where: UserWhereUniqueInput
  }

  /**
   * User deleteMany
   */
  export type UserDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Users to delete
     */
    where?: UserWhereInput
    /**
     * Limit how many Users to delete.
     */
    limit?: number
  }

  /**
   * User.accessesGet
   */
  export type User$accessesGetArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    where?: AccessWhereInput
    orderBy?: AccessOrderByWithRelationInput | AccessOrderByWithRelationInput[]
    cursor?: AccessWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AccessScalarFieldEnum | AccessScalarFieldEnum[]
  }

  /**
   * User.accessesGive
   */
  export type User$accessesGiveArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Access
     */
    select?: AccessSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Access
     */
    omit?: AccessOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccessInclude<ExtArgs> | null
    where?: AccessWhereInput
    orderBy?: AccessOrderByWithRelationInput | AccessOrderByWithRelationInput[]
    cursor?: AccessWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AccessScalarFieldEnum | AccessScalarFieldEnum[]
  }

  /**
   * User.accounts
   */
  export type User$accountsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Account
     */
    select?: AccountSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Account
     */
    omit?: AccountOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AccountInclude<ExtArgs> | null
    where?: AccountWhereInput
    orderBy?: AccountOrderByWithRelationInput | AccountOrderByWithRelationInput[]
    cursor?: AccountWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AccountScalarFieldEnum | AccountScalarFieldEnum[]
  }

  /**
   * User.activities
   */
  export type User$activitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Order
     */
    omit?: OrderOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    where?: OrderWhereInput
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    cursor?: OrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OrderScalarFieldEnum | OrderScalarFieldEnum[]
  }

  /**
   * User.analytics
   */
  export type User$analyticsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Analytics
     */
    select?: AnalyticsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Analytics
     */
    omit?: AnalyticsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AnalyticsInclude<ExtArgs> | null
    where?: AnalyticsWhereInput
  }

  /**
   * User.apiKeys
   */
  export type User$apiKeysArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApiKey
     */
    select?: ApiKeySelect<ExtArgs> | null
    /**
     * Omit specific fields from the ApiKey
     */
    omit?: ApiKeyOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ApiKeyInclude<ExtArgs> | null
    where?: ApiKeyWhereInput
    orderBy?: ApiKeyOrderByWithRelationInput | ApiKeyOrderByWithRelationInput[]
    cursor?: ApiKeyWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ApiKeyScalarFieldEnum | ApiKeyScalarFieldEnum[]
  }

  /**
   * User.authDevices
   */
  export type User$authDevicesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AuthDevice
     */
    select?: AuthDeviceSelect<ExtArgs> | null
    /**
     * Omit specific fields from the AuthDevice
     */
    omit?: AuthDeviceOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AuthDeviceInclude<ExtArgs> | null
    where?: AuthDeviceWhereInput
    orderBy?: AuthDeviceOrderByWithRelationInput | AuthDeviceOrderByWithRelationInput[]
    cursor?: AuthDeviceWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AuthDeviceScalarFieldEnum | AuthDeviceScalarFieldEnum[]
  }

  /**
   * User.settings
   */
  export type User$settingsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Settings
     */
    select?: SettingsSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Settings
     */
    omit?: SettingsOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SettingsInclude<ExtArgs> | null
    where?: SettingsWhereInput
  }

  /**
   * User.subscriptions
   */
  export type User$subscriptionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscription
     */
    select?: SubscriptionSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Subscription
     */
    omit?: SubscriptionOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SubscriptionInclude<ExtArgs> | null
    where?: SubscriptionWhereInput
    orderBy?: SubscriptionOrderByWithRelationInput | SubscriptionOrderByWithRelationInput[]
    cursor?: SubscriptionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SubscriptionScalarFieldEnum | SubscriptionScalarFieldEnum[]
  }

  /**
   * User.tags
   */
  export type User$tagsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Tag
     */
    select?: TagSelect<ExtArgs> | null
    /**
     * Omit specific fields from the Tag
     */
    omit?: TagOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TagInclude<ExtArgs> | null
    where?: TagWhereInput
    orderBy?: TagOrderByWithRelationInput | TagOrderByWithRelationInput[]
    cursor?: TagWhereUniqueInput
    take?: number
    skip?: number
    distinct?: TagScalarFieldEnum | TagScalarFieldEnum[]
  }

  /**
   * User.watchlist
   */
  export type User$watchlistArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    where?: SymbolProfileWhereInput
    orderBy?: SymbolProfileOrderByWithRelationInput | SymbolProfileOrderByWithRelationInput[]
    cursor?: SymbolProfileWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SymbolProfileScalarFieldEnum | SymbolProfileScalarFieldEnum[]
  }

  /**
   * User.SymbolProfile
   */
  export type User$SymbolProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SymbolProfile
     */
    select?: SymbolProfileSelect<ExtArgs> | null
    /**
     * Omit specific fields from the SymbolProfile
     */
    omit?: SymbolProfileOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SymbolProfileInclude<ExtArgs> | null
    where?: SymbolProfileWhereInput
    orderBy?: SymbolProfileOrderByWithRelationInput | SymbolProfileOrderByWithRelationInput[]
    cursor?: SymbolProfileWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SymbolProfileScalarFieldEnum | SymbolProfileScalarFieldEnum[]
  }

  /**
   * User without action
   */
  export type UserDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the User
     */
    select?: UserSelect<ExtArgs> | null
    /**
     * Omit specific fields from the User
     */
    omit?: UserOmit<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserInclude<ExtArgs> | null
  }


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

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


  export const AccessScalarFieldEnum: {
    alias: 'alias',
    createdAt: 'createdAt',
    granteeUserId: 'granteeUserId',
    id: 'id',
    permissions: 'permissions',
    settings: 'settings',
    updatedAt: 'updatedAt',
    userId: 'userId'
  };

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


  export const AccountScalarFieldEnum: {
    balance: 'balance',
    comment: 'comment',
    createdAt: 'createdAt',
    currency: 'currency',
    id: 'id',
    isExcluded: 'isExcluded',
    name: 'name',
    platformId: 'platformId',
    updatedAt: 'updatedAt',
    userId: 'userId'
  };

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


  export const AccountBalanceScalarFieldEnum: {
    accountId: 'accountId',
    createdAt: 'createdAt',
    date: 'date',
    id: 'id',
    updatedAt: 'updatedAt',
    userId: 'userId',
    value: 'value'
  };

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


  export const AnalyticsScalarFieldEnum: {
    activityCount: 'activityCount',
    country: 'country',
    dataProviderGhostfolioDailyRequests: 'dataProviderGhostfolioDailyRequests',
    lastRequestAt: 'lastRequestAt',
    updatedAt: 'updatedAt',
    userId: 'userId'
  };

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


  export const ApiKeyScalarFieldEnum: {
    createdAt: 'createdAt',
    hashedKey: 'hashedKey',
    id: 'id',
    updatedAt: 'updatedAt',
    userId: 'userId'
  };

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


  export const AssetProfileResolutionScalarFieldEnum: {
    createdAt: 'createdAt',
    currency: 'currency',
    dataSourceOrigin: 'dataSourceOrigin',
    dataSourceTarget: 'dataSourceTarget',
    id: 'id',
    requestCount: 'requestCount',
    symbolOrigin: 'symbolOrigin',
    symbolTarget: 'symbolTarget',
    updatedAt: 'updatedAt'
  };

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


  export const AuthDeviceScalarFieldEnum: {
    createdAt: 'createdAt',
    credentialId: 'credentialId',
    credentialPublicKey: 'credentialPublicKey',
    counter: 'counter',
    id: 'id',
    updatedAt: 'updatedAt',
    userId: 'userId'
  };

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


  export const MarketDataScalarFieldEnum: {
    createdAt: 'createdAt',
    dataSource: 'dataSource',
    date: 'date',
    id: 'id',
    marketPrice: 'marketPrice',
    state: 'state',
    symbol: 'symbol'
  };

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


  export const OrderScalarFieldEnum: {
    accountId: 'accountId',
    accountUserId: 'accountUserId',
    comment: 'comment',
    createdAt: 'createdAt',
    currency: 'currency',
    date: 'date',
    fee: 'fee',
    id: 'id',
    isDraft: 'isDraft',
    quantity: 'quantity',
    symbolProfileId: 'symbolProfileId',
    type: 'type',
    unitPrice: 'unitPrice',
    updatedAt: 'updatedAt',
    userId: 'userId'
  };

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


  export const PlatformScalarFieldEnum: {
    id: 'id',
    name: 'name',
    url: 'url'
  };

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


  export const PropertyScalarFieldEnum: {
    key: 'key',
    value: 'value'
  };

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


  export const SettingsScalarFieldEnum: {
    settings: 'settings',
    updatedAt: 'updatedAt',
    userId: 'userId'
  };

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


  export const SymbolProfileScalarFieldEnum: {
    assetClass: 'assetClass',
    assetSubClass: 'assetSubClass',
    comment: 'comment',
    countries: 'countries',
    createdAt: 'createdAt',
    currency: 'currency',
    cusip: 'cusip',
    dataSource: 'dataSource',
    figi: 'figi',
    figiComposite: 'figiComposite',
    figiShareClass: 'figiShareClass',
    holdings: 'holdings',
    id: 'id',
    isActive: 'isActive',
    isin: 'isin',
    name: 'name',
    updatedAt: 'updatedAt',
    scraperConfiguration: 'scraperConfiguration',
    sectors: 'sectors',
    symbol: 'symbol',
    symbolMapping: 'symbolMapping',
    url: 'url',
    userId: 'userId'
  };

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


  export const SymbolProfileOverridesScalarFieldEnum: {
    assetClass: 'assetClass',
    assetSubClass: 'assetSubClass',
    countries: 'countries',
    holdings: 'holdings',
    name: 'name',
    sectors: 'sectors',
    symbolProfileId: 'symbolProfileId',
    updatedAt: 'updatedAt',
    url: 'url'
  };

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


  export const SubscriptionScalarFieldEnum: {
    createdAt: 'createdAt',
    expiresAt: 'expiresAt',
    id: 'id',
    price: 'price',
    updatedAt: 'updatedAt',
    userId: 'userId'
  };

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


  export const TagScalarFieldEnum: {
    id: 'id',
    name: 'name',
    userId: 'userId'
  };

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


  export const UserScalarFieldEnum: {
    accessToken: 'accessToken',
    authChallenge: 'authChallenge',
    createdAt: 'createdAt',
    id: 'id',
    provider: 'provider',
    role: 'role',
    thirdPartyId: 'thirdPartyId',
    updatedAt: 'updatedAt'
  };

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


  export const SortOrder: {
    asc: 'asc',
    desc: 'desc'
  };

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


  export const JsonNullValueInput: {
    JsonNull: typeof JsonNull
  };

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


  export const NullableJsonNullValueInput: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull
  };

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


  export const QueryMode: {
    default: 'default',
    insensitive: 'insensitive'
  };

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


  export const JsonNullValueFilter: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull,
    AnyNull: typeof AnyNull
  };

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


  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 'String[]'
   */
  export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>
    


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * Reference to a field of type 'DateTime[]'
   */
  export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
    


  /**
   * Reference to a field of type 'AccessPermission[]'
   */
  export type ListEnumAccessPermissionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AccessPermission[]'>
    


  /**
   * Reference to a field of type 'AccessPermission'
   */
  export type EnumAccessPermissionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AccessPermission'>
    


  /**
   * Reference to a field of type 'Json'
   */
  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
    


  /**
   * Reference to a field of type 'QueryMode'
   */
  export type EnumQueryModeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'QueryMode'>
    


  /**
   * Reference to a field of type 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    


  /**
   * Reference to a field of type 'Float[]'
   */
  export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
    


  /**
   * Reference to a field of type 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * Reference to a field of type 'Int'
   */
  export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
    


  /**
   * Reference to a field of type 'Int[]'
   */
  export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>
    


  /**
   * Reference to a field of type 'DataSource'
   */
  export type EnumDataSourceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DataSource'>
    


  /**
   * Reference to a field of type 'DataSource[]'
   */
  export type ListEnumDataSourceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DataSource[]'>
    


  /**
   * Reference to a field of type 'Bytes'
   */
  export type BytesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Bytes'>
    


  /**
   * Reference to a field of type 'Bytes[]'
   */
  export type ListBytesFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Bytes[]'>
    


  /**
   * Reference to a field of type 'MarketDataState'
   */
  export type EnumMarketDataStateFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MarketDataState'>
    


  /**
   * Reference to a field of type 'MarketDataState[]'
   */
  export type ListEnumMarketDataStateFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MarketDataState[]'>
    


  /**
   * Reference to a field of type 'Type'
   */
  export type EnumTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Type'>
    


  /**
   * Reference to a field of type 'Type[]'
   */
  export type ListEnumTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Type[]'>
    


  /**
   * Reference to a field of type 'AssetClass'
   */
  export type EnumAssetClassFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AssetClass'>
    


  /**
   * Reference to a field of type 'AssetClass[]'
   */
  export type ListEnumAssetClassFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AssetClass[]'>
    


  /**
   * Reference to a field of type 'AssetSubClass'
   */
  export type EnumAssetSubClassFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AssetSubClass'>
    


  /**
   * Reference to a field of type 'AssetSubClass[]'
   */
  export type ListEnumAssetSubClassFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AssetSubClass[]'>
    


  /**
   * Reference to a field of type 'Provider'
   */
  export type EnumProviderFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Provider'>
    


  /**
   * Reference to a field of type 'Provider[]'
   */
  export type ListEnumProviderFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Provider[]'>
    


  /**
   * Reference to a field of type 'Role'
   */
  export type EnumRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Role'>
    


  /**
   * Reference to a field of type 'Role[]'
   */
  export type ListEnumRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Role[]'>
    
  /**
   * Deep Input Types
   */


  export type AccessWhereInput = {
    AND?: AccessWhereInput | AccessWhereInput[]
    OR?: AccessWhereInput[]
    NOT?: AccessWhereInput | AccessWhereInput[]
    alias?: StringNullableFilter<"Access"> | string | null
    createdAt?: DateTimeFilter<"Access"> | Date | string
    granteeUserId?: StringNullableFilter<"Access"> | string | null
    id?: StringFilter<"Access"> | string
    permissions?: EnumAccessPermissionNullableListFilter<"Access">
    settings?: JsonFilter<"Access">
    updatedAt?: DateTimeFilter<"Access"> | Date | string
    userId?: StringFilter<"Access"> | string
    granteeUser?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type AccessOrderByWithRelationInput = {
    alias?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    granteeUserId?: SortOrderInput | SortOrder
    id?: SortOrder
    permissions?: SortOrder
    settings?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    granteeUser?: UserOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
  }

  export type AccessWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AccessWhereInput | AccessWhereInput[]
    OR?: AccessWhereInput[]
    NOT?: AccessWhereInput | AccessWhereInput[]
    alias?: StringNullableFilter<"Access"> | string | null
    createdAt?: DateTimeFilter<"Access"> | Date | string
    granteeUserId?: StringNullableFilter<"Access"> | string | null
    permissions?: EnumAccessPermissionNullableListFilter<"Access">
    settings?: JsonFilter<"Access">
    updatedAt?: DateTimeFilter<"Access"> | Date | string
    userId?: StringFilter<"Access"> | string
    granteeUser?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id">

  export type AccessOrderByWithAggregationInput = {
    alias?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    granteeUserId?: SortOrderInput | SortOrder
    id?: SortOrder
    permissions?: SortOrder
    settings?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    _count?: AccessCountOrderByAggregateInput
    _max?: AccessMaxOrderByAggregateInput
    _min?: AccessMinOrderByAggregateInput
  }

  export type AccessScalarWhereWithAggregatesInput = {
    AND?: AccessScalarWhereWithAggregatesInput | AccessScalarWhereWithAggregatesInput[]
    OR?: AccessScalarWhereWithAggregatesInput[]
    NOT?: AccessScalarWhereWithAggregatesInput | AccessScalarWhereWithAggregatesInput[]
    alias?: StringNullableWithAggregatesFilter<"Access"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Access"> | Date | string
    granteeUserId?: StringNullableWithAggregatesFilter<"Access"> | string | null
    id?: StringWithAggregatesFilter<"Access"> | string
    permissions?: EnumAccessPermissionNullableListFilter<"Access">
    settings?: JsonWithAggregatesFilter<"Access">
    updatedAt?: DateTimeWithAggregatesFilter<"Access"> | Date | string
    userId?: StringWithAggregatesFilter<"Access"> | string
  }

  export type AccountWhereInput = {
    AND?: AccountWhereInput | AccountWhereInput[]
    OR?: AccountWhereInput[]
    NOT?: AccountWhereInput | AccountWhereInput[]
    balance?: FloatFilter<"Account"> | number
    comment?: StringNullableFilter<"Account"> | string | null
    createdAt?: DateTimeFilter<"Account"> | Date | string
    currency?: StringNullableFilter<"Account"> | string | null
    id?: StringFilter<"Account"> | string
    isExcluded?: BoolFilter<"Account"> | boolean
    name?: StringNullableFilter<"Account"> | string | null
    platformId?: StringNullableFilter<"Account"> | string | null
    updatedAt?: DateTimeFilter<"Account"> | Date | string
    userId?: StringFilter<"Account"> | string
    activities?: OrderListRelationFilter
    balances?: AccountBalanceListRelationFilter
    platform?: XOR<PlatformNullableScalarRelationFilter, PlatformWhereInput> | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type AccountOrderByWithRelationInput = {
    balance?: SortOrder
    comment?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    currency?: SortOrderInput | SortOrder
    id?: SortOrder
    isExcluded?: SortOrder
    name?: SortOrderInput | SortOrder
    platformId?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    activities?: OrderOrderByRelationAggregateInput
    balances?: AccountBalanceOrderByRelationAggregateInput
    platform?: PlatformOrderByWithRelationInput
    user?: UserOrderByWithRelationInput
  }

  export type AccountWhereUniqueInput = Prisma.AtLeast<{
    id_userId?: AccountIdUserIdCompoundUniqueInput
    AND?: AccountWhereInput | AccountWhereInput[]
    OR?: AccountWhereInput[]
    NOT?: AccountWhereInput | AccountWhereInput[]
    balance?: FloatFilter<"Account"> | number
    comment?: StringNullableFilter<"Account"> | string | null
    createdAt?: DateTimeFilter<"Account"> | Date | string
    currency?: StringNullableFilter<"Account"> | string | null
    id?: StringFilter<"Account"> | string
    isExcluded?: BoolFilter<"Account"> | boolean
    name?: StringNullableFilter<"Account"> | string | null
    platformId?: StringNullableFilter<"Account"> | string | null
    updatedAt?: DateTimeFilter<"Account"> | Date | string
    userId?: StringFilter<"Account"> | string
    activities?: OrderListRelationFilter
    balances?: AccountBalanceListRelationFilter
    platform?: XOR<PlatformNullableScalarRelationFilter, PlatformWhereInput> | null
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id_userId">

  export type AccountOrderByWithAggregationInput = {
    balance?: SortOrder
    comment?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    currency?: SortOrderInput | SortOrder
    id?: SortOrder
    isExcluded?: SortOrder
    name?: SortOrderInput | SortOrder
    platformId?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    _count?: AccountCountOrderByAggregateInput
    _avg?: AccountAvgOrderByAggregateInput
    _max?: AccountMaxOrderByAggregateInput
    _min?: AccountMinOrderByAggregateInput
    _sum?: AccountSumOrderByAggregateInput
  }

  export type AccountScalarWhereWithAggregatesInput = {
    AND?: AccountScalarWhereWithAggregatesInput | AccountScalarWhereWithAggregatesInput[]
    OR?: AccountScalarWhereWithAggregatesInput[]
    NOT?: AccountScalarWhereWithAggregatesInput | AccountScalarWhereWithAggregatesInput[]
    balance?: FloatWithAggregatesFilter<"Account"> | number
    comment?: StringNullableWithAggregatesFilter<"Account"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Account"> | Date | string
    currency?: StringNullableWithAggregatesFilter<"Account"> | string | null
    id?: StringWithAggregatesFilter<"Account"> | string
    isExcluded?: BoolWithAggregatesFilter<"Account"> | boolean
    name?: StringNullableWithAggregatesFilter<"Account"> | string | null
    platformId?: StringNullableWithAggregatesFilter<"Account"> | string | null
    updatedAt?: DateTimeWithAggregatesFilter<"Account"> | Date | string
    userId?: StringWithAggregatesFilter<"Account"> | string
  }

  export type AccountBalanceWhereInput = {
    AND?: AccountBalanceWhereInput | AccountBalanceWhereInput[]
    OR?: AccountBalanceWhereInput[]
    NOT?: AccountBalanceWhereInput | AccountBalanceWhereInput[]
    accountId?: StringFilter<"AccountBalance"> | string
    createdAt?: DateTimeFilter<"AccountBalance"> | Date | string
    date?: DateTimeFilter<"AccountBalance"> | Date | string
    id?: StringFilter<"AccountBalance"> | string
    updatedAt?: DateTimeFilter<"AccountBalance"> | Date | string
    userId?: StringFilter<"AccountBalance"> | string
    value?: FloatFilter<"AccountBalance"> | number
    account?: XOR<AccountScalarRelationFilter, AccountWhereInput>
  }

  export type AccountBalanceOrderByWithRelationInput = {
    accountId?: SortOrder
    createdAt?: SortOrder
    date?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    value?: SortOrder
    account?: AccountOrderByWithRelationInput
  }

  export type AccountBalanceWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    accountId_date?: AccountBalanceAccountIdDateCompoundUniqueInput
    AND?: AccountBalanceWhereInput | AccountBalanceWhereInput[]
    OR?: AccountBalanceWhereInput[]
    NOT?: AccountBalanceWhereInput | AccountBalanceWhereInput[]
    accountId?: StringFilter<"AccountBalance"> | string
    createdAt?: DateTimeFilter<"AccountBalance"> | Date | string
    date?: DateTimeFilter<"AccountBalance"> | Date | string
    updatedAt?: DateTimeFilter<"AccountBalance"> | Date | string
    userId?: StringFilter<"AccountBalance"> | string
    value?: FloatFilter<"AccountBalance"> | number
    account?: XOR<AccountScalarRelationFilter, AccountWhereInput>
  }, "id" | "accountId_date">

  export type AccountBalanceOrderByWithAggregationInput = {
    accountId?: SortOrder
    createdAt?: SortOrder
    date?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    value?: SortOrder
    _count?: AccountBalanceCountOrderByAggregateInput
    _avg?: AccountBalanceAvgOrderByAggregateInput
    _max?: AccountBalanceMaxOrderByAggregateInput
    _min?: AccountBalanceMinOrderByAggregateInput
    _sum?: AccountBalanceSumOrderByAggregateInput
  }

  export type AccountBalanceScalarWhereWithAggregatesInput = {
    AND?: AccountBalanceScalarWhereWithAggregatesInput | AccountBalanceScalarWhereWithAggregatesInput[]
    OR?: AccountBalanceScalarWhereWithAggregatesInput[]
    NOT?: AccountBalanceScalarWhereWithAggregatesInput | AccountBalanceScalarWhereWithAggregatesInput[]
    accountId?: StringWithAggregatesFilter<"AccountBalance"> | string
    createdAt?: DateTimeWithAggregatesFilter<"AccountBalance"> | Date | string
    date?: DateTimeWithAggregatesFilter<"AccountBalance"> | Date | string
    id?: StringWithAggregatesFilter<"AccountBalance"> | string
    updatedAt?: DateTimeWithAggregatesFilter<"AccountBalance"> | Date | string
    userId?: StringWithAggregatesFilter<"AccountBalance"> | string
    value?: FloatWithAggregatesFilter<"AccountBalance"> | number
  }

  export type AnalyticsWhereInput = {
    AND?: AnalyticsWhereInput | AnalyticsWhereInput[]
    OR?: AnalyticsWhereInput[]
    NOT?: AnalyticsWhereInput | AnalyticsWhereInput[]
    activityCount?: IntFilter<"Analytics"> | number
    country?: StringNullableFilter<"Analytics"> | string | null
    dataProviderGhostfolioDailyRequests?: IntFilter<"Analytics"> | number
    lastRequestAt?: DateTimeFilter<"Analytics"> | Date | string
    updatedAt?: DateTimeFilter<"Analytics"> | Date | string
    userId?: StringFilter<"Analytics"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type AnalyticsOrderByWithRelationInput = {
    activityCount?: SortOrder
    country?: SortOrderInput | SortOrder
    dataProviderGhostfolioDailyRequests?: SortOrder
    lastRequestAt?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type AnalyticsWhereUniqueInput = Prisma.AtLeast<{
    userId?: string
    AND?: AnalyticsWhereInput | AnalyticsWhereInput[]
    OR?: AnalyticsWhereInput[]
    NOT?: AnalyticsWhereInput | AnalyticsWhereInput[]
    activityCount?: IntFilter<"Analytics"> | number
    country?: StringNullableFilter<"Analytics"> | string | null
    dataProviderGhostfolioDailyRequests?: IntFilter<"Analytics"> | number
    lastRequestAt?: DateTimeFilter<"Analytics"> | Date | string
    updatedAt?: DateTimeFilter<"Analytics"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "userId">

  export type AnalyticsOrderByWithAggregationInput = {
    activityCount?: SortOrder
    country?: SortOrderInput | SortOrder
    dataProviderGhostfolioDailyRequests?: SortOrder
    lastRequestAt?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    _count?: AnalyticsCountOrderByAggregateInput
    _avg?: AnalyticsAvgOrderByAggregateInput
    _max?: AnalyticsMaxOrderByAggregateInput
    _min?: AnalyticsMinOrderByAggregateInput
    _sum?: AnalyticsSumOrderByAggregateInput
  }

  export type AnalyticsScalarWhereWithAggregatesInput = {
    AND?: AnalyticsScalarWhereWithAggregatesInput | AnalyticsScalarWhereWithAggregatesInput[]
    OR?: AnalyticsScalarWhereWithAggregatesInput[]
    NOT?: AnalyticsScalarWhereWithAggregatesInput | AnalyticsScalarWhereWithAggregatesInput[]
    activityCount?: IntWithAggregatesFilter<"Analytics"> | number
    country?: StringNullableWithAggregatesFilter<"Analytics"> | string | null
    dataProviderGhostfolioDailyRequests?: IntWithAggregatesFilter<"Analytics"> | number
    lastRequestAt?: DateTimeWithAggregatesFilter<"Analytics"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Analytics"> | Date | string
    userId?: StringWithAggregatesFilter<"Analytics"> | string
  }

  export type ApiKeyWhereInput = {
    AND?: ApiKeyWhereInput | ApiKeyWhereInput[]
    OR?: ApiKeyWhereInput[]
    NOT?: ApiKeyWhereInput | ApiKeyWhereInput[]
    createdAt?: DateTimeFilter<"ApiKey"> | Date | string
    hashedKey?: StringFilter<"ApiKey"> | string
    id?: StringFilter<"ApiKey"> | string
    updatedAt?: DateTimeFilter<"ApiKey"> | Date | string
    userId?: StringFilter<"ApiKey"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type ApiKeyOrderByWithRelationInput = {
    createdAt?: SortOrder
    hashedKey?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type ApiKeyWhereUniqueInput = Prisma.AtLeast<{
    hashedKey?: string
    id?: string
    AND?: ApiKeyWhereInput | ApiKeyWhereInput[]
    OR?: ApiKeyWhereInput[]
    NOT?: ApiKeyWhereInput | ApiKeyWhereInput[]
    createdAt?: DateTimeFilter<"ApiKey"> | Date | string
    updatedAt?: DateTimeFilter<"ApiKey"> | Date | string
    userId?: StringFilter<"ApiKey"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id" | "hashedKey">

  export type ApiKeyOrderByWithAggregationInput = {
    createdAt?: SortOrder
    hashedKey?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    _count?: ApiKeyCountOrderByAggregateInput
    _max?: ApiKeyMaxOrderByAggregateInput
    _min?: ApiKeyMinOrderByAggregateInput
  }

  export type ApiKeyScalarWhereWithAggregatesInput = {
    AND?: ApiKeyScalarWhereWithAggregatesInput | ApiKeyScalarWhereWithAggregatesInput[]
    OR?: ApiKeyScalarWhereWithAggregatesInput[]
    NOT?: ApiKeyScalarWhereWithAggregatesInput | ApiKeyScalarWhereWithAggregatesInput[]
    createdAt?: DateTimeWithAggregatesFilter<"ApiKey"> | Date | string
    hashedKey?: StringWithAggregatesFilter<"ApiKey"> | string
    id?: StringWithAggregatesFilter<"ApiKey"> | string
    updatedAt?: DateTimeWithAggregatesFilter<"ApiKey"> | Date | string
    userId?: StringWithAggregatesFilter<"ApiKey"> | string
  }

  export type AssetProfileResolutionWhereInput = {
    AND?: AssetProfileResolutionWhereInput | AssetProfileResolutionWhereInput[]
    OR?: AssetProfileResolutionWhereInput[]
    NOT?: AssetProfileResolutionWhereInput | AssetProfileResolutionWhereInput[]
    createdAt?: DateTimeFilter<"AssetProfileResolution"> | Date | string
    currency?: StringFilter<"AssetProfileResolution"> | string
    dataSourceOrigin?: EnumDataSourceFilter<"AssetProfileResolution"> | $Enums.DataSource
    dataSourceTarget?: EnumDataSourceFilter<"AssetProfileResolution"> | $Enums.DataSource
    id?: StringFilter<"AssetProfileResolution"> | string
    requestCount?: IntFilter<"AssetProfileResolution"> | number
    symbolOrigin?: StringFilter<"AssetProfileResolution"> | string
    symbolTarget?: StringFilter<"AssetProfileResolution"> | string
    updatedAt?: DateTimeFilter<"AssetProfileResolution"> | Date | string
  }

  export type AssetProfileResolutionOrderByWithRelationInput = {
    createdAt?: SortOrder
    currency?: SortOrder
    dataSourceOrigin?: SortOrder
    dataSourceTarget?: SortOrder
    id?: SortOrder
    requestCount?: SortOrder
    symbolOrigin?: SortOrder
    symbolTarget?: SortOrder
    updatedAt?: SortOrder
  }

  export type AssetProfileResolutionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    dataSourceOrigin_symbolOrigin?: AssetProfileResolutionDataSourceOriginSymbolOriginCompoundUniqueInput
    AND?: AssetProfileResolutionWhereInput | AssetProfileResolutionWhereInput[]
    OR?: AssetProfileResolutionWhereInput[]
    NOT?: AssetProfileResolutionWhereInput | AssetProfileResolutionWhereInput[]
    createdAt?: DateTimeFilter<"AssetProfileResolution"> | Date | string
    currency?: StringFilter<"AssetProfileResolution"> | string
    dataSourceOrigin?: EnumDataSourceFilter<"AssetProfileResolution"> | $Enums.DataSource
    dataSourceTarget?: EnumDataSourceFilter<"AssetProfileResolution"> | $Enums.DataSource
    requestCount?: IntFilter<"AssetProfileResolution"> | number
    symbolOrigin?: StringFilter<"AssetProfileResolution"> | string
    symbolTarget?: StringFilter<"AssetProfileResolution"> | string
    updatedAt?: DateTimeFilter<"AssetProfileResolution"> | Date | string
  }, "id" | "dataSourceOrigin_symbolOrigin">

  export type AssetProfileResolutionOrderByWithAggregationInput = {
    createdAt?: SortOrder
    currency?: SortOrder
    dataSourceOrigin?: SortOrder
    dataSourceTarget?: SortOrder
    id?: SortOrder
    requestCount?: SortOrder
    symbolOrigin?: SortOrder
    symbolTarget?: SortOrder
    updatedAt?: SortOrder
    _count?: AssetProfileResolutionCountOrderByAggregateInput
    _avg?: AssetProfileResolutionAvgOrderByAggregateInput
    _max?: AssetProfileResolutionMaxOrderByAggregateInput
    _min?: AssetProfileResolutionMinOrderByAggregateInput
    _sum?: AssetProfileResolutionSumOrderByAggregateInput
  }

  export type AssetProfileResolutionScalarWhereWithAggregatesInput = {
    AND?: AssetProfileResolutionScalarWhereWithAggregatesInput | AssetProfileResolutionScalarWhereWithAggregatesInput[]
    OR?: AssetProfileResolutionScalarWhereWithAggregatesInput[]
    NOT?: AssetProfileResolutionScalarWhereWithAggregatesInput | AssetProfileResolutionScalarWhereWithAggregatesInput[]
    createdAt?: DateTimeWithAggregatesFilter<"AssetProfileResolution"> | Date | string
    currency?: StringWithAggregatesFilter<"AssetProfileResolution"> | string
    dataSourceOrigin?: EnumDataSourceWithAggregatesFilter<"AssetProfileResolution"> | $Enums.DataSource
    dataSourceTarget?: EnumDataSourceWithAggregatesFilter<"AssetProfileResolution"> | $Enums.DataSource
    id?: StringWithAggregatesFilter<"AssetProfileResolution"> | string
    requestCount?: IntWithAggregatesFilter<"AssetProfileResolution"> | number
    symbolOrigin?: StringWithAggregatesFilter<"AssetProfileResolution"> | string
    symbolTarget?: StringWithAggregatesFilter<"AssetProfileResolution"> | string
    updatedAt?: DateTimeWithAggregatesFilter<"AssetProfileResolution"> | Date | string
  }

  export type AuthDeviceWhereInput = {
    AND?: AuthDeviceWhereInput | AuthDeviceWhereInput[]
    OR?: AuthDeviceWhereInput[]
    NOT?: AuthDeviceWhereInput | AuthDeviceWhereInput[]
    createdAt?: DateTimeFilter<"AuthDevice"> | Date | string
    credentialId?: BytesFilter<"AuthDevice"> | Bytes
    credentialPublicKey?: BytesFilter<"AuthDevice"> | Bytes
    counter?: IntFilter<"AuthDevice"> | number
    id?: StringFilter<"AuthDevice"> | string
    updatedAt?: DateTimeFilter<"AuthDevice"> | Date | string
    userId?: StringFilter<"AuthDevice"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type AuthDeviceOrderByWithRelationInput = {
    createdAt?: SortOrder
    credentialId?: SortOrder
    credentialPublicKey?: SortOrder
    counter?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type AuthDeviceWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AuthDeviceWhereInput | AuthDeviceWhereInput[]
    OR?: AuthDeviceWhereInput[]
    NOT?: AuthDeviceWhereInput | AuthDeviceWhereInput[]
    createdAt?: DateTimeFilter<"AuthDevice"> | Date | string
    credentialId?: BytesFilter<"AuthDevice"> | Bytes
    credentialPublicKey?: BytesFilter<"AuthDevice"> | Bytes
    counter?: IntFilter<"AuthDevice"> | number
    updatedAt?: DateTimeFilter<"AuthDevice"> | Date | string
    userId?: StringFilter<"AuthDevice"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id">

  export type AuthDeviceOrderByWithAggregationInput = {
    createdAt?: SortOrder
    credentialId?: SortOrder
    credentialPublicKey?: SortOrder
    counter?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    _count?: AuthDeviceCountOrderByAggregateInput
    _avg?: AuthDeviceAvgOrderByAggregateInput
    _max?: AuthDeviceMaxOrderByAggregateInput
    _min?: AuthDeviceMinOrderByAggregateInput
    _sum?: AuthDeviceSumOrderByAggregateInput
  }

  export type AuthDeviceScalarWhereWithAggregatesInput = {
    AND?: AuthDeviceScalarWhereWithAggregatesInput | AuthDeviceScalarWhereWithAggregatesInput[]
    OR?: AuthDeviceScalarWhereWithAggregatesInput[]
    NOT?: AuthDeviceScalarWhereWithAggregatesInput | AuthDeviceScalarWhereWithAggregatesInput[]
    createdAt?: DateTimeWithAggregatesFilter<"AuthDevice"> | Date | string
    credentialId?: BytesWithAggregatesFilter<"AuthDevice"> | Bytes
    credentialPublicKey?: BytesWithAggregatesFilter<"AuthDevice"> | Bytes
    counter?: IntWithAggregatesFilter<"AuthDevice"> | number
    id?: StringWithAggregatesFilter<"AuthDevice"> | string
    updatedAt?: DateTimeWithAggregatesFilter<"AuthDevice"> | Date | string
    userId?: StringWithAggregatesFilter<"AuthDevice"> | string
  }

  export type MarketDataWhereInput = {
    AND?: MarketDataWhereInput | MarketDataWhereInput[]
    OR?: MarketDataWhereInput[]
    NOT?: MarketDataWhereInput | MarketDataWhereInput[]
    createdAt?: DateTimeFilter<"MarketData"> | Date | string
    dataSource?: EnumDataSourceFilter<"MarketData"> | $Enums.DataSource
    date?: DateTimeFilter<"MarketData"> | Date | string
    id?: StringFilter<"MarketData"> | string
    marketPrice?: FloatFilter<"MarketData"> | number
    state?: EnumMarketDataStateFilter<"MarketData"> | $Enums.MarketDataState
    symbol?: StringFilter<"MarketData"> | string
  }

  export type MarketDataOrderByWithRelationInput = {
    createdAt?: SortOrder
    dataSource?: SortOrder
    date?: SortOrder
    id?: SortOrder
    marketPrice?: SortOrder
    state?: SortOrder
    symbol?: SortOrder
  }

  export type MarketDataWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    dataSource_date_symbol?: MarketDataDataSourceDateSymbolCompoundUniqueInput
    AND?: MarketDataWhereInput | MarketDataWhereInput[]
    OR?: MarketDataWhereInput[]
    NOT?: MarketDataWhereInput | MarketDataWhereInput[]
    createdAt?: DateTimeFilter<"MarketData"> | Date | string
    dataSource?: EnumDataSourceFilter<"MarketData"> | $Enums.DataSource
    date?: DateTimeFilter<"MarketData"> | Date | string
    marketPrice?: FloatFilter<"MarketData"> | number
    state?: EnumMarketDataStateFilter<"MarketData"> | $Enums.MarketDataState
    symbol?: StringFilter<"MarketData"> | string
  }, "id" | "dataSource_date_symbol">

  export type MarketDataOrderByWithAggregationInput = {
    createdAt?: SortOrder
    dataSource?: SortOrder
    date?: SortOrder
    id?: SortOrder
    marketPrice?: SortOrder
    state?: SortOrder
    symbol?: SortOrder
    _count?: MarketDataCountOrderByAggregateInput
    _avg?: MarketDataAvgOrderByAggregateInput
    _max?: MarketDataMaxOrderByAggregateInput
    _min?: MarketDataMinOrderByAggregateInput
    _sum?: MarketDataSumOrderByAggregateInput
  }

  export type MarketDataScalarWhereWithAggregatesInput = {
    AND?: MarketDataScalarWhereWithAggregatesInput | MarketDataScalarWhereWithAggregatesInput[]
    OR?: MarketDataScalarWhereWithAggregatesInput[]
    NOT?: MarketDataScalarWhereWithAggregatesInput | MarketDataScalarWhereWithAggregatesInput[]
    createdAt?: DateTimeWithAggregatesFilter<"MarketData"> | Date | string
    dataSource?: EnumDataSourceWithAggregatesFilter<"MarketData"> | $Enums.DataSource
    date?: DateTimeWithAggregatesFilter<"MarketData"> | Date | string
    id?: StringWithAggregatesFilter<"MarketData"> | string
    marketPrice?: FloatWithAggregatesFilter<"MarketData"> | number
    state?: EnumMarketDataStateWithAggregatesFilter<"MarketData"> | $Enums.MarketDataState
    symbol?: StringWithAggregatesFilter<"MarketData"> | string
  }

  export type OrderWhereInput = {
    AND?: OrderWhereInput | OrderWhereInput[]
    OR?: OrderWhereInput[]
    NOT?: OrderWhereInput | OrderWhereInput[]
    accountId?: StringNullableFilter<"Order"> | string | null
    accountUserId?: StringNullableFilter<"Order"> | string | null
    comment?: StringNullableFilter<"Order"> | string | null
    createdAt?: DateTimeFilter<"Order"> | Date | string
    currency?: StringNullableFilter<"Order"> | string | null
    date?: DateTimeFilter<"Order"> | Date | string
    fee?: FloatFilter<"Order"> | number
    id?: StringFilter<"Order"> | string
    isDraft?: BoolFilter<"Order"> | boolean
    quantity?: FloatFilter<"Order"> | number
    symbolProfileId?: StringFilter<"Order"> | string
    type?: EnumTypeFilter<"Order"> | $Enums.Type
    unitPrice?: FloatFilter<"Order"> | number
    updatedAt?: DateTimeFilter<"Order"> | Date | string
    userId?: StringFilter<"Order"> | string
    account?: XOR<AccountNullableScalarRelationFilter, AccountWhereInput> | null
    tags?: TagListRelationFilter
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    SymbolProfile?: XOR<SymbolProfileScalarRelationFilter, SymbolProfileWhereInput>
  }

  export type OrderOrderByWithRelationInput = {
    accountId?: SortOrderInput | SortOrder
    accountUserId?: SortOrderInput | SortOrder
    comment?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    currency?: SortOrderInput | SortOrder
    date?: SortOrder
    fee?: SortOrder
    id?: SortOrder
    isDraft?: SortOrder
    quantity?: SortOrder
    symbolProfileId?: SortOrder
    type?: SortOrder
    unitPrice?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    account?: AccountOrderByWithRelationInput
    tags?: TagOrderByRelationAggregateInput
    user?: UserOrderByWithRelationInput
    SymbolProfile?: SymbolProfileOrderByWithRelationInput
  }

  export type OrderWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: OrderWhereInput | OrderWhereInput[]
    OR?: OrderWhereInput[]
    NOT?: OrderWhereInput | OrderWhereInput[]
    accountId?: StringNullableFilter<"Order"> | string | null
    accountUserId?: StringNullableFilter<"Order"> | string | null
    comment?: StringNullableFilter<"Order"> | string | null
    createdAt?: DateTimeFilter<"Order"> | Date | string
    currency?: StringNullableFilter<"Order"> | string | null
    date?: DateTimeFilter<"Order"> | Date | string
    fee?: FloatFilter<"Order"> | number
    isDraft?: BoolFilter<"Order"> | boolean
    quantity?: FloatFilter<"Order"> | number
    symbolProfileId?: StringFilter<"Order"> | string
    type?: EnumTypeFilter<"Order"> | $Enums.Type
    unitPrice?: FloatFilter<"Order"> | number
    updatedAt?: DateTimeFilter<"Order"> | Date | string
    userId?: StringFilter<"Order"> | string
    account?: XOR<AccountNullableScalarRelationFilter, AccountWhereInput> | null
    tags?: TagListRelationFilter
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
    SymbolProfile?: XOR<SymbolProfileScalarRelationFilter, SymbolProfileWhereInput>
  }, "id">

  export type OrderOrderByWithAggregationInput = {
    accountId?: SortOrderInput | SortOrder
    accountUserId?: SortOrderInput | SortOrder
    comment?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    currency?: SortOrderInput | SortOrder
    date?: SortOrder
    fee?: SortOrder
    id?: SortOrder
    isDraft?: SortOrder
    quantity?: SortOrder
    symbolProfileId?: SortOrder
    type?: SortOrder
    unitPrice?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    _count?: OrderCountOrderByAggregateInput
    _avg?: OrderAvgOrderByAggregateInput
    _max?: OrderMaxOrderByAggregateInput
    _min?: OrderMinOrderByAggregateInput
    _sum?: OrderSumOrderByAggregateInput
  }

  export type OrderScalarWhereWithAggregatesInput = {
    AND?: OrderScalarWhereWithAggregatesInput | OrderScalarWhereWithAggregatesInput[]
    OR?: OrderScalarWhereWithAggregatesInput[]
    NOT?: OrderScalarWhereWithAggregatesInput | OrderScalarWhereWithAggregatesInput[]
    accountId?: StringNullableWithAggregatesFilter<"Order"> | string | null
    accountUserId?: StringNullableWithAggregatesFilter<"Order"> | string | null
    comment?: StringNullableWithAggregatesFilter<"Order"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Order"> | Date | string
    currency?: StringNullableWithAggregatesFilter<"Order"> | string | null
    date?: DateTimeWithAggregatesFilter<"Order"> | Date | string
    fee?: FloatWithAggregatesFilter<"Order"> | number
    id?: StringWithAggregatesFilter<"Order"> | string
    isDraft?: BoolWithAggregatesFilter<"Order"> | boolean
    quantity?: FloatWithAggregatesFilter<"Order"> | number
    symbolProfileId?: StringWithAggregatesFilter<"Order"> | string
    type?: EnumTypeWithAggregatesFilter<"Order"> | $Enums.Type
    unitPrice?: FloatWithAggregatesFilter<"Order"> | number
    updatedAt?: DateTimeWithAggregatesFilter<"Order"> | Date | string
    userId?: StringWithAggregatesFilter<"Order"> | string
  }

  export type PlatformWhereInput = {
    AND?: PlatformWhereInput | PlatformWhereInput[]
    OR?: PlatformWhereInput[]
    NOT?: PlatformWhereInput | PlatformWhereInput[]
    id?: StringFilter<"Platform"> | string
    name?: StringNullableFilter<"Platform"> | string | null
    url?: StringFilter<"Platform"> | string
    accounts?: AccountListRelationFilter
  }

  export type PlatformOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    url?: SortOrder
    accounts?: AccountOrderByRelationAggregateInput
  }

  export type PlatformWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    url?: string
    AND?: PlatformWhereInput | PlatformWhereInput[]
    OR?: PlatformWhereInput[]
    NOT?: PlatformWhereInput | PlatformWhereInput[]
    name?: StringNullableFilter<"Platform"> | string | null
    accounts?: AccountListRelationFilter
  }, "id" | "url">

  export type PlatformOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrderInput | SortOrder
    url?: SortOrder
    _count?: PlatformCountOrderByAggregateInput
    _max?: PlatformMaxOrderByAggregateInput
    _min?: PlatformMinOrderByAggregateInput
  }

  export type PlatformScalarWhereWithAggregatesInput = {
    AND?: PlatformScalarWhereWithAggregatesInput | PlatformScalarWhereWithAggregatesInput[]
    OR?: PlatformScalarWhereWithAggregatesInput[]
    NOT?: PlatformScalarWhereWithAggregatesInput | PlatformScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Platform"> | string
    name?: StringNullableWithAggregatesFilter<"Platform"> | string | null
    url?: StringWithAggregatesFilter<"Platform"> | string
  }

  export type PropertyWhereInput = {
    AND?: PropertyWhereInput | PropertyWhereInput[]
    OR?: PropertyWhereInput[]
    NOT?: PropertyWhereInput | PropertyWhereInput[]
    key?: StringFilter<"Property"> | string
    value?: StringFilter<"Property"> | string
  }

  export type PropertyOrderByWithRelationInput = {
    key?: SortOrder
    value?: SortOrder
  }

  export type PropertyWhereUniqueInput = Prisma.AtLeast<{
    key?: string
    AND?: PropertyWhereInput | PropertyWhereInput[]
    OR?: PropertyWhereInput[]
    NOT?: PropertyWhereInput | PropertyWhereInput[]
    value?: StringFilter<"Property"> | string
  }, "key">

  export type PropertyOrderByWithAggregationInput = {
    key?: SortOrder
    value?: SortOrder
    _count?: PropertyCountOrderByAggregateInput
    _max?: PropertyMaxOrderByAggregateInput
    _min?: PropertyMinOrderByAggregateInput
  }

  export type PropertyScalarWhereWithAggregatesInput = {
    AND?: PropertyScalarWhereWithAggregatesInput | PropertyScalarWhereWithAggregatesInput[]
    OR?: PropertyScalarWhereWithAggregatesInput[]
    NOT?: PropertyScalarWhereWithAggregatesInput | PropertyScalarWhereWithAggregatesInput[]
    key?: StringWithAggregatesFilter<"Property"> | string
    value?: StringWithAggregatesFilter<"Property"> | string
  }

  export type SettingsWhereInput = {
    AND?: SettingsWhereInput | SettingsWhereInput[]
    OR?: SettingsWhereInput[]
    NOT?: SettingsWhereInput | SettingsWhereInput[]
    settings?: JsonNullableFilter<"Settings">
    updatedAt?: DateTimeFilter<"Settings"> | Date | string
    userId?: StringFilter<"Settings"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type SettingsOrderByWithRelationInput = {
    settings?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type SettingsWhereUniqueInput = Prisma.AtLeast<{
    userId?: string
    AND?: SettingsWhereInput | SettingsWhereInput[]
    OR?: SettingsWhereInput[]
    NOT?: SettingsWhereInput | SettingsWhereInput[]
    settings?: JsonNullableFilter<"Settings">
    updatedAt?: DateTimeFilter<"Settings"> | Date | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "userId">

  export type SettingsOrderByWithAggregationInput = {
    settings?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    _count?: SettingsCountOrderByAggregateInput
    _max?: SettingsMaxOrderByAggregateInput
    _min?: SettingsMinOrderByAggregateInput
  }

  export type SettingsScalarWhereWithAggregatesInput = {
    AND?: SettingsScalarWhereWithAggregatesInput | SettingsScalarWhereWithAggregatesInput[]
    OR?: SettingsScalarWhereWithAggregatesInput[]
    NOT?: SettingsScalarWhereWithAggregatesInput | SettingsScalarWhereWithAggregatesInput[]
    settings?: JsonNullableWithAggregatesFilter<"Settings">
    updatedAt?: DateTimeWithAggregatesFilter<"Settings"> | Date | string
    userId?: StringWithAggregatesFilter<"Settings"> | string
  }

  export type SymbolProfileWhereInput = {
    AND?: SymbolProfileWhereInput | SymbolProfileWhereInput[]
    OR?: SymbolProfileWhereInput[]
    NOT?: SymbolProfileWhereInput | SymbolProfileWhereInput[]
    assetClass?: EnumAssetClassNullableFilter<"SymbolProfile"> | $Enums.AssetClass | null
    assetSubClass?: EnumAssetSubClassNullableFilter<"SymbolProfile"> | $Enums.AssetSubClass | null
    comment?: StringNullableFilter<"SymbolProfile"> | string | null
    countries?: JsonNullableFilter<"SymbolProfile">
    createdAt?: DateTimeFilter<"SymbolProfile"> | Date | string
    currency?: StringFilter<"SymbolProfile"> | string
    cusip?: StringNullableFilter<"SymbolProfile"> | string | null
    dataSource?: EnumDataSourceFilter<"SymbolProfile"> | $Enums.DataSource
    figi?: StringNullableFilter<"SymbolProfile"> | string | null
    figiComposite?: StringNullableFilter<"SymbolProfile"> | string | null
    figiShareClass?: StringNullableFilter<"SymbolProfile"> | string | null
    holdings?: JsonNullableFilter<"SymbolProfile">
    id?: StringFilter<"SymbolProfile"> | string
    isActive?: BoolFilter<"SymbolProfile"> | boolean
    isin?: StringNullableFilter<"SymbolProfile"> | string | null
    name?: StringNullableFilter<"SymbolProfile"> | string | null
    updatedAt?: DateTimeFilter<"SymbolProfile"> | Date | string
    scraperConfiguration?: JsonNullableFilter<"SymbolProfile">
    sectors?: JsonNullableFilter<"SymbolProfile">
    symbol?: StringFilter<"SymbolProfile"> | string
    symbolMapping?: JsonNullableFilter<"SymbolProfile">
    url?: StringNullableFilter<"SymbolProfile"> | string | null
    userId?: StringNullableFilter<"SymbolProfile"> | string | null
    activities?: OrderListRelationFilter
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    watchedBy?: UserListRelationFilter
    SymbolProfileOverrides?: XOR<SymbolProfileOverridesNullableScalarRelationFilter, SymbolProfileOverridesWhereInput> | null
  }

  export type SymbolProfileOrderByWithRelationInput = {
    assetClass?: SortOrderInput | SortOrder
    assetSubClass?: SortOrderInput | SortOrder
    comment?: SortOrderInput | SortOrder
    countries?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    cusip?: SortOrderInput | SortOrder
    dataSource?: SortOrder
    figi?: SortOrderInput | SortOrder
    figiComposite?: SortOrderInput | SortOrder
    figiShareClass?: SortOrderInput | SortOrder
    holdings?: SortOrderInput | SortOrder
    id?: SortOrder
    isActive?: SortOrder
    isin?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    scraperConfiguration?: SortOrderInput | SortOrder
    sectors?: SortOrderInput | SortOrder
    symbol?: SortOrder
    symbolMapping?: SortOrderInput | SortOrder
    url?: SortOrderInput | SortOrder
    userId?: SortOrderInput | SortOrder
    activities?: OrderOrderByRelationAggregateInput
    user?: UserOrderByWithRelationInput
    watchedBy?: UserOrderByRelationAggregateInput
    SymbolProfileOverrides?: SymbolProfileOverridesOrderByWithRelationInput
  }

  export type SymbolProfileWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    dataSource_symbol?: SymbolProfileDataSourceSymbolCompoundUniqueInput
    AND?: SymbolProfileWhereInput | SymbolProfileWhereInput[]
    OR?: SymbolProfileWhereInput[]
    NOT?: SymbolProfileWhereInput | SymbolProfileWhereInput[]
    assetClass?: EnumAssetClassNullableFilter<"SymbolProfile"> | $Enums.AssetClass | null
    assetSubClass?: EnumAssetSubClassNullableFilter<"SymbolProfile"> | $Enums.AssetSubClass | null
    comment?: StringNullableFilter<"SymbolProfile"> | string | null
    countries?: JsonNullableFilter<"SymbolProfile">
    createdAt?: DateTimeFilter<"SymbolProfile"> | Date | string
    currency?: StringFilter<"SymbolProfile"> | string
    cusip?: StringNullableFilter<"SymbolProfile"> | string | null
    dataSource?: EnumDataSourceFilter<"SymbolProfile"> | $Enums.DataSource
    figi?: StringNullableFilter<"SymbolProfile"> | string | null
    figiComposite?: StringNullableFilter<"SymbolProfile"> | string | null
    figiShareClass?: StringNullableFilter<"SymbolProfile"> | string | null
    holdings?: JsonNullableFilter<"SymbolProfile">
    isActive?: BoolFilter<"SymbolProfile"> | boolean
    isin?: StringNullableFilter<"SymbolProfile"> | string | null
    name?: StringNullableFilter<"SymbolProfile"> | string | null
    updatedAt?: DateTimeFilter<"SymbolProfile"> | Date | string
    scraperConfiguration?: JsonNullableFilter<"SymbolProfile">
    sectors?: JsonNullableFilter<"SymbolProfile">
    symbol?: StringFilter<"SymbolProfile"> | string
    symbolMapping?: JsonNullableFilter<"SymbolProfile">
    url?: StringNullableFilter<"SymbolProfile"> | string | null
    userId?: StringNullableFilter<"SymbolProfile"> | string | null
    activities?: OrderListRelationFilter
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
    watchedBy?: UserListRelationFilter
    SymbolProfileOverrides?: XOR<SymbolProfileOverridesNullableScalarRelationFilter, SymbolProfileOverridesWhereInput> | null
  }, "id" | "dataSource_symbol">

  export type SymbolProfileOrderByWithAggregationInput = {
    assetClass?: SortOrderInput | SortOrder
    assetSubClass?: SortOrderInput | SortOrder
    comment?: SortOrderInput | SortOrder
    countries?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    cusip?: SortOrderInput | SortOrder
    dataSource?: SortOrder
    figi?: SortOrderInput | SortOrder
    figiComposite?: SortOrderInput | SortOrder
    figiShareClass?: SortOrderInput | SortOrder
    holdings?: SortOrderInput | SortOrder
    id?: SortOrder
    isActive?: SortOrder
    isin?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    scraperConfiguration?: SortOrderInput | SortOrder
    sectors?: SortOrderInput | SortOrder
    symbol?: SortOrder
    symbolMapping?: SortOrderInput | SortOrder
    url?: SortOrderInput | SortOrder
    userId?: SortOrderInput | SortOrder
    _count?: SymbolProfileCountOrderByAggregateInput
    _max?: SymbolProfileMaxOrderByAggregateInput
    _min?: SymbolProfileMinOrderByAggregateInput
  }

  export type SymbolProfileScalarWhereWithAggregatesInput = {
    AND?: SymbolProfileScalarWhereWithAggregatesInput | SymbolProfileScalarWhereWithAggregatesInput[]
    OR?: SymbolProfileScalarWhereWithAggregatesInput[]
    NOT?: SymbolProfileScalarWhereWithAggregatesInput | SymbolProfileScalarWhereWithAggregatesInput[]
    assetClass?: EnumAssetClassNullableWithAggregatesFilter<"SymbolProfile"> | $Enums.AssetClass | null
    assetSubClass?: EnumAssetSubClassNullableWithAggregatesFilter<"SymbolProfile"> | $Enums.AssetSubClass | null
    comment?: StringNullableWithAggregatesFilter<"SymbolProfile"> | string | null
    countries?: JsonNullableWithAggregatesFilter<"SymbolProfile">
    createdAt?: DateTimeWithAggregatesFilter<"SymbolProfile"> | Date | string
    currency?: StringWithAggregatesFilter<"SymbolProfile"> | string
    cusip?: StringNullableWithAggregatesFilter<"SymbolProfile"> | string | null
    dataSource?: EnumDataSourceWithAggregatesFilter<"SymbolProfile"> | $Enums.DataSource
    figi?: StringNullableWithAggregatesFilter<"SymbolProfile"> | string | null
    figiComposite?: StringNullableWithAggregatesFilter<"SymbolProfile"> | string | null
    figiShareClass?: StringNullableWithAggregatesFilter<"SymbolProfile"> | string | null
    holdings?: JsonNullableWithAggregatesFilter<"SymbolProfile">
    id?: StringWithAggregatesFilter<"SymbolProfile"> | string
    isActive?: BoolWithAggregatesFilter<"SymbolProfile"> | boolean
    isin?: StringNullableWithAggregatesFilter<"SymbolProfile"> | string | null
    name?: StringNullableWithAggregatesFilter<"SymbolProfile"> | string | null
    updatedAt?: DateTimeWithAggregatesFilter<"SymbolProfile"> | Date | string
    scraperConfiguration?: JsonNullableWithAggregatesFilter<"SymbolProfile">
    sectors?: JsonNullableWithAggregatesFilter<"SymbolProfile">
    symbol?: StringWithAggregatesFilter<"SymbolProfile"> | string
    symbolMapping?: JsonNullableWithAggregatesFilter<"SymbolProfile">
    url?: StringNullableWithAggregatesFilter<"SymbolProfile"> | string | null
    userId?: StringNullableWithAggregatesFilter<"SymbolProfile"> | string | null
  }

  export type SymbolProfileOverridesWhereInput = {
    AND?: SymbolProfileOverridesWhereInput | SymbolProfileOverridesWhereInput[]
    OR?: SymbolProfileOverridesWhereInput[]
    NOT?: SymbolProfileOverridesWhereInput | SymbolProfileOverridesWhereInput[]
    assetClass?: EnumAssetClassNullableFilter<"SymbolProfileOverrides"> | $Enums.AssetClass | null
    assetSubClass?: EnumAssetSubClassNullableFilter<"SymbolProfileOverrides"> | $Enums.AssetSubClass | null
    countries?: JsonNullableFilter<"SymbolProfileOverrides">
    holdings?: JsonNullableFilter<"SymbolProfileOverrides">
    name?: StringNullableFilter<"SymbolProfileOverrides"> | string | null
    sectors?: JsonNullableFilter<"SymbolProfileOverrides">
    symbolProfileId?: StringFilter<"SymbolProfileOverrides"> | string
    updatedAt?: DateTimeFilter<"SymbolProfileOverrides"> | Date | string
    url?: StringNullableFilter<"SymbolProfileOverrides"> | string | null
    SymbolProfile?: XOR<SymbolProfileScalarRelationFilter, SymbolProfileWhereInput>
  }

  export type SymbolProfileOverridesOrderByWithRelationInput = {
    assetClass?: SortOrderInput | SortOrder
    assetSubClass?: SortOrderInput | SortOrder
    countries?: SortOrderInput | SortOrder
    holdings?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    sectors?: SortOrderInput | SortOrder
    symbolProfileId?: SortOrder
    updatedAt?: SortOrder
    url?: SortOrderInput | SortOrder
    SymbolProfile?: SymbolProfileOrderByWithRelationInput
  }

  export type SymbolProfileOverridesWhereUniqueInput = Prisma.AtLeast<{
    symbolProfileId?: string
    AND?: SymbolProfileOverridesWhereInput | SymbolProfileOverridesWhereInput[]
    OR?: SymbolProfileOverridesWhereInput[]
    NOT?: SymbolProfileOverridesWhereInput | SymbolProfileOverridesWhereInput[]
    assetClass?: EnumAssetClassNullableFilter<"SymbolProfileOverrides"> | $Enums.AssetClass | null
    assetSubClass?: EnumAssetSubClassNullableFilter<"SymbolProfileOverrides"> | $Enums.AssetSubClass | null
    countries?: JsonNullableFilter<"SymbolProfileOverrides">
    holdings?: JsonNullableFilter<"SymbolProfileOverrides">
    name?: StringNullableFilter<"SymbolProfileOverrides"> | string | null
    sectors?: JsonNullableFilter<"SymbolProfileOverrides">
    updatedAt?: DateTimeFilter<"SymbolProfileOverrides"> | Date | string
    url?: StringNullableFilter<"SymbolProfileOverrides"> | string | null
    SymbolProfile?: XOR<SymbolProfileScalarRelationFilter, SymbolProfileWhereInput>
  }, "symbolProfileId">

  export type SymbolProfileOverridesOrderByWithAggregationInput = {
    assetClass?: SortOrderInput | SortOrder
    assetSubClass?: SortOrderInput | SortOrder
    countries?: SortOrderInput | SortOrder
    holdings?: SortOrderInput | SortOrder
    name?: SortOrderInput | SortOrder
    sectors?: SortOrderInput | SortOrder
    symbolProfileId?: SortOrder
    updatedAt?: SortOrder
    url?: SortOrderInput | SortOrder
    _count?: SymbolProfileOverridesCountOrderByAggregateInput
    _max?: SymbolProfileOverridesMaxOrderByAggregateInput
    _min?: SymbolProfileOverridesMinOrderByAggregateInput
  }

  export type SymbolProfileOverridesScalarWhereWithAggregatesInput = {
    AND?: SymbolProfileOverridesScalarWhereWithAggregatesInput | SymbolProfileOverridesScalarWhereWithAggregatesInput[]
    OR?: SymbolProfileOverridesScalarWhereWithAggregatesInput[]
    NOT?: SymbolProfileOverridesScalarWhereWithAggregatesInput | SymbolProfileOverridesScalarWhereWithAggregatesInput[]
    assetClass?: EnumAssetClassNullableWithAggregatesFilter<"SymbolProfileOverrides"> | $Enums.AssetClass | null
    assetSubClass?: EnumAssetSubClassNullableWithAggregatesFilter<"SymbolProfileOverrides"> | $Enums.AssetSubClass | null
    countries?: JsonNullableWithAggregatesFilter<"SymbolProfileOverrides">
    holdings?: JsonNullableWithAggregatesFilter<"SymbolProfileOverrides">
    name?: StringNullableWithAggregatesFilter<"SymbolProfileOverrides"> | string | null
    sectors?: JsonNullableWithAggregatesFilter<"SymbolProfileOverrides">
    symbolProfileId?: StringWithAggregatesFilter<"SymbolProfileOverrides"> | string
    updatedAt?: DateTimeWithAggregatesFilter<"SymbolProfileOverrides"> | Date | string
    url?: StringNullableWithAggregatesFilter<"SymbolProfileOverrides"> | string | null
  }

  export type SubscriptionWhereInput = {
    AND?: SubscriptionWhereInput | SubscriptionWhereInput[]
    OR?: SubscriptionWhereInput[]
    NOT?: SubscriptionWhereInput | SubscriptionWhereInput[]
    createdAt?: DateTimeFilter<"Subscription"> | Date | string
    expiresAt?: DateTimeFilter<"Subscription"> | Date | string
    id?: StringFilter<"Subscription"> | string
    price?: FloatNullableFilter<"Subscription"> | number | null
    updatedAt?: DateTimeFilter<"Subscription"> | Date | string
    userId?: StringFilter<"Subscription"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }

  export type SubscriptionOrderByWithRelationInput = {
    createdAt?: SortOrder
    expiresAt?: SortOrder
    id?: SortOrder
    price?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    user?: UserOrderByWithRelationInput
  }

  export type SubscriptionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SubscriptionWhereInput | SubscriptionWhereInput[]
    OR?: SubscriptionWhereInput[]
    NOT?: SubscriptionWhereInput | SubscriptionWhereInput[]
    createdAt?: DateTimeFilter<"Subscription"> | Date | string
    expiresAt?: DateTimeFilter<"Subscription"> | Date | string
    price?: FloatNullableFilter<"Subscription"> | number | null
    updatedAt?: DateTimeFilter<"Subscription"> | Date | string
    userId?: StringFilter<"Subscription"> | string
    user?: XOR<UserScalarRelationFilter, UserWhereInput>
  }, "id">

  export type SubscriptionOrderByWithAggregationInput = {
    createdAt?: SortOrder
    expiresAt?: SortOrder
    id?: SortOrder
    price?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    _count?: SubscriptionCountOrderByAggregateInput
    _avg?: SubscriptionAvgOrderByAggregateInput
    _max?: SubscriptionMaxOrderByAggregateInput
    _min?: SubscriptionMinOrderByAggregateInput
    _sum?: SubscriptionSumOrderByAggregateInput
  }

  export type SubscriptionScalarWhereWithAggregatesInput = {
    AND?: SubscriptionScalarWhereWithAggregatesInput | SubscriptionScalarWhereWithAggregatesInput[]
    OR?: SubscriptionScalarWhereWithAggregatesInput[]
    NOT?: SubscriptionScalarWhereWithAggregatesInput | SubscriptionScalarWhereWithAggregatesInput[]
    createdAt?: DateTimeWithAggregatesFilter<"Subscription"> | Date | string
    expiresAt?: DateTimeWithAggregatesFilter<"Subscription"> | Date | string
    id?: StringWithAggregatesFilter<"Subscription"> | string
    price?: FloatNullableWithAggregatesFilter<"Subscription"> | number | null
    updatedAt?: DateTimeWithAggregatesFilter<"Subscription"> | Date | string
    userId?: StringWithAggregatesFilter<"Subscription"> | string
  }

  export type TagWhereInput = {
    AND?: TagWhereInput | TagWhereInput[]
    OR?: TagWhereInput[]
    NOT?: TagWhereInput | TagWhereInput[]
    id?: StringFilter<"Tag"> | string
    name?: StringFilter<"Tag"> | string
    userId?: StringNullableFilter<"Tag"> | string | null
    activities?: OrderListRelationFilter
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
  }

  export type TagOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrderInput | SortOrder
    activities?: OrderOrderByRelationAggregateInput
    user?: UserOrderByWithRelationInput
  }

  export type TagWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    name_userId?: TagNameUserIdCompoundUniqueInput
    AND?: TagWhereInput | TagWhereInput[]
    OR?: TagWhereInput[]
    NOT?: TagWhereInput | TagWhereInput[]
    name?: StringFilter<"Tag"> | string
    userId?: StringNullableFilter<"Tag"> | string | null
    activities?: OrderListRelationFilter
    user?: XOR<UserNullableScalarRelationFilter, UserWhereInput> | null
  }, "id" | "name_userId">

  export type TagOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrderInput | SortOrder
    _count?: TagCountOrderByAggregateInput
    _max?: TagMaxOrderByAggregateInput
    _min?: TagMinOrderByAggregateInput
  }

  export type TagScalarWhereWithAggregatesInput = {
    AND?: TagScalarWhereWithAggregatesInput | TagScalarWhereWithAggregatesInput[]
    OR?: TagScalarWhereWithAggregatesInput[]
    NOT?: TagScalarWhereWithAggregatesInput | TagScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Tag"> | string
    name?: StringWithAggregatesFilter<"Tag"> | string
    userId?: StringNullableWithAggregatesFilter<"Tag"> | string | null
  }

  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    accessToken?: StringNullableFilter<"User"> | string | null
    authChallenge?: StringNullableFilter<"User"> | string | null
    createdAt?: DateTimeFilter<"User"> | Date | string
    id?: StringFilter<"User"> | string
    provider?: EnumProviderFilter<"User"> | $Enums.Provider
    role?: EnumRoleFilter<"User"> | $Enums.Role
    thirdPartyId?: StringNullableFilter<"User"> | string | null
    updatedAt?: DateTimeFilter<"User"> | Date | string
    accessesGet?: AccessListRelationFilter
    accessesGive?: AccessListRelationFilter
    accounts?: AccountListRelationFilter
    activities?: OrderListRelationFilter
    analytics?: XOR<AnalyticsNullableScalarRelationFilter, AnalyticsWhereInput> | null
    apiKeys?: ApiKeyListRelationFilter
    authDevices?: AuthDeviceListRelationFilter
    settings?: XOR<SettingsNullableScalarRelationFilter, SettingsWhereInput> | null
    subscriptions?: SubscriptionListRelationFilter
    tags?: TagListRelationFilter
    watchlist?: SymbolProfileListRelationFilter
    SymbolProfile?: SymbolProfileListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    accessToken?: SortOrderInput | SortOrder
    authChallenge?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    id?: SortOrder
    provider?: SortOrder
    role?: SortOrder
    thirdPartyId?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    accessesGet?: AccessOrderByRelationAggregateInput
    accessesGive?: AccessOrderByRelationAggregateInput
    accounts?: AccountOrderByRelationAggregateInput
    activities?: OrderOrderByRelationAggregateInput
    analytics?: AnalyticsOrderByWithRelationInput
    apiKeys?: ApiKeyOrderByRelationAggregateInput
    authDevices?: AuthDeviceOrderByRelationAggregateInput
    settings?: SettingsOrderByWithRelationInput
    subscriptions?: SubscriptionOrderByRelationAggregateInput
    tags?: TagOrderByRelationAggregateInput
    watchlist?: SymbolProfileOrderByRelationAggregateInput
    SymbolProfile?: SymbolProfileOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    accessToken?: StringNullableFilter<"User"> | string | null
    authChallenge?: StringNullableFilter<"User"> | string | null
    createdAt?: DateTimeFilter<"User"> | Date | string
    provider?: EnumProviderFilter<"User"> | $Enums.Provider
    role?: EnumRoleFilter<"User"> | $Enums.Role
    thirdPartyId?: StringNullableFilter<"User"> | string | null
    updatedAt?: DateTimeFilter<"User"> | Date | string
    accessesGet?: AccessListRelationFilter
    accessesGive?: AccessListRelationFilter
    accounts?: AccountListRelationFilter
    activities?: OrderListRelationFilter
    analytics?: XOR<AnalyticsNullableScalarRelationFilter, AnalyticsWhereInput> | null
    apiKeys?: ApiKeyListRelationFilter
    authDevices?: AuthDeviceListRelationFilter
    settings?: XOR<SettingsNullableScalarRelationFilter, SettingsWhereInput> | null
    subscriptions?: SubscriptionListRelationFilter
    tags?: TagListRelationFilter
    watchlist?: SymbolProfileListRelationFilter
    SymbolProfile?: SymbolProfileListRelationFilter
  }, "id">

  export type UserOrderByWithAggregationInput = {
    accessToken?: SortOrderInput | SortOrder
    authChallenge?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    id?: SortOrder
    provider?: SortOrder
    role?: SortOrder
    thirdPartyId?: SortOrderInput | SortOrder
    updatedAt?: SortOrder
    _count?: UserCountOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    accessToken?: StringNullableWithAggregatesFilter<"User"> | string | null
    authChallenge?: StringNullableWithAggregatesFilter<"User"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
    id?: StringWithAggregatesFilter<"User"> | string
    provider?: EnumProviderWithAggregatesFilter<"User"> | $Enums.Provider
    role?: EnumRoleWithAggregatesFilter<"User"> | $Enums.Role
    thirdPartyId?: StringNullableWithAggregatesFilter<"User"> | string | null
    updatedAt?: DateTimeWithAggregatesFilter<"User"> | Date | string
  }

  export type AccessCreateInput = {
    alias?: string | null
    createdAt?: Date | string
    id?: string
    permissions?: AccessCreatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    granteeUser?: UserCreateNestedOneWithoutAccessesGetInput
    user: UserCreateNestedOneWithoutAccessesGiveInput
  }

  export type AccessUncheckedCreateInput = {
    alias?: string | null
    createdAt?: Date | string
    granteeUserId?: string | null
    id?: string
    permissions?: AccessCreatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    userId: string
  }

  export type AccessUpdateInput = {
    alias?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    permissions?: AccessUpdatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    granteeUser?: UserUpdateOneWithoutAccessesGetNestedInput
    user?: UserUpdateOneRequiredWithoutAccessesGiveNestedInput
  }

  export type AccessUncheckedUpdateInput = {
    alias?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    granteeUserId?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    permissions?: AccessUpdatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AccessCreateManyInput = {
    alias?: string | null
    createdAt?: Date | string
    granteeUserId?: string | null
    id?: string
    permissions?: AccessCreatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    userId: string
  }

  export type AccessUpdateManyMutationInput = {
    alias?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    permissions?: AccessUpdatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccessUncheckedUpdateManyInput = {
    alias?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    granteeUserId?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    permissions?: AccessUpdatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AccountCreateInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    updatedAt?: Date | string
    activities?: OrderCreateNestedManyWithoutAccountInput
    balances?: AccountBalanceCreateNestedManyWithoutAccountInput
    platform?: PlatformCreateNestedOneWithoutAccountsInput
    user: UserCreateNestedOneWithoutAccountsInput
  }

  export type AccountUncheckedCreateInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    platformId?: string | null
    updatedAt?: Date | string
    userId: string
    activities?: OrderUncheckedCreateNestedManyWithoutAccountInput
    balances?: AccountBalanceUncheckedCreateNestedManyWithoutAccountInput
  }

  export type AccountUpdateInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    activities?: OrderUpdateManyWithoutAccountNestedInput
    balances?: AccountBalanceUpdateManyWithoutAccountNestedInput
    platform?: PlatformUpdateOneWithoutAccountsNestedInput
    user?: UserUpdateOneRequiredWithoutAccountsNestedInput
  }

  export type AccountUncheckedUpdateInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    platformId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    activities?: OrderUncheckedUpdateManyWithoutAccountNestedInput
    balances?: AccountBalanceUncheckedUpdateManyWithoutAccountNestedInput
  }

  export type AccountCreateManyInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    platformId?: string | null
    updatedAt?: Date | string
    userId: string
  }

  export type AccountUpdateManyMutationInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUncheckedUpdateManyInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    platformId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AccountBalanceCreateInput = {
    createdAt?: Date | string
    date?: Date | string
    id?: string
    updatedAt?: Date | string
    value: number
    account: AccountCreateNestedOneWithoutBalancesInput
  }

  export type AccountBalanceUncheckedCreateInput = {
    accountId: string
    createdAt?: Date | string
    date?: Date | string
    id?: string
    updatedAt?: Date | string
    userId: string
    value: number
  }

  export type AccountBalanceUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    value?: FloatFieldUpdateOperationsInput | number
    account?: AccountUpdateOneRequiredWithoutBalancesNestedInput
  }

  export type AccountBalanceUncheckedUpdateInput = {
    accountId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    value?: FloatFieldUpdateOperationsInput | number
  }

  export type AccountBalanceCreateManyInput = {
    accountId: string
    createdAt?: Date | string
    date?: Date | string
    id?: string
    updatedAt?: Date | string
    userId: string
    value: number
  }

  export type AccountBalanceUpdateManyMutationInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    value?: FloatFieldUpdateOperationsInput | number
  }

  export type AccountBalanceUncheckedUpdateManyInput = {
    accountId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    value?: FloatFieldUpdateOperationsInput | number
  }

  export type AnalyticsCreateInput = {
    activityCount?: number
    country?: string | null
    dataProviderGhostfolioDailyRequests?: number
    lastRequestAt?: Date | string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutAnalyticsInput
  }

  export type AnalyticsUncheckedCreateInput = {
    activityCount?: number
    country?: string | null
    dataProviderGhostfolioDailyRequests?: number
    lastRequestAt?: Date | string
    updatedAt?: Date | string
    userId: string
  }

  export type AnalyticsUpdateInput = {
    activityCount?: IntFieldUpdateOperationsInput | number
    country?: NullableStringFieldUpdateOperationsInput | string | null
    dataProviderGhostfolioDailyRequests?: IntFieldUpdateOperationsInput | number
    lastRequestAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAnalyticsNestedInput
  }

  export type AnalyticsUncheckedUpdateInput = {
    activityCount?: IntFieldUpdateOperationsInput | number
    country?: NullableStringFieldUpdateOperationsInput | string | null
    dataProviderGhostfolioDailyRequests?: IntFieldUpdateOperationsInput | number
    lastRequestAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AnalyticsCreateManyInput = {
    activityCount?: number
    country?: string | null
    dataProviderGhostfolioDailyRequests?: number
    lastRequestAt?: Date | string
    updatedAt?: Date | string
    userId: string
  }

  export type AnalyticsUpdateManyMutationInput = {
    activityCount?: IntFieldUpdateOperationsInput | number
    country?: NullableStringFieldUpdateOperationsInput | string | null
    dataProviderGhostfolioDailyRequests?: IntFieldUpdateOperationsInput | number
    lastRequestAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AnalyticsUncheckedUpdateManyInput = {
    activityCount?: IntFieldUpdateOperationsInput | number
    country?: NullableStringFieldUpdateOperationsInput | string | null
    dataProviderGhostfolioDailyRequests?: IntFieldUpdateOperationsInput | number
    lastRequestAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type ApiKeyCreateInput = {
    createdAt?: Date | string
    hashedKey: string
    id?: string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutApiKeysInput
  }

  export type ApiKeyUncheckedCreateInput = {
    createdAt?: Date | string
    hashedKey: string
    id?: string
    updatedAt?: Date | string
    userId: string
  }

  export type ApiKeyUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    hashedKey?: StringFieldUpdateOperationsInput | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutApiKeysNestedInput
  }

  export type ApiKeyUncheckedUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    hashedKey?: StringFieldUpdateOperationsInput | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type ApiKeyCreateManyInput = {
    createdAt?: Date | string
    hashedKey: string
    id?: string
    updatedAt?: Date | string
    userId: string
  }

  export type ApiKeyUpdateManyMutationInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    hashedKey?: StringFieldUpdateOperationsInput | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ApiKeyUncheckedUpdateManyInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    hashedKey?: StringFieldUpdateOperationsInput | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AssetProfileResolutionCreateInput = {
    createdAt?: Date | string
    currency: string
    dataSourceOrigin: $Enums.DataSource
    dataSourceTarget: $Enums.DataSource
    id?: string
    requestCount?: number
    symbolOrigin: string
    symbolTarget: string
    updatedAt?: Date | string
  }

  export type AssetProfileResolutionUncheckedCreateInput = {
    createdAt?: Date | string
    currency: string
    dataSourceOrigin: $Enums.DataSource
    dataSourceTarget: $Enums.DataSource
    id?: string
    requestCount?: number
    symbolOrigin: string
    symbolTarget: string
    updatedAt?: Date | string
  }

  export type AssetProfileResolutionUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    dataSourceOrigin?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    dataSourceTarget?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    id?: StringFieldUpdateOperationsInput | string
    requestCount?: IntFieldUpdateOperationsInput | number
    symbolOrigin?: StringFieldUpdateOperationsInput | string
    symbolTarget?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AssetProfileResolutionUncheckedUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    dataSourceOrigin?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    dataSourceTarget?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    id?: StringFieldUpdateOperationsInput | string
    requestCount?: IntFieldUpdateOperationsInput | number
    symbolOrigin?: StringFieldUpdateOperationsInput | string
    symbolTarget?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AssetProfileResolutionCreateManyInput = {
    createdAt?: Date | string
    currency: string
    dataSourceOrigin: $Enums.DataSource
    dataSourceTarget: $Enums.DataSource
    id?: string
    requestCount?: number
    symbolOrigin: string
    symbolTarget: string
    updatedAt?: Date | string
  }

  export type AssetProfileResolutionUpdateManyMutationInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    dataSourceOrigin?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    dataSourceTarget?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    id?: StringFieldUpdateOperationsInput | string
    requestCount?: IntFieldUpdateOperationsInput | number
    symbolOrigin?: StringFieldUpdateOperationsInput | string
    symbolTarget?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AssetProfileResolutionUncheckedUpdateManyInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    dataSourceOrigin?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    dataSourceTarget?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    id?: StringFieldUpdateOperationsInput | string
    requestCount?: IntFieldUpdateOperationsInput | number
    symbolOrigin?: StringFieldUpdateOperationsInput | string
    symbolTarget?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AuthDeviceCreateInput = {
    createdAt?: Date | string
    credentialId: Bytes
    credentialPublicKey: Bytes
    counter: number
    id?: string
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutAuthDevicesInput
  }

  export type AuthDeviceUncheckedCreateInput = {
    createdAt?: Date | string
    credentialId: Bytes
    credentialPublicKey: Bytes
    counter: number
    id?: string
    updatedAt?: Date | string
    userId: string
  }

  export type AuthDeviceUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    credentialId?: BytesFieldUpdateOperationsInput | Bytes
    credentialPublicKey?: BytesFieldUpdateOperationsInput | Bytes
    counter?: IntFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAuthDevicesNestedInput
  }

  export type AuthDeviceUncheckedUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    credentialId?: BytesFieldUpdateOperationsInput | Bytes
    credentialPublicKey?: BytesFieldUpdateOperationsInput | Bytes
    counter?: IntFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AuthDeviceCreateManyInput = {
    createdAt?: Date | string
    credentialId: Bytes
    credentialPublicKey: Bytes
    counter: number
    id?: string
    updatedAt?: Date | string
    userId: string
  }

  export type AuthDeviceUpdateManyMutationInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    credentialId?: BytesFieldUpdateOperationsInput | Bytes
    credentialPublicKey?: BytesFieldUpdateOperationsInput | Bytes
    counter?: IntFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AuthDeviceUncheckedUpdateManyInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    credentialId?: BytesFieldUpdateOperationsInput | Bytes
    credentialPublicKey?: BytesFieldUpdateOperationsInput | Bytes
    counter?: IntFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type MarketDataCreateInput = {
    createdAt?: Date | string
    dataSource: $Enums.DataSource
    date: Date | string
    id?: string
    marketPrice: number
    state?: $Enums.MarketDataState
    symbol: string
  }

  export type MarketDataUncheckedCreateInput = {
    createdAt?: Date | string
    dataSource: $Enums.DataSource
    date: Date | string
    id?: string
    marketPrice: number
    state?: $Enums.MarketDataState
    symbol: string
  }

  export type MarketDataUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    marketPrice?: FloatFieldUpdateOperationsInput | number
    state?: EnumMarketDataStateFieldUpdateOperationsInput | $Enums.MarketDataState
    symbol?: StringFieldUpdateOperationsInput | string
  }

  export type MarketDataUncheckedUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    marketPrice?: FloatFieldUpdateOperationsInput | number
    state?: EnumMarketDataStateFieldUpdateOperationsInput | $Enums.MarketDataState
    symbol?: StringFieldUpdateOperationsInput | string
  }

  export type MarketDataCreateManyInput = {
    createdAt?: Date | string
    dataSource: $Enums.DataSource
    date: Date | string
    id?: string
    marketPrice: number
    state?: $Enums.MarketDataState
    symbol: string
  }

  export type MarketDataUpdateManyMutationInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    marketPrice?: FloatFieldUpdateOperationsInput | number
    state?: EnumMarketDataStateFieldUpdateOperationsInput | $Enums.MarketDataState
    symbol?: StringFieldUpdateOperationsInput | string
  }

  export type MarketDataUncheckedUpdateManyInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    marketPrice?: FloatFieldUpdateOperationsInput | number
    state?: EnumMarketDataStateFieldUpdateOperationsInput | $Enums.MarketDataState
    symbol?: StringFieldUpdateOperationsInput | string
  }

  export type OrderCreateInput = {
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    account?: AccountCreateNestedOneWithoutActivitiesInput
    tags?: TagCreateNestedManyWithoutActivitiesInput
    user: UserCreateNestedOneWithoutActivitiesInput
    SymbolProfile: SymbolProfileCreateNestedOneWithoutActivitiesInput
  }

  export type OrderUncheckedCreateInput = {
    accountId?: string | null
    accountUserId?: string | null
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    symbolProfileId: string
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    userId: string
    tags?: TagUncheckedCreateNestedManyWithoutActivitiesInput
  }

  export type OrderUpdateInput = {
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    account?: AccountUpdateOneWithoutActivitiesNestedInput
    tags?: TagUpdateManyWithoutActivitiesNestedInput
    user?: UserUpdateOneRequiredWithoutActivitiesNestedInput
    SymbolProfile?: SymbolProfileUpdateOneRequiredWithoutActivitiesNestedInput
  }

  export type OrderUncheckedUpdateInput = {
    accountId?: NullableStringFieldUpdateOperationsInput | string | null
    accountUserId?: NullableStringFieldUpdateOperationsInput | string | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    symbolProfileId?: StringFieldUpdateOperationsInput | string
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    tags?: TagUncheckedUpdateManyWithoutActivitiesNestedInput
  }

  export type OrderCreateManyInput = {
    accountId?: string | null
    accountUserId?: string | null
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    symbolProfileId: string
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    userId: string
  }

  export type OrderUpdateManyMutationInput = {
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OrderUncheckedUpdateManyInput = {
    accountId?: NullableStringFieldUpdateOperationsInput | string | null
    accountUserId?: NullableStringFieldUpdateOperationsInput | string | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    symbolProfileId?: StringFieldUpdateOperationsInput | string
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type PlatformCreateInput = {
    id?: string
    name?: string | null
    url: string
    accounts?: AccountCreateNestedManyWithoutPlatformInput
  }

  export type PlatformUncheckedCreateInput = {
    id?: string
    name?: string | null
    url: string
    accounts?: AccountUncheckedCreateNestedManyWithoutPlatformInput
  }

  export type PlatformUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
    accounts?: AccountUpdateManyWithoutPlatformNestedInput
  }

  export type PlatformUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
    accounts?: AccountUncheckedUpdateManyWithoutPlatformNestedInput
  }

  export type PlatformCreateManyInput = {
    id?: string
    name?: string | null
    url: string
  }

  export type PlatformUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
  }

  export type PlatformUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
  }

  export type PropertyCreateInput = {
    key: string
    value: string
  }

  export type PropertyUncheckedCreateInput = {
    key: string
    value: string
  }

  export type PropertyUpdateInput = {
    key?: StringFieldUpdateOperationsInput | string
    value?: StringFieldUpdateOperationsInput | string
  }

  export type PropertyUncheckedUpdateInput = {
    key?: StringFieldUpdateOperationsInput | string
    value?: StringFieldUpdateOperationsInput | string
  }

  export type PropertyCreateManyInput = {
    key: string
    value: string
  }

  export type PropertyUpdateManyMutationInput = {
    key?: StringFieldUpdateOperationsInput | string
    value?: StringFieldUpdateOperationsInput | string
  }

  export type PropertyUncheckedUpdateManyInput = {
    key?: StringFieldUpdateOperationsInput | string
    value?: StringFieldUpdateOperationsInput | string
  }

  export type SettingsCreateInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutSettingsInput
  }

  export type SettingsUncheckedCreateInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    userId: string
  }

  export type SettingsUpdateInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutSettingsNestedInput
  }

  export type SettingsUncheckedUpdateInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type SettingsCreateManyInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    userId: string
  }

  export type SettingsUpdateManyMutationInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SettingsUncheckedUpdateManyInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type SymbolProfileCreateInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    activities?: OrderCreateNestedManyWithoutSymbolProfileInput
    user?: UserCreateNestedOneWithoutSymbolProfileInput
    watchedBy?: UserCreateNestedManyWithoutWatchlistInput
    SymbolProfileOverrides?: SymbolProfileOverridesCreateNestedOneWithoutSymbolProfileInput
  }

  export type SymbolProfileUncheckedCreateInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    userId?: string | null
    activities?: OrderUncheckedCreateNestedManyWithoutSymbolProfileInput
    watchedBy?: UserUncheckedCreateNestedManyWithoutWatchlistInput
    SymbolProfileOverrides?: SymbolProfileOverridesUncheckedCreateNestedOneWithoutSymbolProfileInput
  }

  export type SymbolProfileUpdateInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    activities?: OrderUpdateManyWithoutSymbolProfileNestedInput
    user?: UserUpdateOneWithoutSymbolProfileNestedInput
    watchedBy?: UserUpdateManyWithoutWatchlistNestedInput
    SymbolProfileOverrides?: SymbolProfileOverridesUpdateOneWithoutSymbolProfileNestedInput
  }

  export type SymbolProfileUncheckedUpdateInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    activities?: OrderUncheckedUpdateManyWithoutSymbolProfileNestedInput
    watchedBy?: UserUncheckedUpdateManyWithoutWatchlistNestedInput
    SymbolProfileOverrides?: SymbolProfileOverridesUncheckedUpdateOneWithoutSymbolProfileNestedInput
  }

  export type SymbolProfileCreateManyInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    userId?: string | null
  }

  export type SymbolProfileUpdateManyMutationInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SymbolProfileUncheckedUpdateManyInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SymbolProfileOverridesCreateInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    url?: string | null
    SymbolProfile: SymbolProfileCreateNestedOneWithoutSymbolProfileOverridesInput
  }

  export type SymbolProfileOverridesUncheckedCreateInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbolProfileId: string
    updatedAt?: Date | string
    url?: string | null
  }

  export type SymbolProfileOverridesUpdateInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: NullableStringFieldUpdateOperationsInput | string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    url?: NullableStringFieldUpdateOperationsInput | string | null
    SymbolProfile?: SymbolProfileUpdateOneRequiredWithoutSymbolProfileOverridesNestedInput
  }

  export type SymbolProfileOverridesUncheckedUpdateInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: NullableStringFieldUpdateOperationsInput | string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbolProfileId?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    url?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SymbolProfileOverridesCreateManyInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbolProfileId: string
    updatedAt?: Date | string
    url?: string | null
  }

  export type SymbolProfileOverridesUpdateManyMutationInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: NullableStringFieldUpdateOperationsInput | string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    url?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SymbolProfileOverridesUncheckedUpdateManyInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: NullableStringFieldUpdateOperationsInput | string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbolProfileId?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    url?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SubscriptionCreateInput = {
    createdAt?: Date | string
    expiresAt: Date | string
    id?: string
    price?: number | null
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutSubscriptionsInput
  }

  export type SubscriptionUncheckedCreateInput = {
    createdAt?: Date | string
    expiresAt: Date | string
    id?: string
    price?: number | null
    updatedAt?: Date | string
    userId: string
  }

  export type SubscriptionUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    price?: NullableFloatFieldUpdateOperationsInput | number | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutSubscriptionsNestedInput
  }

  export type SubscriptionUncheckedUpdateInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    price?: NullableFloatFieldUpdateOperationsInput | number | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type SubscriptionCreateManyInput = {
    createdAt?: Date | string
    expiresAt: Date | string
    id?: string
    price?: number | null
    updatedAt?: Date | string
    userId: string
  }

  export type SubscriptionUpdateManyMutationInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    price?: NullableFloatFieldUpdateOperationsInput | number | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscriptionUncheckedUpdateManyInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    price?: NullableFloatFieldUpdateOperationsInput | number | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type TagCreateInput = {
    id?: string
    name: string
    activities?: OrderCreateNestedManyWithoutTagsInput
    user?: UserCreateNestedOneWithoutTagsInput
  }

  export type TagUncheckedCreateInput = {
    id?: string
    name: string
    userId?: string | null
    activities?: OrderUncheckedCreateNestedManyWithoutTagsInput
  }

  export type TagUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activities?: OrderUpdateManyWithoutTagsNestedInput
    user?: UserUpdateOneWithoutTagsNestedInput
  }

  export type TagUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    activities?: OrderUncheckedUpdateManyWithoutTagsNestedInput
  }

  export type TagCreateManyInput = {
    id?: string
    name: string
    userId?: string | null
  }

  export type TagUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type TagUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UserCreateInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserUpdateInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateManyInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
  }

  export type UserUpdateManyMutationInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUncheckedUpdateManyInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | 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>
    mode?: QueryMode
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type DateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type StringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    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>
    mode?: QueryMode
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type EnumAccessPermissionNullableListFilter<$PrismaModel = never> = {
    equals?: $Enums.AccessPermission[] | ListEnumAccessPermissionFieldRefInput<$PrismaModel> | null
    has?: $Enums.AccessPermission | EnumAccessPermissionFieldRefInput<$PrismaModel> | null
    hasEvery?: $Enums.AccessPermission[] | ListEnumAccessPermissionFieldRefInput<$PrismaModel>
    hasSome?: $Enums.AccessPermission[] | ListEnumAccessPermissionFieldRefInput<$PrismaModel>
    isEmpty?: boolean
  }
  export type JsonFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>

  export type JsonFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type UserNullableScalarRelationFilter = {
    is?: UserWhereInput | null
    isNot?: UserWhereInput | null
  }

  export type UserScalarRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type AccessCountOrderByAggregateInput = {
    alias?: SortOrder
    createdAt?: SortOrder
    granteeUserId?: SortOrder
    id?: SortOrder
    permissions?: SortOrder
    settings?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AccessMaxOrderByAggregateInput = {
    alias?: SortOrder
    createdAt?: SortOrder
    granteeUserId?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AccessMinOrderByAggregateInput = {
    alias?: SortOrder
    createdAt?: SortOrder
    granteeUserId?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | 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>
    mode?: QueryMode
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type StringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    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>
    mode?: QueryMode
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }
  export type JsonWithAggregatesFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedJsonFilter<$PrismaModel>
    _max?: NestedJsonFilter<$PrismaModel>
  }

  export type FloatFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }

  export type BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type OrderListRelationFilter = {
    every?: OrderWhereInput
    some?: OrderWhereInput
    none?: OrderWhereInput
  }

  export type AccountBalanceListRelationFilter = {
    every?: AccountBalanceWhereInput
    some?: AccountBalanceWhereInput
    none?: AccountBalanceWhereInput
  }

  export type PlatformNullableScalarRelationFilter = {
    is?: PlatformWhereInput | null
    isNot?: PlatformWhereInput | null
  }

  export type OrderOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AccountBalanceOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AccountIdUserIdCompoundUniqueInput = {
    id: string
    userId: string
  }

  export type AccountCountOrderByAggregateInput = {
    balance?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    id?: SortOrder
    isExcluded?: SortOrder
    name?: SortOrder
    platformId?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AccountAvgOrderByAggregateInput = {
    balance?: SortOrder
  }

  export type AccountMaxOrderByAggregateInput = {
    balance?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    id?: SortOrder
    isExcluded?: SortOrder
    name?: SortOrder
    platformId?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AccountMinOrderByAggregateInput = {
    balance?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    id?: SortOrder
    isExcluded?: SortOrder
    name?: SortOrder
    platformId?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AccountSumOrderByAggregateInput = {
    balance?: SortOrder
  }

  export type FloatWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type AccountScalarRelationFilter = {
    is?: AccountWhereInput
    isNot?: AccountWhereInput
  }

  export type AccountBalanceAccountIdDateCompoundUniqueInput = {
    accountId: string
    date: Date | string
  }

  export type AccountBalanceCountOrderByAggregateInput = {
    accountId?: SortOrder
    createdAt?: SortOrder
    date?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    value?: SortOrder
  }

  export type AccountBalanceAvgOrderByAggregateInput = {
    value?: SortOrder
  }

  export type AccountBalanceMaxOrderByAggregateInput = {
    accountId?: SortOrder
    createdAt?: SortOrder
    date?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    value?: SortOrder
  }

  export type AccountBalanceMinOrderByAggregateInput = {
    accountId?: SortOrder
    createdAt?: SortOrder
    date?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
    value?: SortOrder
  }

  export type AccountBalanceSumOrderByAggregateInput = {
    value?: SortOrder
  }

  export type IntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type AnalyticsCountOrderByAggregateInput = {
    activityCount?: SortOrder
    country?: SortOrder
    dataProviderGhostfolioDailyRequests?: SortOrder
    lastRequestAt?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AnalyticsAvgOrderByAggregateInput = {
    activityCount?: SortOrder
    dataProviderGhostfolioDailyRequests?: SortOrder
  }

  export type AnalyticsMaxOrderByAggregateInput = {
    activityCount?: SortOrder
    country?: SortOrder
    dataProviderGhostfolioDailyRequests?: SortOrder
    lastRequestAt?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AnalyticsMinOrderByAggregateInput = {
    activityCount?: SortOrder
    country?: SortOrder
    dataProviderGhostfolioDailyRequests?: SortOrder
    lastRequestAt?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AnalyticsSumOrderByAggregateInput = {
    activityCount?: SortOrder
    dataProviderGhostfolioDailyRequests?: SortOrder
  }

  export type IntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    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 ApiKeyCountOrderByAggregateInput = {
    createdAt?: SortOrder
    hashedKey?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type ApiKeyMaxOrderByAggregateInput = {
    createdAt?: SortOrder
    hashedKey?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type ApiKeyMinOrderByAggregateInput = {
    createdAt?: SortOrder
    hashedKey?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type EnumDataSourceFilter<$PrismaModel = never> = {
    equals?: $Enums.DataSource | EnumDataSourceFieldRefInput<$PrismaModel>
    in?: $Enums.DataSource[] | ListEnumDataSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.DataSource[] | ListEnumDataSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumDataSourceFilter<$PrismaModel> | $Enums.DataSource
  }

  export type AssetProfileResolutionDataSourceOriginSymbolOriginCompoundUniqueInput = {
    dataSourceOrigin: $Enums.DataSource
    symbolOrigin: string
  }

  export type AssetProfileResolutionCountOrderByAggregateInput = {
    createdAt?: SortOrder
    currency?: SortOrder
    dataSourceOrigin?: SortOrder
    dataSourceTarget?: SortOrder
    id?: SortOrder
    requestCount?: SortOrder
    symbolOrigin?: SortOrder
    symbolTarget?: SortOrder
    updatedAt?: SortOrder
  }

  export type AssetProfileResolutionAvgOrderByAggregateInput = {
    requestCount?: SortOrder
  }

  export type AssetProfileResolutionMaxOrderByAggregateInput = {
    createdAt?: SortOrder
    currency?: SortOrder
    dataSourceOrigin?: SortOrder
    dataSourceTarget?: SortOrder
    id?: SortOrder
    requestCount?: SortOrder
    symbolOrigin?: SortOrder
    symbolTarget?: SortOrder
    updatedAt?: SortOrder
  }

  export type AssetProfileResolutionMinOrderByAggregateInput = {
    createdAt?: SortOrder
    currency?: SortOrder
    dataSourceOrigin?: SortOrder
    dataSourceTarget?: SortOrder
    id?: SortOrder
    requestCount?: SortOrder
    symbolOrigin?: SortOrder
    symbolTarget?: SortOrder
    updatedAt?: SortOrder
  }

  export type AssetProfileResolutionSumOrderByAggregateInput = {
    requestCount?: SortOrder
  }

  export type EnumDataSourceWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.DataSource | EnumDataSourceFieldRefInput<$PrismaModel>
    in?: $Enums.DataSource[] | ListEnumDataSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.DataSource[] | ListEnumDataSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumDataSourceWithAggregatesFilter<$PrismaModel> | $Enums.DataSource
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumDataSourceFilter<$PrismaModel>
    _max?: NestedEnumDataSourceFilter<$PrismaModel>
  }

  export type BytesFilter<$PrismaModel = never> = {
    equals?: Bytes | BytesFieldRefInput<$PrismaModel>
    in?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    notIn?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    not?: NestedBytesFilter<$PrismaModel> | Bytes
  }

  export type AuthDeviceCountOrderByAggregateInput = {
    createdAt?: SortOrder
    credentialId?: SortOrder
    credentialPublicKey?: SortOrder
    counter?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AuthDeviceAvgOrderByAggregateInput = {
    counter?: SortOrder
  }

  export type AuthDeviceMaxOrderByAggregateInput = {
    createdAt?: SortOrder
    credentialId?: SortOrder
    credentialPublicKey?: SortOrder
    counter?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AuthDeviceMinOrderByAggregateInput = {
    createdAt?: SortOrder
    credentialId?: SortOrder
    credentialPublicKey?: SortOrder
    counter?: SortOrder
    id?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type AuthDeviceSumOrderByAggregateInput = {
    counter?: SortOrder
  }

  export type BytesWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Bytes | BytesFieldRefInput<$PrismaModel>
    in?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    notIn?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    not?: NestedBytesWithAggregatesFilter<$PrismaModel> | Bytes
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBytesFilter<$PrismaModel>
    _max?: NestedBytesFilter<$PrismaModel>
  }

  export type EnumMarketDataStateFilter<$PrismaModel = never> = {
    equals?: $Enums.MarketDataState | EnumMarketDataStateFieldRefInput<$PrismaModel>
    in?: $Enums.MarketDataState[] | ListEnumMarketDataStateFieldRefInput<$PrismaModel>
    notIn?: $Enums.MarketDataState[] | ListEnumMarketDataStateFieldRefInput<$PrismaModel>
    not?: NestedEnumMarketDataStateFilter<$PrismaModel> | $Enums.MarketDataState
  }

  export type MarketDataDataSourceDateSymbolCompoundUniqueInput = {
    dataSource: $Enums.DataSource
    date: Date | string
    symbol: string
  }

  export type MarketDataCountOrderByAggregateInput = {
    createdAt?: SortOrder
    dataSource?: SortOrder
    date?: SortOrder
    id?: SortOrder
    marketPrice?: SortOrder
    state?: SortOrder
    symbol?: SortOrder
  }

  export type MarketDataAvgOrderByAggregateInput = {
    marketPrice?: SortOrder
  }

  export type MarketDataMaxOrderByAggregateInput = {
    createdAt?: SortOrder
    dataSource?: SortOrder
    date?: SortOrder
    id?: SortOrder
    marketPrice?: SortOrder
    state?: SortOrder
    symbol?: SortOrder
  }

  export type MarketDataMinOrderByAggregateInput = {
    createdAt?: SortOrder
    dataSource?: SortOrder
    date?: SortOrder
    id?: SortOrder
    marketPrice?: SortOrder
    state?: SortOrder
    symbol?: SortOrder
  }

  export type MarketDataSumOrderByAggregateInput = {
    marketPrice?: SortOrder
  }

  export type EnumMarketDataStateWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MarketDataState | EnumMarketDataStateFieldRefInput<$PrismaModel>
    in?: $Enums.MarketDataState[] | ListEnumMarketDataStateFieldRefInput<$PrismaModel>
    notIn?: $Enums.MarketDataState[] | ListEnumMarketDataStateFieldRefInput<$PrismaModel>
    not?: NestedEnumMarketDataStateWithAggregatesFilter<$PrismaModel> | $Enums.MarketDataState
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMarketDataStateFilter<$PrismaModel>
    _max?: NestedEnumMarketDataStateFilter<$PrismaModel>
  }

  export type EnumTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.Type | EnumTypeFieldRefInput<$PrismaModel>
    in?: $Enums.Type[] | ListEnumTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.Type[] | ListEnumTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumTypeFilter<$PrismaModel> | $Enums.Type
  }

  export type AccountNullableScalarRelationFilter = {
    is?: AccountWhereInput | null
    isNot?: AccountWhereInput | null
  }

  export type TagListRelationFilter = {
    every?: TagWhereInput
    some?: TagWhereInput
    none?: TagWhereInput
  }

  export type SymbolProfileScalarRelationFilter = {
    is?: SymbolProfileWhereInput
    isNot?: SymbolProfileWhereInput
  }

  export type TagOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type OrderCountOrderByAggregateInput = {
    accountId?: SortOrder
    accountUserId?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    date?: SortOrder
    fee?: SortOrder
    id?: SortOrder
    isDraft?: SortOrder
    quantity?: SortOrder
    symbolProfileId?: SortOrder
    type?: SortOrder
    unitPrice?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type OrderAvgOrderByAggregateInput = {
    fee?: SortOrder
    quantity?: SortOrder
    unitPrice?: SortOrder
  }

  export type OrderMaxOrderByAggregateInput = {
    accountId?: SortOrder
    accountUserId?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    date?: SortOrder
    fee?: SortOrder
    id?: SortOrder
    isDraft?: SortOrder
    quantity?: SortOrder
    symbolProfileId?: SortOrder
    type?: SortOrder
    unitPrice?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type OrderMinOrderByAggregateInput = {
    accountId?: SortOrder
    accountUserId?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    date?: SortOrder
    fee?: SortOrder
    id?: SortOrder
    isDraft?: SortOrder
    quantity?: SortOrder
    symbolProfileId?: SortOrder
    type?: SortOrder
    unitPrice?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type OrderSumOrderByAggregateInput = {
    fee?: SortOrder
    quantity?: SortOrder
    unitPrice?: SortOrder
  }

  export type EnumTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Type | EnumTypeFieldRefInput<$PrismaModel>
    in?: $Enums.Type[] | ListEnumTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.Type[] | ListEnumTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumTypeWithAggregatesFilter<$PrismaModel> | $Enums.Type
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumTypeFilter<$PrismaModel>
    _max?: NestedEnumTypeFilter<$PrismaModel>
  }

  export type AccountListRelationFilter = {
    every?: AccountWhereInput
    some?: AccountWhereInput
    none?: AccountWhereInput
  }

  export type AccountOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PlatformCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    url?: SortOrder
  }

  export type PlatformMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    url?: SortOrder
  }

  export type PlatformMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    url?: SortOrder
  }

  export type PropertyCountOrderByAggregateInput = {
    key?: SortOrder
    value?: SortOrder
  }

  export type PropertyMaxOrderByAggregateInput = {
    key?: SortOrder
    value?: SortOrder
  }

  export type PropertyMinOrderByAggregateInput = {
    key?: SortOrder
    value?: SortOrder
  }
  export type JsonNullableFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type SettingsCountOrderByAggregateInput = {
    settings?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type SettingsMaxOrderByAggregateInput = {
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type SettingsMinOrderByAggregateInput = {
    updatedAt?: SortOrder
    userId?: SortOrder
  }
  export type JsonNullableWithAggregatesFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonNullableWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonNullableWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedJsonNullableFilter<$PrismaModel>
    _max?: NestedJsonNullableFilter<$PrismaModel>
  }

  export type EnumAssetClassNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.AssetClass | EnumAssetClassFieldRefInput<$PrismaModel> | null
    in?: $Enums.AssetClass[] | ListEnumAssetClassFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AssetClass[] | ListEnumAssetClassFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAssetClassNullableFilter<$PrismaModel> | $Enums.AssetClass | null
  }

  export type EnumAssetSubClassNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.AssetSubClass | EnumAssetSubClassFieldRefInput<$PrismaModel> | null
    in?: $Enums.AssetSubClass[] | ListEnumAssetSubClassFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AssetSubClass[] | ListEnumAssetSubClassFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAssetSubClassNullableFilter<$PrismaModel> | $Enums.AssetSubClass | null
  }

  export type UserListRelationFilter = {
    every?: UserWhereInput
    some?: UserWhereInput
    none?: UserWhereInput
  }

  export type SymbolProfileOverridesNullableScalarRelationFilter = {
    is?: SymbolProfileOverridesWhereInput | null
    isNot?: SymbolProfileOverridesWhereInput | null
  }

  export type UserOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SymbolProfileDataSourceSymbolCompoundUniqueInput = {
    dataSource: $Enums.DataSource
    symbol: string
  }

  export type SymbolProfileCountOrderByAggregateInput = {
    assetClass?: SortOrder
    assetSubClass?: SortOrder
    comment?: SortOrder
    countries?: SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    cusip?: SortOrder
    dataSource?: SortOrder
    figi?: SortOrder
    figiComposite?: SortOrder
    figiShareClass?: SortOrder
    holdings?: SortOrder
    id?: SortOrder
    isActive?: SortOrder
    isin?: SortOrder
    name?: SortOrder
    updatedAt?: SortOrder
    scraperConfiguration?: SortOrder
    sectors?: SortOrder
    symbol?: SortOrder
    symbolMapping?: SortOrder
    url?: SortOrder
    userId?: SortOrder
  }

  export type SymbolProfileMaxOrderByAggregateInput = {
    assetClass?: SortOrder
    assetSubClass?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    cusip?: SortOrder
    dataSource?: SortOrder
    figi?: SortOrder
    figiComposite?: SortOrder
    figiShareClass?: SortOrder
    id?: SortOrder
    isActive?: SortOrder
    isin?: SortOrder
    name?: SortOrder
    updatedAt?: SortOrder
    symbol?: SortOrder
    url?: SortOrder
    userId?: SortOrder
  }

  export type SymbolProfileMinOrderByAggregateInput = {
    assetClass?: SortOrder
    assetSubClass?: SortOrder
    comment?: SortOrder
    createdAt?: SortOrder
    currency?: SortOrder
    cusip?: SortOrder
    dataSource?: SortOrder
    figi?: SortOrder
    figiComposite?: SortOrder
    figiShareClass?: SortOrder
    id?: SortOrder
    isActive?: SortOrder
    isin?: SortOrder
    name?: SortOrder
    updatedAt?: SortOrder
    symbol?: SortOrder
    url?: SortOrder
    userId?: SortOrder
  }

  export type EnumAssetClassNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AssetClass | EnumAssetClassFieldRefInput<$PrismaModel> | null
    in?: $Enums.AssetClass[] | ListEnumAssetClassFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AssetClass[] | ListEnumAssetClassFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAssetClassNullableWithAggregatesFilter<$PrismaModel> | $Enums.AssetClass | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumAssetClassNullableFilter<$PrismaModel>
    _max?: NestedEnumAssetClassNullableFilter<$PrismaModel>
  }

  export type EnumAssetSubClassNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AssetSubClass | EnumAssetSubClassFieldRefInput<$PrismaModel> | null
    in?: $Enums.AssetSubClass[] | ListEnumAssetSubClassFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AssetSubClass[] | ListEnumAssetSubClassFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAssetSubClassNullableWithAggregatesFilter<$PrismaModel> | $Enums.AssetSubClass | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumAssetSubClassNullableFilter<$PrismaModel>
    _max?: NestedEnumAssetSubClassNullableFilter<$PrismaModel>
  }

  export type SymbolProfileOverridesCountOrderByAggregateInput = {
    assetClass?: SortOrder
    assetSubClass?: SortOrder
    countries?: SortOrder
    holdings?: SortOrder
    name?: SortOrder
    sectors?: SortOrder
    symbolProfileId?: SortOrder
    updatedAt?: SortOrder
    url?: SortOrder
  }

  export type SymbolProfileOverridesMaxOrderByAggregateInput = {
    assetClass?: SortOrder
    assetSubClass?: SortOrder
    name?: SortOrder
    symbolProfileId?: SortOrder
    updatedAt?: SortOrder
    url?: SortOrder
  }

  export type SymbolProfileOverridesMinOrderByAggregateInput = {
    assetClass?: SortOrder
    assetSubClass?: SortOrder
    name?: SortOrder
    symbolProfileId?: SortOrder
    updatedAt?: SortOrder
    url?: SortOrder
  }

  export type FloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type SubscriptionCountOrderByAggregateInput = {
    createdAt?: SortOrder
    expiresAt?: SortOrder
    id?: SortOrder
    price?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type SubscriptionAvgOrderByAggregateInput = {
    price?: SortOrder
  }

  export type SubscriptionMaxOrderByAggregateInput = {
    createdAt?: SortOrder
    expiresAt?: SortOrder
    id?: SortOrder
    price?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type SubscriptionMinOrderByAggregateInput = {
    createdAt?: SortOrder
    expiresAt?: SortOrder
    id?: SortOrder
    price?: SortOrder
    updatedAt?: SortOrder
    userId?: SortOrder
  }

  export type SubscriptionSumOrderByAggregateInput = {
    price?: SortOrder
  }

  export type FloatNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type TagNameUserIdCompoundUniqueInput = {
    name: string
    userId: string
  }

  export type TagCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
  }

  export type TagMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
  }

  export type TagMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    userId?: SortOrder
  }

  export type EnumProviderFilter<$PrismaModel = never> = {
    equals?: $Enums.Provider | EnumProviderFieldRefInput<$PrismaModel>
    in?: $Enums.Provider[] | ListEnumProviderFieldRefInput<$PrismaModel>
    notIn?: $Enums.Provider[] | ListEnumProviderFieldRefInput<$PrismaModel>
    not?: NestedEnumProviderFilter<$PrismaModel> | $Enums.Provider
  }

  export type EnumRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleFilter<$PrismaModel> | $Enums.Role
  }

  export type AccessListRelationFilter = {
    every?: AccessWhereInput
    some?: AccessWhereInput
    none?: AccessWhereInput
  }

  export type AnalyticsNullableScalarRelationFilter = {
    is?: AnalyticsWhereInput | null
    isNot?: AnalyticsWhereInput | null
  }

  export type ApiKeyListRelationFilter = {
    every?: ApiKeyWhereInput
    some?: ApiKeyWhereInput
    none?: ApiKeyWhereInput
  }

  export type AuthDeviceListRelationFilter = {
    every?: AuthDeviceWhereInput
    some?: AuthDeviceWhereInput
    none?: AuthDeviceWhereInput
  }

  export type SettingsNullableScalarRelationFilter = {
    is?: SettingsWhereInput | null
    isNot?: SettingsWhereInput | null
  }

  export type SubscriptionListRelationFilter = {
    every?: SubscriptionWhereInput
    some?: SubscriptionWhereInput
    none?: SubscriptionWhereInput
  }

  export type SymbolProfileListRelationFilter = {
    every?: SymbolProfileWhereInput
    some?: SymbolProfileWhereInput
    none?: SymbolProfileWhereInput
  }

  export type AccessOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ApiKeyOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AuthDeviceOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SubscriptionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SymbolProfileOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserCountOrderByAggregateInput = {
    accessToken?: SortOrder
    authChallenge?: SortOrder
    createdAt?: SortOrder
    id?: SortOrder
    provider?: SortOrder
    role?: SortOrder
    thirdPartyId?: SortOrder
    updatedAt?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    accessToken?: SortOrder
    authChallenge?: SortOrder
    createdAt?: SortOrder
    id?: SortOrder
    provider?: SortOrder
    role?: SortOrder
    thirdPartyId?: SortOrder
    updatedAt?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    accessToken?: SortOrder
    authChallenge?: SortOrder
    createdAt?: SortOrder
    id?: SortOrder
    provider?: SortOrder
    role?: SortOrder
    thirdPartyId?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumProviderWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Provider | EnumProviderFieldRefInput<$PrismaModel>
    in?: $Enums.Provider[] | ListEnumProviderFieldRefInput<$PrismaModel>
    notIn?: $Enums.Provider[] | ListEnumProviderFieldRefInput<$PrismaModel>
    not?: NestedEnumProviderWithAggregatesFilter<$PrismaModel> | $Enums.Provider
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumProviderFilter<$PrismaModel>
    _max?: NestedEnumProviderFilter<$PrismaModel>
  }

  export type EnumRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleWithAggregatesFilter<$PrismaModel> | $Enums.Role
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRoleFilter<$PrismaModel>
    _max?: NestedEnumRoleFilter<$PrismaModel>
  }

  export type AccessCreatepermissionsInput = {
    set: $Enums.AccessPermission[]
  }

  export type UserCreateNestedOneWithoutAccessesGetInput = {
    create?: XOR<UserCreateWithoutAccessesGetInput, UserUncheckedCreateWithoutAccessesGetInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccessesGetInput
    connect?: UserWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutAccessesGiveInput = {
    create?: XOR<UserCreateWithoutAccessesGiveInput, UserUncheckedCreateWithoutAccessesGiveInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccessesGiveInput
    connect?: UserWhereUniqueInput
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type AccessUpdatepermissionsInput = {
    set?: $Enums.AccessPermission[]
    push?: $Enums.AccessPermission | $Enums.AccessPermission[]
  }

  export type UserUpdateOneWithoutAccessesGetNestedInput = {
    create?: XOR<UserCreateWithoutAccessesGetInput, UserUncheckedCreateWithoutAccessesGetInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccessesGetInput
    upsert?: UserUpsertWithoutAccessesGetInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAccessesGetInput, UserUpdateWithoutAccessesGetInput>, UserUncheckedUpdateWithoutAccessesGetInput>
  }

  export type UserUpdateOneRequiredWithoutAccessesGiveNestedInput = {
    create?: XOR<UserCreateWithoutAccessesGiveInput, UserUncheckedCreateWithoutAccessesGiveInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccessesGiveInput
    upsert?: UserUpsertWithoutAccessesGiveInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAccessesGiveInput, UserUpdateWithoutAccessesGiveInput>, UserUncheckedUpdateWithoutAccessesGiveInput>
  }

  export type OrderCreateNestedManyWithoutAccountInput = {
    create?: XOR<OrderCreateWithoutAccountInput, OrderUncheckedCreateWithoutAccountInput> | OrderCreateWithoutAccountInput[] | OrderUncheckedCreateWithoutAccountInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutAccountInput | OrderCreateOrConnectWithoutAccountInput[]
    createMany?: OrderCreateManyAccountInputEnvelope
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type AccountBalanceCreateNestedManyWithoutAccountInput = {
    create?: XOR<AccountBalanceCreateWithoutAccountInput, AccountBalanceUncheckedCreateWithoutAccountInput> | AccountBalanceCreateWithoutAccountInput[] | AccountBalanceUncheckedCreateWithoutAccountInput[]
    connectOrCreate?: AccountBalanceCreateOrConnectWithoutAccountInput | AccountBalanceCreateOrConnectWithoutAccountInput[]
    createMany?: AccountBalanceCreateManyAccountInputEnvelope
    connect?: AccountBalanceWhereUniqueInput | AccountBalanceWhereUniqueInput[]
  }

  export type PlatformCreateNestedOneWithoutAccountsInput = {
    create?: XOR<PlatformCreateWithoutAccountsInput, PlatformUncheckedCreateWithoutAccountsInput>
    connectOrCreate?: PlatformCreateOrConnectWithoutAccountsInput
    connect?: PlatformWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutAccountsInput = {
    create?: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccountsInput
    connect?: UserWhereUniqueInput
  }

  export type OrderUncheckedCreateNestedManyWithoutAccountInput = {
    create?: XOR<OrderCreateWithoutAccountInput, OrderUncheckedCreateWithoutAccountInput> | OrderCreateWithoutAccountInput[] | OrderUncheckedCreateWithoutAccountInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutAccountInput | OrderCreateOrConnectWithoutAccountInput[]
    createMany?: OrderCreateManyAccountInputEnvelope
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type AccountBalanceUncheckedCreateNestedManyWithoutAccountInput = {
    create?: XOR<AccountBalanceCreateWithoutAccountInput, AccountBalanceUncheckedCreateWithoutAccountInput> | AccountBalanceCreateWithoutAccountInput[] | AccountBalanceUncheckedCreateWithoutAccountInput[]
    connectOrCreate?: AccountBalanceCreateOrConnectWithoutAccountInput | AccountBalanceCreateOrConnectWithoutAccountInput[]
    createMany?: AccountBalanceCreateManyAccountInputEnvelope
    connect?: AccountBalanceWhereUniqueInput | AccountBalanceWhereUniqueInput[]
  }

  export type FloatFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type OrderUpdateManyWithoutAccountNestedInput = {
    create?: XOR<OrderCreateWithoutAccountInput, OrderUncheckedCreateWithoutAccountInput> | OrderCreateWithoutAccountInput[] | OrderUncheckedCreateWithoutAccountInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutAccountInput | OrderCreateOrConnectWithoutAccountInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutAccountInput | OrderUpsertWithWhereUniqueWithoutAccountInput[]
    createMany?: OrderCreateManyAccountInputEnvelope
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutAccountInput | OrderUpdateWithWhereUniqueWithoutAccountInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutAccountInput | OrderUpdateManyWithWhereWithoutAccountInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type AccountBalanceUpdateManyWithoutAccountNestedInput = {
    create?: XOR<AccountBalanceCreateWithoutAccountInput, AccountBalanceUncheckedCreateWithoutAccountInput> | AccountBalanceCreateWithoutAccountInput[] | AccountBalanceUncheckedCreateWithoutAccountInput[]
    connectOrCreate?: AccountBalanceCreateOrConnectWithoutAccountInput | AccountBalanceCreateOrConnectWithoutAccountInput[]
    upsert?: AccountBalanceUpsertWithWhereUniqueWithoutAccountInput | AccountBalanceUpsertWithWhereUniqueWithoutAccountInput[]
    createMany?: AccountBalanceCreateManyAccountInputEnvelope
    set?: AccountBalanceWhereUniqueInput | AccountBalanceWhereUniqueInput[]
    disconnect?: AccountBalanceWhereUniqueInput | AccountBalanceWhereUniqueInput[]
    delete?: AccountBalanceWhereUniqueInput | AccountBalanceWhereUniqueInput[]
    connect?: AccountBalanceWhereUniqueInput | AccountBalanceWhereUniqueInput[]
    update?: AccountBalanceUpdateWithWhereUniqueWithoutAccountInput | AccountBalanceUpdateWithWhereUniqueWithoutAccountInput[]
    updateMany?: AccountBalanceUpdateManyWithWhereWithoutAccountInput | AccountBalanceUpdateManyWithWhereWithoutAccountInput[]
    deleteMany?: AccountBalanceScalarWhereInput | AccountBalanceScalarWhereInput[]
  }

  export type PlatformUpdateOneWithoutAccountsNestedInput = {
    create?: XOR<PlatformCreateWithoutAccountsInput, PlatformUncheckedCreateWithoutAccountsInput>
    connectOrCreate?: PlatformCreateOrConnectWithoutAccountsInput
    upsert?: PlatformUpsertWithoutAccountsInput
    disconnect?: PlatformWhereInput | boolean
    delete?: PlatformWhereInput | boolean
    connect?: PlatformWhereUniqueInput
    update?: XOR<XOR<PlatformUpdateToOneWithWhereWithoutAccountsInput, PlatformUpdateWithoutAccountsInput>, PlatformUncheckedUpdateWithoutAccountsInput>
  }

  export type UserUpdateOneRequiredWithoutAccountsNestedInput = {
    create?: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAccountsInput
    upsert?: UserUpsertWithoutAccountsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAccountsInput, UserUpdateWithoutAccountsInput>, UserUncheckedUpdateWithoutAccountsInput>
  }

  export type OrderUncheckedUpdateManyWithoutAccountNestedInput = {
    create?: XOR<OrderCreateWithoutAccountInput, OrderUncheckedCreateWithoutAccountInput> | OrderCreateWithoutAccountInput[] | OrderUncheckedCreateWithoutAccountInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutAccountInput | OrderCreateOrConnectWithoutAccountInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutAccountInput | OrderUpsertWithWhereUniqueWithoutAccountInput[]
    createMany?: OrderCreateManyAccountInputEnvelope
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutAccountInput | OrderUpdateWithWhereUniqueWithoutAccountInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutAccountInput | OrderUpdateManyWithWhereWithoutAccountInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type AccountBalanceUncheckedUpdateManyWithoutAccountNestedInput = {
    create?: XOR<AccountBalanceCreateWithoutAccountInput, AccountBalanceUncheckedCreateWithoutAccountInput> | AccountBalanceCreateWithoutAccountInput[] | AccountBalanceUncheckedCreateWithoutAccountInput[]
    connectOrCreate?: AccountBalanceCreateOrConnectWithoutAccountInput | AccountBalanceCreateOrConnectWithoutAccountInput[]
    upsert?: AccountBalanceUpsertWithWhereUniqueWithoutAccountInput | AccountBalanceUpsertWithWhereUniqueWithoutAccountInput[]
    createMany?: AccountBalanceCreateManyAccountInputEnvelope
    set?: AccountBalanceWhereUniqueInput | AccountBalanceWhereUniqueInput[]
    disconnect?: AccountBalanceWhereUniqueInput | AccountBalanceWhereUniqueInput[]
    delete?: AccountBalanceWhereUniqueInput | AccountBalanceWhereUniqueInput[]
    connect?: AccountBalanceWhereUniqueInput | AccountBalanceWhereUniqueInput[]
    update?: AccountBalanceUpdateWithWhereUniqueWithoutAccountInput | AccountBalanceUpdateWithWhereUniqueWithoutAccountInput[]
    updateMany?: AccountBalanceUpdateManyWithWhereWithoutAccountInput | AccountBalanceUpdateManyWithWhereWithoutAccountInput[]
    deleteMany?: AccountBalanceScalarWhereInput | AccountBalanceScalarWhereInput[]
  }

  export type AccountCreateNestedOneWithoutBalancesInput = {
    create?: XOR<AccountCreateWithoutBalancesInput, AccountUncheckedCreateWithoutBalancesInput>
    connectOrCreate?: AccountCreateOrConnectWithoutBalancesInput
    connect?: AccountWhereUniqueInput
  }

  export type AccountUpdateOneRequiredWithoutBalancesNestedInput = {
    create?: XOR<AccountCreateWithoutBalancesInput, AccountUncheckedCreateWithoutBalancesInput>
    connectOrCreate?: AccountCreateOrConnectWithoutBalancesInput
    upsert?: AccountUpsertWithoutBalancesInput
    connect?: AccountWhereUniqueInput
    update?: XOR<XOR<AccountUpdateToOneWithWhereWithoutBalancesInput, AccountUpdateWithoutBalancesInput>, AccountUncheckedUpdateWithoutBalancesInput>
  }

  export type UserCreateNestedOneWithoutAnalyticsInput = {
    create?: XOR<UserCreateWithoutAnalyticsInput, UserUncheckedCreateWithoutAnalyticsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAnalyticsInput
    connect?: UserWhereUniqueInput
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type UserUpdateOneRequiredWithoutAnalyticsNestedInput = {
    create?: XOR<UserCreateWithoutAnalyticsInput, UserUncheckedCreateWithoutAnalyticsInput>
    connectOrCreate?: UserCreateOrConnectWithoutAnalyticsInput
    upsert?: UserUpsertWithoutAnalyticsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAnalyticsInput, UserUpdateWithoutAnalyticsInput>, UserUncheckedUpdateWithoutAnalyticsInput>
  }

  export type UserCreateNestedOneWithoutApiKeysInput = {
    create?: XOR<UserCreateWithoutApiKeysInput, UserUncheckedCreateWithoutApiKeysInput>
    connectOrCreate?: UserCreateOrConnectWithoutApiKeysInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutApiKeysNestedInput = {
    create?: XOR<UserCreateWithoutApiKeysInput, UserUncheckedCreateWithoutApiKeysInput>
    connectOrCreate?: UserCreateOrConnectWithoutApiKeysInput
    upsert?: UserUpsertWithoutApiKeysInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutApiKeysInput, UserUpdateWithoutApiKeysInput>, UserUncheckedUpdateWithoutApiKeysInput>
  }

  export type EnumDataSourceFieldUpdateOperationsInput = {
    set?: $Enums.DataSource
  }

  export type UserCreateNestedOneWithoutAuthDevicesInput = {
    create?: XOR<UserCreateWithoutAuthDevicesInput, UserUncheckedCreateWithoutAuthDevicesInput>
    connectOrCreate?: UserCreateOrConnectWithoutAuthDevicesInput
    connect?: UserWhereUniqueInput
  }

  export type BytesFieldUpdateOperationsInput = {
    set?: Bytes
  }

  export type UserUpdateOneRequiredWithoutAuthDevicesNestedInput = {
    create?: XOR<UserCreateWithoutAuthDevicesInput, UserUncheckedCreateWithoutAuthDevicesInput>
    connectOrCreate?: UserCreateOrConnectWithoutAuthDevicesInput
    upsert?: UserUpsertWithoutAuthDevicesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutAuthDevicesInput, UserUpdateWithoutAuthDevicesInput>, UserUncheckedUpdateWithoutAuthDevicesInput>
  }

  export type EnumMarketDataStateFieldUpdateOperationsInput = {
    set?: $Enums.MarketDataState
  }

  export type AccountCreateNestedOneWithoutActivitiesInput = {
    create?: XOR<AccountCreateWithoutActivitiesInput, AccountUncheckedCreateWithoutActivitiesInput>
    connectOrCreate?: AccountCreateOrConnectWithoutActivitiesInput
    connect?: AccountWhereUniqueInput
  }

  export type TagCreateNestedManyWithoutActivitiesInput = {
    create?: XOR<TagCreateWithoutActivitiesInput, TagUncheckedCreateWithoutActivitiesInput> | TagCreateWithoutActivitiesInput[] | TagUncheckedCreateWithoutActivitiesInput[]
    connectOrCreate?: TagCreateOrConnectWithoutActivitiesInput | TagCreateOrConnectWithoutActivitiesInput[]
    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
  }

  export type UserCreateNestedOneWithoutActivitiesInput = {
    create?: XOR<UserCreateWithoutActivitiesInput, UserUncheckedCreateWithoutActivitiesInput>
    connectOrCreate?: UserCreateOrConnectWithoutActivitiesInput
    connect?: UserWhereUniqueInput
  }

  export type SymbolProfileCreateNestedOneWithoutActivitiesInput = {
    create?: XOR<SymbolProfileCreateWithoutActivitiesInput, SymbolProfileUncheckedCreateWithoutActivitiesInput>
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutActivitiesInput
    connect?: SymbolProfileWhereUniqueInput
  }

  export type TagUncheckedCreateNestedManyWithoutActivitiesInput = {
    create?: XOR<TagCreateWithoutActivitiesInput, TagUncheckedCreateWithoutActivitiesInput> | TagCreateWithoutActivitiesInput[] | TagUncheckedCreateWithoutActivitiesInput[]
    connectOrCreate?: TagCreateOrConnectWithoutActivitiesInput | TagCreateOrConnectWithoutActivitiesInput[]
    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
  }

  export type EnumTypeFieldUpdateOperationsInput = {
    set?: $Enums.Type
  }

  export type AccountUpdateOneWithoutActivitiesNestedInput = {
    create?: XOR<AccountCreateWithoutActivitiesInput, AccountUncheckedCreateWithoutActivitiesInput>
    connectOrCreate?: AccountCreateOrConnectWithoutActivitiesInput
    upsert?: AccountUpsertWithoutActivitiesInput
    disconnect?: AccountWhereInput | boolean
    delete?: AccountWhereInput | boolean
    connect?: AccountWhereUniqueInput
    update?: XOR<XOR<AccountUpdateToOneWithWhereWithoutActivitiesInput, AccountUpdateWithoutActivitiesInput>, AccountUncheckedUpdateWithoutActivitiesInput>
  }

  export type TagUpdateManyWithoutActivitiesNestedInput = {
    create?: XOR<TagCreateWithoutActivitiesInput, TagUncheckedCreateWithoutActivitiesInput> | TagCreateWithoutActivitiesInput[] | TagUncheckedCreateWithoutActivitiesInput[]
    connectOrCreate?: TagCreateOrConnectWithoutActivitiesInput | TagCreateOrConnectWithoutActivitiesInput[]
    upsert?: TagUpsertWithWhereUniqueWithoutActivitiesInput | TagUpsertWithWhereUniqueWithoutActivitiesInput[]
    set?: TagWhereUniqueInput | TagWhereUniqueInput[]
    disconnect?: TagWhereUniqueInput | TagWhereUniqueInput[]
    delete?: TagWhereUniqueInput | TagWhereUniqueInput[]
    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
    update?: TagUpdateWithWhereUniqueWithoutActivitiesInput | TagUpdateWithWhereUniqueWithoutActivitiesInput[]
    updateMany?: TagUpdateManyWithWhereWithoutActivitiesInput | TagUpdateManyWithWhereWithoutActivitiesInput[]
    deleteMany?: TagScalarWhereInput | TagScalarWhereInput[]
  }

  export type UserUpdateOneRequiredWithoutActivitiesNestedInput = {
    create?: XOR<UserCreateWithoutActivitiesInput, UserUncheckedCreateWithoutActivitiesInput>
    connectOrCreate?: UserCreateOrConnectWithoutActivitiesInput
    upsert?: UserUpsertWithoutActivitiesInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutActivitiesInput, UserUpdateWithoutActivitiesInput>, UserUncheckedUpdateWithoutActivitiesInput>
  }

  export type SymbolProfileUpdateOneRequiredWithoutActivitiesNestedInput = {
    create?: XOR<SymbolProfileCreateWithoutActivitiesInput, SymbolProfileUncheckedCreateWithoutActivitiesInput>
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutActivitiesInput
    upsert?: SymbolProfileUpsertWithoutActivitiesInput
    connect?: SymbolProfileWhereUniqueInput
    update?: XOR<XOR<SymbolProfileUpdateToOneWithWhereWithoutActivitiesInput, SymbolProfileUpdateWithoutActivitiesInput>, SymbolProfileUncheckedUpdateWithoutActivitiesInput>
  }

  export type TagUncheckedUpdateManyWithoutActivitiesNestedInput = {
    create?: XOR<TagCreateWithoutActivitiesInput, TagUncheckedCreateWithoutActivitiesInput> | TagCreateWithoutActivitiesInput[] | TagUncheckedCreateWithoutActivitiesInput[]
    connectOrCreate?: TagCreateOrConnectWithoutActivitiesInput | TagCreateOrConnectWithoutActivitiesInput[]
    upsert?: TagUpsertWithWhereUniqueWithoutActivitiesInput | TagUpsertWithWhereUniqueWithoutActivitiesInput[]
    set?: TagWhereUniqueInput | TagWhereUniqueInput[]
    disconnect?: TagWhereUniqueInput | TagWhereUniqueInput[]
    delete?: TagWhereUniqueInput | TagWhereUniqueInput[]
    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
    update?: TagUpdateWithWhereUniqueWithoutActivitiesInput | TagUpdateWithWhereUniqueWithoutActivitiesInput[]
    updateMany?: TagUpdateManyWithWhereWithoutActivitiesInput | TagUpdateManyWithWhereWithoutActivitiesInput[]
    deleteMany?: TagScalarWhereInput | TagScalarWhereInput[]
  }

  export type AccountCreateNestedManyWithoutPlatformInput = {
    create?: XOR<AccountCreateWithoutPlatformInput, AccountUncheckedCreateWithoutPlatformInput> | AccountCreateWithoutPlatformInput[] | AccountUncheckedCreateWithoutPlatformInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutPlatformInput | AccountCreateOrConnectWithoutPlatformInput[]
    createMany?: AccountCreateManyPlatformInputEnvelope
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
  }

  export type AccountUncheckedCreateNestedManyWithoutPlatformInput = {
    create?: XOR<AccountCreateWithoutPlatformInput, AccountUncheckedCreateWithoutPlatformInput> | AccountCreateWithoutPlatformInput[] | AccountUncheckedCreateWithoutPlatformInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutPlatformInput | AccountCreateOrConnectWithoutPlatformInput[]
    createMany?: AccountCreateManyPlatformInputEnvelope
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
  }

  export type AccountUpdateManyWithoutPlatformNestedInput = {
    create?: XOR<AccountCreateWithoutPlatformInput, AccountUncheckedCreateWithoutPlatformInput> | AccountCreateWithoutPlatformInput[] | AccountUncheckedCreateWithoutPlatformInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutPlatformInput | AccountCreateOrConnectWithoutPlatformInput[]
    upsert?: AccountUpsertWithWhereUniqueWithoutPlatformInput | AccountUpsertWithWhereUniqueWithoutPlatformInput[]
    createMany?: AccountCreateManyPlatformInputEnvelope
    set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    update?: AccountUpdateWithWhereUniqueWithoutPlatformInput | AccountUpdateWithWhereUniqueWithoutPlatformInput[]
    updateMany?: AccountUpdateManyWithWhereWithoutPlatformInput | AccountUpdateManyWithWhereWithoutPlatformInput[]
    deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
  }

  export type AccountUncheckedUpdateManyWithoutPlatformNestedInput = {
    create?: XOR<AccountCreateWithoutPlatformInput, AccountUncheckedCreateWithoutPlatformInput> | AccountCreateWithoutPlatformInput[] | AccountUncheckedCreateWithoutPlatformInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutPlatformInput | AccountCreateOrConnectWithoutPlatformInput[]
    upsert?: AccountUpsertWithWhereUniqueWithoutPlatformInput | AccountUpsertWithWhereUniqueWithoutPlatformInput[]
    createMany?: AccountCreateManyPlatformInputEnvelope
    set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    update?: AccountUpdateWithWhereUniqueWithoutPlatformInput | AccountUpdateWithWhereUniqueWithoutPlatformInput[]
    updateMany?: AccountUpdateManyWithWhereWithoutPlatformInput | AccountUpdateManyWithWhereWithoutPlatformInput[]
    deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutSettingsInput = {
    create?: XOR<UserCreateWithoutSettingsInput, UserUncheckedCreateWithoutSettingsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSettingsInput
    connect?: UserWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutSettingsNestedInput = {
    create?: XOR<UserCreateWithoutSettingsInput, UserUncheckedCreateWithoutSettingsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSettingsInput
    upsert?: UserUpsertWithoutSettingsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSettingsInput, UserUpdateWithoutSettingsInput>, UserUncheckedUpdateWithoutSettingsInput>
  }

  export type OrderCreateNestedManyWithoutSymbolProfileInput = {
    create?: XOR<OrderCreateWithoutSymbolProfileInput, OrderUncheckedCreateWithoutSymbolProfileInput> | OrderCreateWithoutSymbolProfileInput[] | OrderUncheckedCreateWithoutSymbolProfileInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutSymbolProfileInput | OrderCreateOrConnectWithoutSymbolProfileInput[]
    createMany?: OrderCreateManySymbolProfileInputEnvelope
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type UserCreateNestedOneWithoutSymbolProfileInput = {
    create?: XOR<UserCreateWithoutSymbolProfileInput, UserUncheckedCreateWithoutSymbolProfileInput>
    connectOrCreate?: UserCreateOrConnectWithoutSymbolProfileInput
    connect?: UserWhereUniqueInput
  }

  export type UserCreateNestedManyWithoutWatchlistInput = {
    create?: XOR<UserCreateWithoutWatchlistInput, UserUncheckedCreateWithoutWatchlistInput> | UserCreateWithoutWatchlistInput[] | UserUncheckedCreateWithoutWatchlistInput[]
    connectOrCreate?: UserCreateOrConnectWithoutWatchlistInput | UserCreateOrConnectWithoutWatchlistInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type SymbolProfileOverridesCreateNestedOneWithoutSymbolProfileInput = {
    create?: XOR<SymbolProfileOverridesCreateWithoutSymbolProfileInput, SymbolProfileOverridesUncheckedCreateWithoutSymbolProfileInput>
    connectOrCreate?: SymbolProfileOverridesCreateOrConnectWithoutSymbolProfileInput
    connect?: SymbolProfileOverridesWhereUniqueInput
  }

  export type OrderUncheckedCreateNestedManyWithoutSymbolProfileInput = {
    create?: XOR<OrderCreateWithoutSymbolProfileInput, OrderUncheckedCreateWithoutSymbolProfileInput> | OrderCreateWithoutSymbolProfileInput[] | OrderUncheckedCreateWithoutSymbolProfileInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutSymbolProfileInput | OrderCreateOrConnectWithoutSymbolProfileInput[]
    createMany?: OrderCreateManySymbolProfileInputEnvelope
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type UserUncheckedCreateNestedManyWithoutWatchlistInput = {
    create?: XOR<UserCreateWithoutWatchlistInput, UserUncheckedCreateWithoutWatchlistInput> | UserCreateWithoutWatchlistInput[] | UserUncheckedCreateWithoutWatchlistInput[]
    connectOrCreate?: UserCreateOrConnectWithoutWatchlistInput | UserCreateOrConnectWithoutWatchlistInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
  }

  export type SymbolProfileOverridesUncheckedCreateNestedOneWithoutSymbolProfileInput = {
    create?: XOR<SymbolProfileOverridesCreateWithoutSymbolProfileInput, SymbolProfileOverridesUncheckedCreateWithoutSymbolProfileInput>
    connectOrCreate?: SymbolProfileOverridesCreateOrConnectWithoutSymbolProfileInput
    connect?: SymbolProfileOverridesWhereUniqueInput
  }

  export type NullableEnumAssetClassFieldUpdateOperationsInput = {
    set?: $Enums.AssetClass | null
  }

  export type NullableEnumAssetSubClassFieldUpdateOperationsInput = {
    set?: $Enums.AssetSubClass | null
  }

  export type OrderUpdateManyWithoutSymbolProfileNestedInput = {
    create?: XOR<OrderCreateWithoutSymbolProfileInput, OrderUncheckedCreateWithoutSymbolProfileInput> | OrderCreateWithoutSymbolProfileInput[] | OrderUncheckedCreateWithoutSymbolProfileInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutSymbolProfileInput | OrderCreateOrConnectWithoutSymbolProfileInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutSymbolProfileInput | OrderUpsertWithWhereUniqueWithoutSymbolProfileInput[]
    createMany?: OrderCreateManySymbolProfileInputEnvelope
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutSymbolProfileInput | OrderUpdateWithWhereUniqueWithoutSymbolProfileInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutSymbolProfileInput | OrderUpdateManyWithWhereWithoutSymbolProfileInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type UserUpdateOneWithoutSymbolProfileNestedInput = {
    create?: XOR<UserCreateWithoutSymbolProfileInput, UserUncheckedCreateWithoutSymbolProfileInput>
    connectOrCreate?: UserCreateOrConnectWithoutSymbolProfileInput
    upsert?: UserUpsertWithoutSymbolProfileInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSymbolProfileInput, UserUpdateWithoutSymbolProfileInput>, UserUncheckedUpdateWithoutSymbolProfileInput>
  }

  export type UserUpdateManyWithoutWatchlistNestedInput = {
    create?: XOR<UserCreateWithoutWatchlistInput, UserUncheckedCreateWithoutWatchlistInput> | UserCreateWithoutWatchlistInput[] | UserUncheckedCreateWithoutWatchlistInput[]
    connectOrCreate?: UserCreateOrConnectWithoutWatchlistInput | UserCreateOrConnectWithoutWatchlistInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutWatchlistInput | UserUpsertWithWhereUniqueWithoutWatchlistInput[]
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutWatchlistInput | UserUpdateWithWhereUniqueWithoutWatchlistInput[]
    updateMany?: UserUpdateManyWithWhereWithoutWatchlistInput | UserUpdateManyWithWhereWithoutWatchlistInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type SymbolProfileOverridesUpdateOneWithoutSymbolProfileNestedInput = {
    create?: XOR<SymbolProfileOverridesCreateWithoutSymbolProfileInput, SymbolProfileOverridesUncheckedCreateWithoutSymbolProfileInput>
    connectOrCreate?: SymbolProfileOverridesCreateOrConnectWithoutSymbolProfileInput
    upsert?: SymbolProfileOverridesUpsertWithoutSymbolProfileInput
    disconnect?: SymbolProfileOverridesWhereInput | boolean
    delete?: SymbolProfileOverridesWhereInput | boolean
    connect?: SymbolProfileOverridesWhereUniqueInput
    update?: XOR<XOR<SymbolProfileOverridesUpdateToOneWithWhereWithoutSymbolProfileInput, SymbolProfileOverridesUpdateWithoutSymbolProfileInput>, SymbolProfileOverridesUncheckedUpdateWithoutSymbolProfileInput>
  }

  export type OrderUncheckedUpdateManyWithoutSymbolProfileNestedInput = {
    create?: XOR<OrderCreateWithoutSymbolProfileInput, OrderUncheckedCreateWithoutSymbolProfileInput> | OrderCreateWithoutSymbolProfileInput[] | OrderUncheckedCreateWithoutSymbolProfileInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutSymbolProfileInput | OrderCreateOrConnectWithoutSymbolProfileInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutSymbolProfileInput | OrderUpsertWithWhereUniqueWithoutSymbolProfileInput[]
    createMany?: OrderCreateManySymbolProfileInputEnvelope
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutSymbolProfileInput | OrderUpdateWithWhereUniqueWithoutSymbolProfileInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutSymbolProfileInput | OrderUpdateManyWithWhereWithoutSymbolProfileInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type UserUncheckedUpdateManyWithoutWatchlistNestedInput = {
    create?: XOR<UserCreateWithoutWatchlistInput, UserUncheckedCreateWithoutWatchlistInput> | UserCreateWithoutWatchlistInput[] | UserUncheckedCreateWithoutWatchlistInput[]
    connectOrCreate?: UserCreateOrConnectWithoutWatchlistInput | UserCreateOrConnectWithoutWatchlistInput[]
    upsert?: UserUpsertWithWhereUniqueWithoutWatchlistInput | UserUpsertWithWhereUniqueWithoutWatchlistInput[]
    set?: UserWhereUniqueInput | UserWhereUniqueInput[]
    disconnect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    delete?: UserWhereUniqueInput | UserWhereUniqueInput[]
    connect?: UserWhereUniqueInput | UserWhereUniqueInput[]
    update?: UserUpdateWithWhereUniqueWithoutWatchlistInput | UserUpdateWithWhereUniqueWithoutWatchlistInput[]
    updateMany?: UserUpdateManyWithWhereWithoutWatchlistInput | UserUpdateManyWithWhereWithoutWatchlistInput[]
    deleteMany?: UserScalarWhereInput | UserScalarWhereInput[]
  }

  export type SymbolProfileOverridesUncheckedUpdateOneWithoutSymbolProfileNestedInput = {
    create?: XOR<SymbolProfileOverridesCreateWithoutSymbolProfileInput, SymbolProfileOverridesUncheckedCreateWithoutSymbolProfileInput>
    connectOrCreate?: SymbolProfileOverridesCreateOrConnectWithoutSymbolProfileInput
    upsert?: SymbolProfileOverridesUpsertWithoutSymbolProfileInput
    disconnect?: SymbolProfileOverridesWhereInput | boolean
    delete?: SymbolProfileOverridesWhereInput | boolean
    connect?: SymbolProfileOverridesWhereUniqueInput
    update?: XOR<XOR<SymbolProfileOverridesUpdateToOneWithWhereWithoutSymbolProfileInput, SymbolProfileOverridesUpdateWithoutSymbolProfileInput>, SymbolProfileOverridesUncheckedUpdateWithoutSymbolProfileInput>
  }

  export type SymbolProfileCreateNestedOneWithoutSymbolProfileOverridesInput = {
    create?: XOR<SymbolProfileCreateWithoutSymbolProfileOverridesInput, SymbolProfileUncheckedCreateWithoutSymbolProfileOverridesInput>
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutSymbolProfileOverridesInput
    connect?: SymbolProfileWhereUniqueInput
  }

  export type SymbolProfileUpdateOneRequiredWithoutSymbolProfileOverridesNestedInput = {
    create?: XOR<SymbolProfileCreateWithoutSymbolProfileOverridesInput, SymbolProfileUncheckedCreateWithoutSymbolProfileOverridesInput>
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutSymbolProfileOverridesInput
    upsert?: SymbolProfileUpsertWithoutSymbolProfileOverridesInput
    connect?: SymbolProfileWhereUniqueInput
    update?: XOR<XOR<SymbolProfileUpdateToOneWithWhereWithoutSymbolProfileOverridesInput, SymbolProfileUpdateWithoutSymbolProfileOverridesInput>, SymbolProfileUncheckedUpdateWithoutSymbolProfileOverridesInput>
  }

  export type UserCreateNestedOneWithoutSubscriptionsInput = {
    create?: XOR<UserCreateWithoutSubscriptionsInput, UserUncheckedCreateWithoutSubscriptionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSubscriptionsInput
    connect?: UserWhereUniqueInput
  }

  export type NullableFloatFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type UserUpdateOneRequiredWithoutSubscriptionsNestedInput = {
    create?: XOR<UserCreateWithoutSubscriptionsInput, UserUncheckedCreateWithoutSubscriptionsInput>
    connectOrCreate?: UserCreateOrConnectWithoutSubscriptionsInput
    upsert?: UserUpsertWithoutSubscriptionsInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutSubscriptionsInput, UserUpdateWithoutSubscriptionsInput>, UserUncheckedUpdateWithoutSubscriptionsInput>
  }

  export type OrderCreateNestedManyWithoutTagsInput = {
    create?: XOR<OrderCreateWithoutTagsInput, OrderUncheckedCreateWithoutTagsInput> | OrderCreateWithoutTagsInput[] | OrderUncheckedCreateWithoutTagsInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutTagsInput | OrderCreateOrConnectWithoutTagsInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type UserCreateNestedOneWithoutTagsInput = {
    create?: XOR<UserCreateWithoutTagsInput, UserUncheckedCreateWithoutTagsInput>
    connectOrCreate?: UserCreateOrConnectWithoutTagsInput
    connect?: UserWhereUniqueInput
  }

  export type OrderUncheckedCreateNestedManyWithoutTagsInput = {
    create?: XOR<OrderCreateWithoutTagsInput, OrderUncheckedCreateWithoutTagsInput> | OrderCreateWithoutTagsInput[] | OrderUncheckedCreateWithoutTagsInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutTagsInput | OrderCreateOrConnectWithoutTagsInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type OrderUpdateManyWithoutTagsNestedInput = {
    create?: XOR<OrderCreateWithoutTagsInput, OrderUncheckedCreateWithoutTagsInput> | OrderCreateWithoutTagsInput[] | OrderUncheckedCreateWithoutTagsInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutTagsInput | OrderCreateOrConnectWithoutTagsInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutTagsInput | OrderUpsertWithWhereUniqueWithoutTagsInput[]
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutTagsInput | OrderUpdateWithWhereUniqueWithoutTagsInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutTagsInput | OrderUpdateManyWithWhereWithoutTagsInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type UserUpdateOneWithoutTagsNestedInput = {
    create?: XOR<UserCreateWithoutTagsInput, UserUncheckedCreateWithoutTagsInput>
    connectOrCreate?: UserCreateOrConnectWithoutTagsInput
    upsert?: UserUpsertWithoutTagsInput
    disconnect?: UserWhereInput | boolean
    delete?: UserWhereInput | boolean
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutTagsInput, UserUpdateWithoutTagsInput>, UserUncheckedUpdateWithoutTagsInput>
  }

  export type OrderUncheckedUpdateManyWithoutTagsNestedInput = {
    create?: XOR<OrderCreateWithoutTagsInput, OrderUncheckedCreateWithoutTagsInput> | OrderCreateWithoutTagsInput[] | OrderUncheckedCreateWithoutTagsInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutTagsInput | OrderCreateOrConnectWithoutTagsInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutTagsInput | OrderUpsertWithWhereUniqueWithoutTagsInput[]
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutTagsInput | OrderUpdateWithWhereUniqueWithoutTagsInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutTagsInput | OrderUpdateManyWithWhereWithoutTagsInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type AccessCreateNestedManyWithoutGranteeUserInput = {
    create?: XOR<AccessCreateWithoutGranteeUserInput, AccessUncheckedCreateWithoutGranteeUserInput> | AccessCreateWithoutGranteeUserInput[] | AccessUncheckedCreateWithoutGranteeUserInput[]
    connectOrCreate?: AccessCreateOrConnectWithoutGranteeUserInput | AccessCreateOrConnectWithoutGranteeUserInput[]
    createMany?: AccessCreateManyGranteeUserInputEnvelope
    connect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
  }

  export type AccessCreateNestedManyWithoutUserInput = {
    create?: XOR<AccessCreateWithoutUserInput, AccessUncheckedCreateWithoutUserInput> | AccessCreateWithoutUserInput[] | AccessUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccessCreateOrConnectWithoutUserInput | AccessCreateOrConnectWithoutUserInput[]
    createMany?: AccessCreateManyUserInputEnvelope
    connect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
  }

  export type AccountCreateNestedManyWithoutUserInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
  }

  export type OrderCreateNestedManyWithoutUserInput = {
    create?: XOR<OrderCreateWithoutUserInput, OrderUncheckedCreateWithoutUserInput> | OrderCreateWithoutUserInput[] | OrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutUserInput | OrderCreateOrConnectWithoutUserInput[]
    createMany?: OrderCreateManyUserInputEnvelope
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type AnalyticsCreateNestedOneWithoutUserInput = {
    create?: XOR<AnalyticsCreateWithoutUserInput, AnalyticsUncheckedCreateWithoutUserInput>
    connectOrCreate?: AnalyticsCreateOrConnectWithoutUserInput
    connect?: AnalyticsWhereUniqueInput
  }

  export type ApiKeyCreateNestedManyWithoutUserInput = {
    create?: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput> | ApiKeyCreateWithoutUserInput[] | ApiKeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutUserInput | ApiKeyCreateOrConnectWithoutUserInput[]
    createMany?: ApiKeyCreateManyUserInputEnvelope
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
  }

  export type AuthDeviceCreateNestedManyWithoutUserInput = {
    create?: XOR<AuthDeviceCreateWithoutUserInput, AuthDeviceUncheckedCreateWithoutUserInput> | AuthDeviceCreateWithoutUserInput[] | AuthDeviceUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AuthDeviceCreateOrConnectWithoutUserInput | AuthDeviceCreateOrConnectWithoutUserInput[]
    createMany?: AuthDeviceCreateManyUserInputEnvelope
    connect?: AuthDeviceWhereUniqueInput | AuthDeviceWhereUniqueInput[]
  }

  export type SettingsCreateNestedOneWithoutUserInput = {
    create?: XOR<SettingsCreateWithoutUserInput, SettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: SettingsCreateOrConnectWithoutUserInput
    connect?: SettingsWhereUniqueInput
  }

  export type SubscriptionCreateNestedManyWithoutUserInput = {
    create?: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput> | SubscriptionCreateWithoutUserInput[] | SubscriptionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutUserInput | SubscriptionCreateOrConnectWithoutUserInput[]
    createMany?: SubscriptionCreateManyUserInputEnvelope
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
  }

  export type TagCreateNestedManyWithoutUserInput = {
    create?: XOR<TagCreateWithoutUserInput, TagUncheckedCreateWithoutUserInput> | TagCreateWithoutUserInput[] | TagUncheckedCreateWithoutUserInput[]
    connectOrCreate?: TagCreateOrConnectWithoutUserInput | TagCreateOrConnectWithoutUserInput[]
    createMany?: TagCreateManyUserInputEnvelope
    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
  }

  export type SymbolProfileCreateNestedManyWithoutWatchedByInput = {
    create?: XOR<SymbolProfileCreateWithoutWatchedByInput, SymbolProfileUncheckedCreateWithoutWatchedByInput> | SymbolProfileCreateWithoutWatchedByInput[] | SymbolProfileUncheckedCreateWithoutWatchedByInput[]
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutWatchedByInput | SymbolProfileCreateOrConnectWithoutWatchedByInput[]
    connect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
  }

  export type SymbolProfileCreateNestedManyWithoutUserInput = {
    create?: XOR<SymbolProfileCreateWithoutUserInput, SymbolProfileUncheckedCreateWithoutUserInput> | SymbolProfileCreateWithoutUserInput[] | SymbolProfileUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutUserInput | SymbolProfileCreateOrConnectWithoutUserInput[]
    createMany?: SymbolProfileCreateManyUserInputEnvelope
    connect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
  }

  export type AccessUncheckedCreateNestedManyWithoutGranteeUserInput = {
    create?: XOR<AccessCreateWithoutGranteeUserInput, AccessUncheckedCreateWithoutGranteeUserInput> | AccessCreateWithoutGranteeUserInput[] | AccessUncheckedCreateWithoutGranteeUserInput[]
    connectOrCreate?: AccessCreateOrConnectWithoutGranteeUserInput | AccessCreateOrConnectWithoutGranteeUserInput[]
    createMany?: AccessCreateManyGranteeUserInputEnvelope
    connect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
  }

  export type AccessUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AccessCreateWithoutUserInput, AccessUncheckedCreateWithoutUserInput> | AccessCreateWithoutUserInput[] | AccessUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccessCreateOrConnectWithoutUserInput | AccessCreateOrConnectWithoutUserInput[]
    createMany?: AccessCreateManyUserInputEnvelope
    connect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
  }

  export type AccountUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
  }

  export type OrderUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<OrderCreateWithoutUserInput, OrderUncheckedCreateWithoutUserInput> | OrderCreateWithoutUserInput[] | OrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutUserInput | OrderCreateOrConnectWithoutUserInput[]
    createMany?: OrderCreateManyUserInputEnvelope
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type AnalyticsUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<AnalyticsCreateWithoutUserInput, AnalyticsUncheckedCreateWithoutUserInput>
    connectOrCreate?: AnalyticsCreateOrConnectWithoutUserInput
    connect?: AnalyticsWhereUniqueInput
  }

  export type ApiKeyUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput> | ApiKeyCreateWithoutUserInput[] | ApiKeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutUserInput | ApiKeyCreateOrConnectWithoutUserInput[]
    createMany?: ApiKeyCreateManyUserInputEnvelope
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
  }

  export type AuthDeviceUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<AuthDeviceCreateWithoutUserInput, AuthDeviceUncheckedCreateWithoutUserInput> | AuthDeviceCreateWithoutUserInput[] | AuthDeviceUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AuthDeviceCreateOrConnectWithoutUserInput | AuthDeviceCreateOrConnectWithoutUserInput[]
    createMany?: AuthDeviceCreateManyUserInputEnvelope
    connect?: AuthDeviceWhereUniqueInput | AuthDeviceWhereUniqueInput[]
  }

  export type SettingsUncheckedCreateNestedOneWithoutUserInput = {
    create?: XOR<SettingsCreateWithoutUserInput, SettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: SettingsCreateOrConnectWithoutUserInput
    connect?: SettingsWhereUniqueInput
  }

  export type SubscriptionUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput> | SubscriptionCreateWithoutUserInput[] | SubscriptionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutUserInput | SubscriptionCreateOrConnectWithoutUserInput[]
    createMany?: SubscriptionCreateManyUserInputEnvelope
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
  }

  export type TagUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<TagCreateWithoutUserInput, TagUncheckedCreateWithoutUserInput> | TagCreateWithoutUserInput[] | TagUncheckedCreateWithoutUserInput[]
    connectOrCreate?: TagCreateOrConnectWithoutUserInput | TagCreateOrConnectWithoutUserInput[]
    createMany?: TagCreateManyUserInputEnvelope
    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
  }

  export type SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput = {
    create?: XOR<SymbolProfileCreateWithoutWatchedByInput, SymbolProfileUncheckedCreateWithoutWatchedByInput> | SymbolProfileCreateWithoutWatchedByInput[] | SymbolProfileUncheckedCreateWithoutWatchedByInput[]
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutWatchedByInput | SymbolProfileCreateOrConnectWithoutWatchedByInput[]
    connect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
  }

  export type SymbolProfileUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<SymbolProfileCreateWithoutUserInput, SymbolProfileUncheckedCreateWithoutUserInput> | SymbolProfileCreateWithoutUserInput[] | SymbolProfileUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutUserInput | SymbolProfileCreateOrConnectWithoutUserInput[]
    createMany?: SymbolProfileCreateManyUserInputEnvelope
    connect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
  }

  export type EnumProviderFieldUpdateOperationsInput = {
    set?: $Enums.Provider
  }

  export type EnumRoleFieldUpdateOperationsInput = {
    set?: $Enums.Role
  }

  export type AccessUpdateManyWithoutGranteeUserNestedInput = {
    create?: XOR<AccessCreateWithoutGranteeUserInput, AccessUncheckedCreateWithoutGranteeUserInput> | AccessCreateWithoutGranteeUserInput[] | AccessUncheckedCreateWithoutGranteeUserInput[]
    connectOrCreate?: AccessCreateOrConnectWithoutGranteeUserInput | AccessCreateOrConnectWithoutGranteeUserInput[]
    upsert?: AccessUpsertWithWhereUniqueWithoutGranteeUserInput | AccessUpsertWithWhereUniqueWithoutGranteeUserInput[]
    createMany?: AccessCreateManyGranteeUserInputEnvelope
    set?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    disconnect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    delete?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    connect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    update?: AccessUpdateWithWhereUniqueWithoutGranteeUserInput | AccessUpdateWithWhereUniqueWithoutGranteeUserInput[]
    updateMany?: AccessUpdateManyWithWhereWithoutGranteeUserInput | AccessUpdateManyWithWhereWithoutGranteeUserInput[]
    deleteMany?: AccessScalarWhereInput | AccessScalarWhereInput[]
  }

  export type AccessUpdateManyWithoutUserNestedInput = {
    create?: XOR<AccessCreateWithoutUserInput, AccessUncheckedCreateWithoutUserInput> | AccessCreateWithoutUserInput[] | AccessUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccessCreateOrConnectWithoutUserInput | AccessCreateOrConnectWithoutUserInput[]
    upsert?: AccessUpsertWithWhereUniqueWithoutUserInput | AccessUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AccessCreateManyUserInputEnvelope
    set?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    disconnect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    delete?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    connect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    update?: AccessUpdateWithWhereUniqueWithoutUserInput | AccessUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AccessUpdateManyWithWhereWithoutUserInput | AccessUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AccessScalarWhereInput | AccessScalarWhereInput[]
  }

  export type AccountUpdateManyWithoutUserNestedInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    upsert?: AccountUpsertWithWhereUniqueWithoutUserInput | AccountUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    update?: AccountUpdateWithWhereUniqueWithoutUserInput | AccountUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AccountUpdateManyWithWhereWithoutUserInput | AccountUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
  }

  export type OrderUpdateManyWithoutUserNestedInput = {
    create?: XOR<OrderCreateWithoutUserInput, OrderUncheckedCreateWithoutUserInput> | OrderCreateWithoutUserInput[] | OrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutUserInput | OrderCreateOrConnectWithoutUserInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutUserInput | OrderUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: OrderCreateManyUserInputEnvelope
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutUserInput | OrderUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutUserInput | OrderUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type AnalyticsUpdateOneWithoutUserNestedInput = {
    create?: XOR<AnalyticsCreateWithoutUserInput, AnalyticsUncheckedCreateWithoutUserInput>
    connectOrCreate?: AnalyticsCreateOrConnectWithoutUserInput
    upsert?: AnalyticsUpsertWithoutUserInput
    disconnect?: AnalyticsWhereInput | boolean
    delete?: AnalyticsWhereInput | boolean
    connect?: AnalyticsWhereUniqueInput
    update?: XOR<XOR<AnalyticsUpdateToOneWithWhereWithoutUserInput, AnalyticsUpdateWithoutUserInput>, AnalyticsUncheckedUpdateWithoutUserInput>
  }

  export type ApiKeyUpdateManyWithoutUserNestedInput = {
    create?: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput> | ApiKeyCreateWithoutUserInput[] | ApiKeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutUserInput | ApiKeyCreateOrConnectWithoutUserInput[]
    upsert?: ApiKeyUpsertWithWhereUniqueWithoutUserInput | ApiKeyUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ApiKeyCreateManyUserInputEnvelope
    set?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    disconnect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    delete?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    update?: ApiKeyUpdateWithWhereUniqueWithoutUserInput | ApiKeyUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ApiKeyUpdateManyWithWhereWithoutUserInput | ApiKeyUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ApiKeyScalarWhereInput | ApiKeyScalarWhereInput[]
  }

  export type AuthDeviceUpdateManyWithoutUserNestedInput = {
    create?: XOR<AuthDeviceCreateWithoutUserInput, AuthDeviceUncheckedCreateWithoutUserInput> | AuthDeviceCreateWithoutUserInput[] | AuthDeviceUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AuthDeviceCreateOrConnectWithoutUserInput | AuthDeviceCreateOrConnectWithoutUserInput[]
    upsert?: AuthDeviceUpsertWithWhereUniqueWithoutUserInput | AuthDeviceUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AuthDeviceCreateManyUserInputEnvelope
    set?: AuthDeviceWhereUniqueInput | AuthDeviceWhereUniqueInput[]
    disconnect?: AuthDeviceWhereUniqueInput | AuthDeviceWhereUniqueInput[]
    delete?: AuthDeviceWhereUniqueInput | AuthDeviceWhereUniqueInput[]
    connect?: AuthDeviceWhereUniqueInput | AuthDeviceWhereUniqueInput[]
    update?: AuthDeviceUpdateWithWhereUniqueWithoutUserInput | AuthDeviceUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AuthDeviceUpdateManyWithWhereWithoutUserInput | AuthDeviceUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AuthDeviceScalarWhereInput | AuthDeviceScalarWhereInput[]
  }

  export type SettingsUpdateOneWithoutUserNestedInput = {
    create?: XOR<SettingsCreateWithoutUserInput, SettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: SettingsCreateOrConnectWithoutUserInput
    upsert?: SettingsUpsertWithoutUserInput
    disconnect?: SettingsWhereInput | boolean
    delete?: SettingsWhereInput | boolean
    connect?: SettingsWhereUniqueInput
    update?: XOR<XOR<SettingsUpdateToOneWithWhereWithoutUserInput, SettingsUpdateWithoutUserInput>, SettingsUncheckedUpdateWithoutUserInput>
  }

  export type SubscriptionUpdateManyWithoutUserNestedInput = {
    create?: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput> | SubscriptionCreateWithoutUserInput[] | SubscriptionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutUserInput | SubscriptionCreateOrConnectWithoutUserInput[]
    upsert?: SubscriptionUpsertWithWhereUniqueWithoutUserInput | SubscriptionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SubscriptionCreateManyUserInputEnvelope
    set?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    disconnect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    delete?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    update?: SubscriptionUpdateWithWhereUniqueWithoutUserInput | SubscriptionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SubscriptionUpdateManyWithWhereWithoutUserInput | SubscriptionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SubscriptionScalarWhereInput | SubscriptionScalarWhereInput[]
  }

  export type TagUpdateManyWithoutUserNestedInput = {
    create?: XOR<TagCreateWithoutUserInput, TagUncheckedCreateWithoutUserInput> | TagCreateWithoutUserInput[] | TagUncheckedCreateWithoutUserInput[]
    connectOrCreate?: TagCreateOrConnectWithoutUserInput | TagCreateOrConnectWithoutUserInput[]
    upsert?: TagUpsertWithWhereUniqueWithoutUserInput | TagUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: TagCreateManyUserInputEnvelope
    set?: TagWhereUniqueInput | TagWhereUniqueInput[]
    disconnect?: TagWhereUniqueInput | TagWhereUniqueInput[]
    delete?: TagWhereUniqueInput | TagWhereUniqueInput[]
    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
    update?: TagUpdateWithWhereUniqueWithoutUserInput | TagUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: TagUpdateManyWithWhereWithoutUserInput | TagUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: TagScalarWhereInput | TagScalarWhereInput[]
  }

  export type SymbolProfileUpdateManyWithoutWatchedByNestedInput = {
    create?: XOR<SymbolProfileCreateWithoutWatchedByInput, SymbolProfileUncheckedCreateWithoutWatchedByInput> | SymbolProfileCreateWithoutWatchedByInput[] | SymbolProfileUncheckedCreateWithoutWatchedByInput[]
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutWatchedByInput | SymbolProfileCreateOrConnectWithoutWatchedByInput[]
    upsert?: SymbolProfileUpsertWithWhereUniqueWithoutWatchedByInput | SymbolProfileUpsertWithWhereUniqueWithoutWatchedByInput[]
    set?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    disconnect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    delete?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    connect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    update?: SymbolProfileUpdateWithWhereUniqueWithoutWatchedByInput | SymbolProfileUpdateWithWhereUniqueWithoutWatchedByInput[]
    updateMany?: SymbolProfileUpdateManyWithWhereWithoutWatchedByInput | SymbolProfileUpdateManyWithWhereWithoutWatchedByInput[]
    deleteMany?: SymbolProfileScalarWhereInput | SymbolProfileScalarWhereInput[]
  }

  export type SymbolProfileUpdateManyWithoutUserNestedInput = {
    create?: XOR<SymbolProfileCreateWithoutUserInput, SymbolProfileUncheckedCreateWithoutUserInput> | SymbolProfileCreateWithoutUserInput[] | SymbolProfileUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutUserInput | SymbolProfileCreateOrConnectWithoutUserInput[]
    upsert?: SymbolProfileUpsertWithWhereUniqueWithoutUserInput | SymbolProfileUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SymbolProfileCreateManyUserInputEnvelope
    set?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    disconnect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    delete?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    connect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    update?: SymbolProfileUpdateWithWhereUniqueWithoutUserInput | SymbolProfileUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SymbolProfileUpdateManyWithWhereWithoutUserInput | SymbolProfileUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SymbolProfileScalarWhereInput | SymbolProfileScalarWhereInput[]
  }

  export type AccessUncheckedUpdateManyWithoutGranteeUserNestedInput = {
    create?: XOR<AccessCreateWithoutGranteeUserInput, AccessUncheckedCreateWithoutGranteeUserInput> | AccessCreateWithoutGranteeUserInput[] | AccessUncheckedCreateWithoutGranteeUserInput[]
    connectOrCreate?: AccessCreateOrConnectWithoutGranteeUserInput | AccessCreateOrConnectWithoutGranteeUserInput[]
    upsert?: AccessUpsertWithWhereUniqueWithoutGranteeUserInput | AccessUpsertWithWhereUniqueWithoutGranteeUserInput[]
    createMany?: AccessCreateManyGranteeUserInputEnvelope
    set?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    disconnect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    delete?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    connect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    update?: AccessUpdateWithWhereUniqueWithoutGranteeUserInput | AccessUpdateWithWhereUniqueWithoutGranteeUserInput[]
    updateMany?: AccessUpdateManyWithWhereWithoutGranteeUserInput | AccessUpdateManyWithWhereWithoutGranteeUserInput[]
    deleteMany?: AccessScalarWhereInput | AccessScalarWhereInput[]
  }

  export type AccessUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AccessCreateWithoutUserInput, AccessUncheckedCreateWithoutUserInput> | AccessCreateWithoutUserInput[] | AccessUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccessCreateOrConnectWithoutUserInput | AccessCreateOrConnectWithoutUserInput[]
    upsert?: AccessUpsertWithWhereUniqueWithoutUserInput | AccessUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AccessCreateManyUserInputEnvelope
    set?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    disconnect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    delete?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    connect?: AccessWhereUniqueInput | AccessWhereUniqueInput[]
    update?: AccessUpdateWithWhereUniqueWithoutUserInput | AccessUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AccessUpdateManyWithWhereWithoutUserInput | AccessUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AccessScalarWhereInput | AccessScalarWhereInput[]
  }

  export type AccountUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput> | AccountCreateWithoutUserInput[] | AccountUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AccountCreateOrConnectWithoutUserInput | AccountCreateOrConnectWithoutUserInput[]
    upsert?: AccountUpsertWithWhereUniqueWithoutUserInput | AccountUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AccountCreateManyUserInputEnvelope
    set?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    disconnect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    delete?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    connect?: AccountWhereUniqueInput | AccountWhereUniqueInput[]
    update?: AccountUpdateWithWhereUniqueWithoutUserInput | AccountUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AccountUpdateManyWithWhereWithoutUserInput | AccountUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AccountScalarWhereInput | AccountScalarWhereInput[]
  }

  export type OrderUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<OrderCreateWithoutUserInput, OrderUncheckedCreateWithoutUserInput> | OrderCreateWithoutUserInput[] | OrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutUserInput | OrderCreateOrConnectWithoutUserInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutUserInput | OrderUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: OrderCreateManyUserInputEnvelope
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutUserInput | OrderUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutUserInput | OrderUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type AnalyticsUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<AnalyticsCreateWithoutUserInput, AnalyticsUncheckedCreateWithoutUserInput>
    connectOrCreate?: AnalyticsCreateOrConnectWithoutUserInput
    upsert?: AnalyticsUpsertWithoutUserInput
    disconnect?: AnalyticsWhereInput | boolean
    delete?: AnalyticsWhereInput | boolean
    connect?: AnalyticsWhereUniqueInput
    update?: XOR<XOR<AnalyticsUpdateToOneWithWhereWithoutUserInput, AnalyticsUpdateWithoutUserInput>, AnalyticsUncheckedUpdateWithoutUserInput>
  }

  export type ApiKeyUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput> | ApiKeyCreateWithoutUserInput[] | ApiKeyUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ApiKeyCreateOrConnectWithoutUserInput | ApiKeyCreateOrConnectWithoutUserInput[]
    upsert?: ApiKeyUpsertWithWhereUniqueWithoutUserInput | ApiKeyUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ApiKeyCreateManyUserInputEnvelope
    set?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    disconnect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    delete?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    connect?: ApiKeyWhereUniqueInput | ApiKeyWhereUniqueInput[]
    update?: ApiKeyUpdateWithWhereUniqueWithoutUserInput | ApiKeyUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ApiKeyUpdateManyWithWhereWithoutUserInput | ApiKeyUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ApiKeyScalarWhereInput | ApiKeyScalarWhereInput[]
  }

  export type AuthDeviceUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<AuthDeviceCreateWithoutUserInput, AuthDeviceUncheckedCreateWithoutUserInput> | AuthDeviceCreateWithoutUserInput[] | AuthDeviceUncheckedCreateWithoutUserInput[]
    connectOrCreate?: AuthDeviceCreateOrConnectWithoutUserInput | AuthDeviceCreateOrConnectWithoutUserInput[]
    upsert?: AuthDeviceUpsertWithWhereUniqueWithoutUserInput | AuthDeviceUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: AuthDeviceCreateManyUserInputEnvelope
    set?: AuthDeviceWhereUniqueInput | AuthDeviceWhereUniqueInput[]
    disconnect?: AuthDeviceWhereUniqueInput | AuthDeviceWhereUniqueInput[]
    delete?: AuthDeviceWhereUniqueInput | AuthDeviceWhereUniqueInput[]
    connect?: AuthDeviceWhereUniqueInput | AuthDeviceWhereUniqueInput[]
    update?: AuthDeviceUpdateWithWhereUniqueWithoutUserInput | AuthDeviceUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: AuthDeviceUpdateManyWithWhereWithoutUserInput | AuthDeviceUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: AuthDeviceScalarWhereInput | AuthDeviceScalarWhereInput[]
  }

  export type SettingsUncheckedUpdateOneWithoutUserNestedInput = {
    create?: XOR<SettingsCreateWithoutUserInput, SettingsUncheckedCreateWithoutUserInput>
    connectOrCreate?: SettingsCreateOrConnectWithoutUserInput
    upsert?: SettingsUpsertWithoutUserInput
    disconnect?: SettingsWhereInput | boolean
    delete?: SettingsWhereInput | boolean
    connect?: SettingsWhereUniqueInput
    update?: XOR<XOR<SettingsUpdateToOneWithWhereWithoutUserInput, SettingsUpdateWithoutUserInput>, SettingsUncheckedUpdateWithoutUserInput>
  }

  export type SubscriptionUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput> | SubscriptionCreateWithoutUserInput[] | SubscriptionUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SubscriptionCreateOrConnectWithoutUserInput | SubscriptionCreateOrConnectWithoutUserInput[]
    upsert?: SubscriptionUpsertWithWhereUniqueWithoutUserInput | SubscriptionUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SubscriptionCreateManyUserInputEnvelope
    set?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    disconnect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    delete?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    connect?: SubscriptionWhereUniqueInput | SubscriptionWhereUniqueInput[]
    update?: SubscriptionUpdateWithWhereUniqueWithoutUserInput | SubscriptionUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SubscriptionUpdateManyWithWhereWithoutUserInput | SubscriptionUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SubscriptionScalarWhereInput | SubscriptionScalarWhereInput[]
  }

  export type TagUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<TagCreateWithoutUserInput, TagUncheckedCreateWithoutUserInput> | TagCreateWithoutUserInput[] | TagUncheckedCreateWithoutUserInput[]
    connectOrCreate?: TagCreateOrConnectWithoutUserInput | TagCreateOrConnectWithoutUserInput[]
    upsert?: TagUpsertWithWhereUniqueWithoutUserInput | TagUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: TagCreateManyUserInputEnvelope
    set?: TagWhereUniqueInput | TagWhereUniqueInput[]
    disconnect?: TagWhereUniqueInput | TagWhereUniqueInput[]
    delete?: TagWhereUniqueInput | TagWhereUniqueInput[]
    connect?: TagWhereUniqueInput | TagWhereUniqueInput[]
    update?: TagUpdateWithWhereUniqueWithoutUserInput | TagUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: TagUpdateManyWithWhereWithoutUserInput | TagUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: TagScalarWhereInput | TagScalarWhereInput[]
  }

  export type SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput = {
    create?: XOR<SymbolProfileCreateWithoutWatchedByInput, SymbolProfileUncheckedCreateWithoutWatchedByInput> | SymbolProfileCreateWithoutWatchedByInput[] | SymbolProfileUncheckedCreateWithoutWatchedByInput[]
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutWatchedByInput | SymbolProfileCreateOrConnectWithoutWatchedByInput[]
    upsert?: SymbolProfileUpsertWithWhereUniqueWithoutWatchedByInput | SymbolProfileUpsertWithWhereUniqueWithoutWatchedByInput[]
    set?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    disconnect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    delete?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    connect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    update?: SymbolProfileUpdateWithWhereUniqueWithoutWatchedByInput | SymbolProfileUpdateWithWhereUniqueWithoutWatchedByInput[]
    updateMany?: SymbolProfileUpdateManyWithWhereWithoutWatchedByInput | SymbolProfileUpdateManyWithWhereWithoutWatchedByInput[]
    deleteMany?: SymbolProfileScalarWhereInput | SymbolProfileScalarWhereInput[]
  }

  export type SymbolProfileUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<SymbolProfileCreateWithoutUserInput, SymbolProfileUncheckedCreateWithoutUserInput> | SymbolProfileCreateWithoutUserInput[] | SymbolProfileUncheckedCreateWithoutUserInput[]
    connectOrCreate?: SymbolProfileCreateOrConnectWithoutUserInput | SymbolProfileCreateOrConnectWithoutUserInput[]
    upsert?: SymbolProfileUpsertWithWhereUniqueWithoutUserInput | SymbolProfileUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: SymbolProfileCreateManyUserInputEnvelope
    set?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    disconnect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    delete?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    connect?: SymbolProfileWhereUniqueInput | SymbolProfileWhereUniqueInput[]
    update?: SymbolProfileUpdateWithWhereUniqueWithoutUserInput | SymbolProfileUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: SymbolProfileUpdateManyWithWhereWithoutUserInput | SymbolProfileUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: SymbolProfileScalarWhereInput | SymbolProfileScalarWhereInput[]
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | 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 NestedDateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    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 NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | 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[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type NestedIntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    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 NestedJsonFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<NestedJsonFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>,
        Required<NestedJsonFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>

  export type NestedJsonFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type NestedFloatFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }

  export type NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type NestedFloatWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedFloatFilter<$PrismaModel>
    _min?: NestedFloatFilter<$PrismaModel>
    _max?: NestedFloatFilter<$PrismaModel>
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    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 NestedEnumDataSourceFilter<$PrismaModel = never> = {
    equals?: $Enums.DataSource | EnumDataSourceFieldRefInput<$PrismaModel>
    in?: $Enums.DataSource[] | ListEnumDataSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.DataSource[] | ListEnumDataSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumDataSourceFilter<$PrismaModel> | $Enums.DataSource
  }

  export type NestedEnumDataSourceWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.DataSource | EnumDataSourceFieldRefInput<$PrismaModel>
    in?: $Enums.DataSource[] | ListEnumDataSourceFieldRefInput<$PrismaModel>
    notIn?: $Enums.DataSource[] | ListEnumDataSourceFieldRefInput<$PrismaModel>
    not?: NestedEnumDataSourceWithAggregatesFilter<$PrismaModel> | $Enums.DataSource
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumDataSourceFilter<$PrismaModel>
    _max?: NestedEnumDataSourceFilter<$PrismaModel>
  }

  export type NestedBytesFilter<$PrismaModel = never> = {
    equals?: Bytes | BytesFieldRefInput<$PrismaModel>
    in?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    notIn?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    not?: NestedBytesFilter<$PrismaModel> | Bytes
  }

  export type NestedBytesWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Bytes | BytesFieldRefInput<$PrismaModel>
    in?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    notIn?: Bytes[] | ListBytesFieldRefInput<$PrismaModel>
    not?: NestedBytesWithAggregatesFilter<$PrismaModel> | Bytes
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBytesFilter<$PrismaModel>
    _max?: NestedBytesFilter<$PrismaModel>
  }

  export type NestedEnumMarketDataStateFilter<$PrismaModel = never> = {
    equals?: $Enums.MarketDataState | EnumMarketDataStateFieldRefInput<$PrismaModel>
    in?: $Enums.MarketDataState[] | ListEnumMarketDataStateFieldRefInput<$PrismaModel>
    notIn?: $Enums.MarketDataState[] | ListEnumMarketDataStateFieldRefInput<$PrismaModel>
    not?: NestedEnumMarketDataStateFilter<$PrismaModel> | $Enums.MarketDataState
  }

  export type NestedEnumMarketDataStateWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MarketDataState | EnumMarketDataStateFieldRefInput<$PrismaModel>
    in?: $Enums.MarketDataState[] | ListEnumMarketDataStateFieldRefInput<$PrismaModel>
    notIn?: $Enums.MarketDataState[] | ListEnumMarketDataStateFieldRefInput<$PrismaModel>
    not?: NestedEnumMarketDataStateWithAggregatesFilter<$PrismaModel> | $Enums.MarketDataState
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMarketDataStateFilter<$PrismaModel>
    _max?: NestedEnumMarketDataStateFilter<$PrismaModel>
  }

  export type NestedEnumTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.Type | EnumTypeFieldRefInput<$PrismaModel>
    in?: $Enums.Type[] | ListEnumTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.Type[] | ListEnumTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumTypeFilter<$PrismaModel> | $Enums.Type
  }

  export type NestedEnumTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Type | EnumTypeFieldRefInput<$PrismaModel>
    in?: $Enums.Type[] | ListEnumTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.Type[] | ListEnumTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumTypeWithAggregatesFilter<$PrismaModel> | $Enums.Type
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumTypeFilter<$PrismaModel>
    _max?: NestedEnumTypeFilter<$PrismaModel>
  }
  export type NestedJsonNullableFilter<$PrismaModel = never> =
    | PatchUndefined<
        Either<Required<NestedJsonNullableFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>,
        Required<NestedJsonNullableFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<NestedJsonNullableFilterBase<$PrismaModel>>, 'path'>>

  export type NestedJsonNullableFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    mode?: QueryMode | EnumQueryModeFieldRefInput<$PrismaModel>
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type NestedEnumAssetClassNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.AssetClass | EnumAssetClassFieldRefInput<$PrismaModel> | null
    in?: $Enums.AssetClass[] | ListEnumAssetClassFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AssetClass[] | ListEnumAssetClassFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAssetClassNullableFilter<$PrismaModel> | $Enums.AssetClass | null
  }

  export type NestedEnumAssetSubClassNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.AssetSubClass | EnumAssetSubClassFieldRefInput<$PrismaModel> | null
    in?: $Enums.AssetSubClass[] | ListEnumAssetSubClassFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AssetSubClass[] | ListEnumAssetSubClassFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAssetSubClassNullableFilter<$PrismaModel> | $Enums.AssetSubClass | null
  }

  export type NestedEnumAssetClassNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AssetClass | EnumAssetClassFieldRefInput<$PrismaModel> | null
    in?: $Enums.AssetClass[] | ListEnumAssetClassFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AssetClass[] | ListEnumAssetClassFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAssetClassNullableWithAggregatesFilter<$PrismaModel> | $Enums.AssetClass | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumAssetClassNullableFilter<$PrismaModel>
    _max?: NestedEnumAssetClassNullableFilter<$PrismaModel>
  }

  export type NestedEnumAssetSubClassNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AssetSubClass | EnumAssetSubClassFieldRefInput<$PrismaModel> | null
    in?: $Enums.AssetSubClass[] | ListEnumAssetSubClassFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.AssetSubClass[] | ListEnumAssetSubClassFieldRefInput<$PrismaModel> | null
    not?: NestedEnumAssetSubClassNullableWithAggregatesFilter<$PrismaModel> | $Enums.AssetSubClass | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumAssetSubClassNullableFilter<$PrismaModel>
    _max?: NestedEnumAssetSubClassNullableFilter<$PrismaModel>
  }

  export type NestedFloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type NestedFloatNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedFloatNullableFilter<$PrismaModel>
    _min?: NestedFloatNullableFilter<$PrismaModel>
    _max?: NestedFloatNullableFilter<$PrismaModel>
  }

  export type NestedEnumProviderFilter<$PrismaModel = never> = {
    equals?: $Enums.Provider | EnumProviderFieldRefInput<$PrismaModel>
    in?: $Enums.Provider[] | ListEnumProviderFieldRefInput<$PrismaModel>
    notIn?: $Enums.Provider[] | ListEnumProviderFieldRefInput<$PrismaModel>
    not?: NestedEnumProviderFilter<$PrismaModel> | $Enums.Provider
  }

  export type NestedEnumRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleFilter<$PrismaModel> | $Enums.Role
  }

  export type NestedEnumProviderWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Provider | EnumProviderFieldRefInput<$PrismaModel>
    in?: $Enums.Provider[] | ListEnumProviderFieldRefInput<$PrismaModel>
    notIn?: $Enums.Provider[] | ListEnumProviderFieldRefInput<$PrismaModel>
    not?: NestedEnumProviderWithAggregatesFilter<$PrismaModel> | $Enums.Provider
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumProviderFilter<$PrismaModel>
    _max?: NestedEnumProviderFilter<$PrismaModel>
  }

  export type NestedEnumRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.Role[] | ListEnumRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumRoleWithAggregatesFilter<$PrismaModel> | $Enums.Role
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRoleFilter<$PrismaModel>
    _max?: NestedEnumRoleFilter<$PrismaModel>
  }

  export type UserCreateWithoutAccessesGetInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAccessesGetInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAccessesGetInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAccessesGetInput, UserUncheckedCreateWithoutAccessesGetInput>
  }

  export type UserCreateWithoutAccessesGiveInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAccessesGiveInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAccessesGiveInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAccessesGiveInput, UserUncheckedCreateWithoutAccessesGiveInput>
  }

  export type UserUpsertWithoutAccessesGetInput = {
    update: XOR<UserUpdateWithoutAccessesGetInput, UserUncheckedUpdateWithoutAccessesGetInput>
    create: XOR<UserCreateWithoutAccessesGetInput, UserUncheckedCreateWithoutAccessesGetInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAccessesGetInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAccessesGetInput, UserUncheckedUpdateWithoutAccessesGetInput>
  }

  export type UserUpdateWithoutAccessesGetInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAccessesGetInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUpsertWithoutAccessesGiveInput = {
    update: XOR<UserUpdateWithoutAccessesGiveInput, UserUncheckedUpdateWithoutAccessesGiveInput>
    create: XOR<UserCreateWithoutAccessesGiveInput, UserUncheckedCreateWithoutAccessesGiveInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAccessesGiveInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAccessesGiveInput, UserUncheckedUpdateWithoutAccessesGiveInput>
  }

  export type UserUpdateWithoutAccessesGiveInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAccessesGiveInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type OrderCreateWithoutAccountInput = {
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    tags?: TagCreateNestedManyWithoutActivitiesInput
    user: UserCreateNestedOneWithoutActivitiesInput
    SymbolProfile: SymbolProfileCreateNestedOneWithoutActivitiesInput
  }

  export type OrderUncheckedCreateWithoutAccountInput = {
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    symbolProfileId: string
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    userId: string
    tags?: TagUncheckedCreateNestedManyWithoutActivitiesInput
  }

  export type OrderCreateOrConnectWithoutAccountInput = {
    where: OrderWhereUniqueInput
    create: XOR<OrderCreateWithoutAccountInput, OrderUncheckedCreateWithoutAccountInput>
  }

  export type OrderCreateManyAccountInputEnvelope = {
    data: OrderCreateManyAccountInput | OrderCreateManyAccountInput[]
    skipDuplicates?: boolean
  }

  export type AccountBalanceCreateWithoutAccountInput = {
    createdAt?: Date | string
    date?: Date | string
    id?: string
    updatedAt?: Date | string
    value: number
  }

  export type AccountBalanceUncheckedCreateWithoutAccountInput = {
    createdAt?: Date | string
    date?: Date | string
    id?: string
    updatedAt?: Date | string
    value: number
  }

  export type AccountBalanceCreateOrConnectWithoutAccountInput = {
    where: AccountBalanceWhereUniqueInput
    create: XOR<AccountBalanceCreateWithoutAccountInput, AccountBalanceUncheckedCreateWithoutAccountInput>
  }

  export type AccountBalanceCreateManyAccountInputEnvelope = {
    data: AccountBalanceCreateManyAccountInput | AccountBalanceCreateManyAccountInput[]
    skipDuplicates?: boolean
  }

  export type PlatformCreateWithoutAccountsInput = {
    id?: string
    name?: string | null
    url: string
  }

  export type PlatformUncheckedCreateWithoutAccountsInput = {
    id?: string
    name?: string | null
    url: string
  }

  export type PlatformCreateOrConnectWithoutAccountsInput = {
    where: PlatformWhereUniqueInput
    create: XOR<PlatformCreateWithoutAccountsInput, PlatformUncheckedCreateWithoutAccountsInput>
  }

  export type UserCreateWithoutAccountsInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAccountsInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAccountsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
  }

  export type OrderUpsertWithWhereUniqueWithoutAccountInput = {
    where: OrderWhereUniqueInput
    update: XOR<OrderUpdateWithoutAccountInput, OrderUncheckedUpdateWithoutAccountInput>
    create: XOR<OrderCreateWithoutAccountInput, OrderUncheckedCreateWithoutAccountInput>
  }

  export type OrderUpdateWithWhereUniqueWithoutAccountInput = {
    where: OrderWhereUniqueInput
    data: XOR<OrderUpdateWithoutAccountInput, OrderUncheckedUpdateWithoutAccountInput>
  }

  export type OrderUpdateManyWithWhereWithoutAccountInput = {
    where: OrderScalarWhereInput
    data: XOR<OrderUpdateManyMutationInput, OrderUncheckedUpdateManyWithoutAccountInput>
  }

  export type OrderScalarWhereInput = {
    AND?: OrderScalarWhereInput | OrderScalarWhereInput[]
    OR?: OrderScalarWhereInput[]
    NOT?: OrderScalarWhereInput | OrderScalarWhereInput[]
    accountId?: StringNullableFilter<"Order"> | string | null
    accountUserId?: StringNullableFilter<"Order"> | string | null
    comment?: StringNullableFilter<"Order"> | string | null
    createdAt?: DateTimeFilter<"Order"> | Date | string
    currency?: StringNullableFilter<"Order"> | string | null
    date?: DateTimeFilter<"Order"> | Date | string
    fee?: FloatFilter<"Order"> | number
    id?: StringFilter<"Order"> | string
    isDraft?: BoolFilter<"Order"> | boolean
    quantity?: FloatFilter<"Order"> | number
    symbolProfileId?: StringFilter<"Order"> | string
    type?: EnumTypeFilter<"Order"> | $Enums.Type
    unitPrice?: FloatFilter<"Order"> | number
    updatedAt?: DateTimeFilter<"Order"> | Date | string
    userId?: StringFilter<"Order"> | string
  }

  export type AccountBalanceUpsertWithWhereUniqueWithoutAccountInput = {
    where: AccountBalanceWhereUniqueInput
    update: XOR<AccountBalanceUpdateWithoutAccountInput, AccountBalanceUncheckedUpdateWithoutAccountInput>
    create: XOR<AccountBalanceCreateWithoutAccountInput, AccountBalanceUncheckedCreateWithoutAccountInput>
  }

  export type AccountBalanceUpdateWithWhereUniqueWithoutAccountInput = {
    where: AccountBalanceWhereUniqueInput
    data: XOR<AccountBalanceUpdateWithoutAccountInput, AccountBalanceUncheckedUpdateWithoutAccountInput>
  }

  export type AccountBalanceUpdateManyWithWhereWithoutAccountInput = {
    where: AccountBalanceScalarWhereInput
    data: XOR<AccountBalanceUpdateManyMutationInput, AccountBalanceUncheckedUpdateManyWithoutAccountInput>
  }

  export type AccountBalanceScalarWhereInput = {
    AND?: AccountBalanceScalarWhereInput | AccountBalanceScalarWhereInput[]
    OR?: AccountBalanceScalarWhereInput[]
    NOT?: AccountBalanceScalarWhereInput | AccountBalanceScalarWhereInput[]
    accountId?: StringFilter<"AccountBalance"> | string
    createdAt?: DateTimeFilter<"AccountBalance"> | Date | string
    date?: DateTimeFilter<"AccountBalance"> | Date | string
    id?: StringFilter<"AccountBalance"> | string
    updatedAt?: DateTimeFilter<"AccountBalance"> | Date | string
    userId?: StringFilter<"AccountBalance"> | string
    value?: FloatFilter<"AccountBalance"> | number
  }

  export type PlatformUpsertWithoutAccountsInput = {
    update: XOR<PlatformUpdateWithoutAccountsInput, PlatformUncheckedUpdateWithoutAccountsInput>
    create: XOR<PlatformCreateWithoutAccountsInput, PlatformUncheckedCreateWithoutAccountsInput>
    where?: PlatformWhereInput
  }

  export type PlatformUpdateToOneWithWhereWithoutAccountsInput = {
    where?: PlatformWhereInput
    data: XOR<PlatformUpdateWithoutAccountsInput, PlatformUncheckedUpdateWithoutAccountsInput>
  }

  export type PlatformUpdateWithoutAccountsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
  }

  export type PlatformUncheckedUpdateWithoutAccountsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: NullableStringFieldUpdateOperationsInput | string | null
    url?: StringFieldUpdateOperationsInput | string
  }

  export type UserUpsertWithoutAccountsInput = {
    update: XOR<UserUpdateWithoutAccountsInput, UserUncheckedUpdateWithoutAccountsInput>
    create: XOR<UserCreateWithoutAccountsInput, UserUncheckedCreateWithoutAccountsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAccountsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAccountsInput, UserUncheckedUpdateWithoutAccountsInput>
  }

  export type UserUpdateWithoutAccountsInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAccountsInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AccountCreateWithoutBalancesInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    updatedAt?: Date | string
    activities?: OrderCreateNestedManyWithoutAccountInput
    platform?: PlatformCreateNestedOneWithoutAccountsInput
    user: UserCreateNestedOneWithoutAccountsInput
  }

  export type AccountUncheckedCreateWithoutBalancesInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    platformId?: string | null
    updatedAt?: Date | string
    userId: string
    activities?: OrderUncheckedCreateNestedManyWithoutAccountInput
  }

  export type AccountCreateOrConnectWithoutBalancesInput = {
    where: AccountWhereUniqueInput
    create: XOR<AccountCreateWithoutBalancesInput, AccountUncheckedCreateWithoutBalancesInput>
  }

  export type AccountUpsertWithoutBalancesInput = {
    update: XOR<AccountUpdateWithoutBalancesInput, AccountUncheckedUpdateWithoutBalancesInput>
    create: XOR<AccountCreateWithoutBalancesInput, AccountUncheckedCreateWithoutBalancesInput>
    where?: AccountWhereInput
  }

  export type AccountUpdateToOneWithWhereWithoutBalancesInput = {
    where?: AccountWhereInput
    data: XOR<AccountUpdateWithoutBalancesInput, AccountUncheckedUpdateWithoutBalancesInput>
  }

  export type AccountUpdateWithoutBalancesInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    activities?: OrderUpdateManyWithoutAccountNestedInput
    platform?: PlatformUpdateOneWithoutAccountsNestedInput
    user?: UserUpdateOneRequiredWithoutAccountsNestedInput
  }

  export type AccountUncheckedUpdateWithoutBalancesInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    platformId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    activities?: OrderUncheckedUpdateManyWithoutAccountNestedInput
  }

  export type UserCreateWithoutAnalyticsInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAnalyticsInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAnalyticsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAnalyticsInput, UserUncheckedCreateWithoutAnalyticsInput>
  }

  export type UserUpsertWithoutAnalyticsInput = {
    update: XOR<UserUpdateWithoutAnalyticsInput, UserUncheckedUpdateWithoutAnalyticsInput>
    create: XOR<UserCreateWithoutAnalyticsInput, UserUncheckedCreateWithoutAnalyticsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAnalyticsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAnalyticsInput, UserUncheckedUpdateWithoutAnalyticsInput>
  }

  export type UserUpdateWithoutAnalyticsInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAnalyticsInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutApiKeysInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutApiKeysInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutApiKeysInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutApiKeysInput, UserUncheckedCreateWithoutApiKeysInput>
  }

  export type UserUpsertWithoutApiKeysInput = {
    update: XOR<UserUpdateWithoutApiKeysInput, UserUncheckedUpdateWithoutApiKeysInput>
    create: XOR<UserCreateWithoutApiKeysInput, UserUncheckedCreateWithoutApiKeysInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutApiKeysInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutApiKeysInput, UserUncheckedUpdateWithoutApiKeysInput>
  }

  export type UserUpdateWithoutApiKeysInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutApiKeysInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateWithoutAuthDevicesInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutAuthDevicesInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutAuthDevicesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutAuthDevicesInput, UserUncheckedCreateWithoutAuthDevicesInput>
  }

  export type UserUpsertWithoutAuthDevicesInput = {
    update: XOR<UserUpdateWithoutAuthDevicesInput, UserUncheckedUpdateWithoutAuthDevicesInput>
    create: XOR<UserCreateWithoutAuthDevicesInput, UserUncheckedCreateWithoutAuthDevicesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutAuthDevicesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutAuthDevicesInput, UserUncheckedUpdateWithoutAuthDevicesInput>
  }

  export type UserUpdateWithoutAuthDevicesInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutAuthDevicesInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AccountCreateWithoutActivitiesInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    updatedAt?: Date | string
    balances?: AccountBalanceCreateNestedManyWithoutAccountInput
    platform?: PlatformCreateNestedOneWithoutAccountsInput
    user: UserCreateNestedOneWithoutAccountsInput
  }

  export type AccountUncheckedCreateWithoutActivitiesInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    platformId?: string | null
    updatedAt?: Date | string
    userId: string
    balances?: AccountBalanceUncheckedCreateNestedManyWithoutAccountInput
  }

  export type AccountCreateOrConnectWithoutActivitiesInput = {
    where: AccountWhereUniqueInput
    create: XOR<AccountCreateWithoutActivitiesInput, AccountUncheckedCreateWithoutActivitiesInput>
  }

  export type TagCreateWithoutActivitiesInput = {
    id?: string
    name: string
    user?: UserCreateNestedOneWithoutTagsInput
  }

  export type TagUncheckedCreateWithoutActivitiesInput = {
    id?: string
    name: string
    userId?: string | null
  }

  export type TagCreateOrConnectWithoutActivitiesInput = {
    where: TagWhereUniqueInput
    create: XOR<TagCreateWithoutActivitiesInput, TagUncheckedCreateWithoutActivitiesInput>
  }

  export type UserCreateWithoutActivitiesInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutActivitiesInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutActivitiesInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutActivitiesInput, UserUncheckedCreateWithoutActivitiesInput>
  }

  export type SymbolProfileCreateWithoutActivitiesInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    user?: UserCreateNestedOneWithoutSymbolProfileInput
    watchedBy?: UserCreateNestedManyWithoutWatchlistInput
    SymbolProfileOverrides?: SymbolProfileOverridesCreateNestedOneWithoutSymbolProfileInput
  }

  export type SymbolProfileUncheckedCreateWithoutActivitiesInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    userId?: string | null
    watchedBy?: UserUncheckedCreateNestedManyWithoutWatchlistInput
    SymbolProfileOverrides?: SymbolProfileOverridesUncheckedCreateNestedOneWithoutSymbolProfileInput
  }

  export type SymbolProfileCreateOrConnectWithoutActivitiesInput = {
    where: SymbolProfileWhereUniqueInput
    create: XOR<SymbolProfileCreateWithoutActivitiesInput, SymbolProfileUncheckedCreateWithoutActivitiesInput>
  }

  export type AccountUpsertWithoutActivitiesInput = {
    update: XOR<AccountUpdateWithoutActivitiesInput, AccountUncheckedUpdateWithoutActivitiesInput>
    create: XOR<AccountCreateWithoutActivitiesInput, AccountUncheckedCreateWithoutActivitiesInput>
    where?: AccountWhereInput
  }

  export type AccountUpdateToOneWithWhereWithoutActivitiesInput = {
    where?: AccountWhereInput
    data: XOR<AccountUpdateWithoutActivitiesInput, AccountUncheckedUpdateWithoutActivitiesInput>
  }

  export type AccountUpdateWithoutActivitiesInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    balances?: AccountBalanceUpdateManyWithoutAccountNestedInput
    platform?: PlatformUpdateOneWithoutAccountsNestedInput
    user?: UserUpdateOneRequiredWithoutAccountsNestedInput
  }

  export type AccountUncheckedUpdateWithoutActivitiesInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    platformId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    balances?: AccountBalanceUncheckedUpdateManyWithoutAccountNestedInput
  }

  export type TagUpsertWithWhereUniqueWithoutActivitiesInput = {
    where: TagWhereUniqueInput
    update: XOR<TagUpdateWithoutActivitiesInput, TagUncheckedUpdateWithoutActivitiesInput>
    create: XOR<TagCreateWithoutActivitiesInput, TagUncheckedCreateWithoutActivitiesInput>
  }

  export type TagUpdateWithWhereUniqueWithoutActivitiesInput = {
    where: TagWhereUniqueInput
    data: XOR<TagUpdateWithoutActivitiesInput, TagUncheckedUpdateWithoutActivitiesInput>
  }

  export type TagUpdateManyWithWhereWithoutActivitiesInput = {
    where: TagScalarWhereInput
    data: XOR<TagUpdateManyMutationInput, TagUncheckedUpdateManyWithoutActivitiesInput>
  }

  export type TagScalarWhereInput = {
    AND?: TagScalarWhereInput | TagScalarWhereInput[]
    OR?: TagScalarWhereInput[]
    NOT?: TagScalarWhereInput | TagScalarWhereInput[]
    id?: StringFilter<"Tag"> | string
    name?: StringFilter<"Tag"> | string
    userId?: StringNullableFilter<"Tag"> | string | null
  }

  export type UserUpsertWithoutActivitiesInput = {
    update: XOR<UserUpdateWithoutActivitiesInput, UserUncheckedUpdateWithoutActivitiesInput>
    create: XOR<UserCreateWithoutActivitiesInput, UserUncheckedCreateWithoutActivitiesInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutActivitiesInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutActivitiesInput, UserUncheckedUpdateWithoutActivitiesInput>
  }

  export type UserUpdateWithoutActivitiesInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutActivitiesInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type SymbolProfileUpsertWithoutActivitiesInput = {
    update: XOR<SymbolProfileUpdateWithoutActivitiesInput, SymbolProfileUncheckedUpdateWithoutActivitiesInput>
    create: XOR<SymbolProfileCreateWithoutActivitiesInput, SymbolProfileUncheckedCreateWithoutActivitiesInput>
    where?: SymbolProfileWhereInput
  }

  export type SymbolProfileUpdateToOneWithWhereWithoutActivitiesInput = {
    where?: SymbolProfileWhereInput
    data: XOR<SymbolProfileUpdateWithoutActivitiesInput, SymbolProfileUncheckedUpdateWithoutActivitiesInput>
  }

  export type SymbolProfileUpdateWithoutActivitiesInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    user?: UserUpdateOneWithoutSymbolProfileNestedInput
    watchedBy?: UserUpdateManyWithoutWatchlistNestedInput
    SymbolProfileOverrides?: SymbolProfileOverridesUpdateOneWithoutSymbolProfileNestedInput
  }

  export type SymbolProfileUncheckedUpdateWithoutActivitiesInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    watchedBy?: UserUncheckedUpdateManyWithoutWatchlistNestedInput
    SymbolProfileOverrides?: SymbolProfileOverridesUncheckedUpdateOneWithoutSymbolProfileNestedInput
  }

  export type AccountCreateWithoutPlatformInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    updatedAt?: Date | string
    activities?: OrderCreateNestedManyWithoutAccountInput
    balances?: AccountBalanceCreateNestedManyWithoutAccountInput
    user: UserCreateNestedOneWithoutAccountsInput
  }

  export type AccountUncheckedCreateWithoutPlatformInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    updatedAt?: Date | string
    userId: string
    activities?: OrderUncheckedCreateNestedManyWithoutAccountInput
    balances?: AccountBalanceUncheckedCreateNestedManyWithoutAccountInput
  }

  export type AccountCreateOrConnectWithoutPlatformInput = {
    where: AccountWhereUniqueInput
    create: XOR<AccountCreateWithoutPlatformInput, AccountUncheckedCreateWithoutPlatformInput>
  }

  export type AccountCreateManyPlatformInputEnvelope = {
    data: AccountCreateManyPlatformInput | AccountCreateManyPlatformInput[]
    skipDuplicates?: boolean
  }

  export type AccountUpsertWithWhereUniqueWithoutPlatformInput = {
    where: AccountWhereUniqueInput
    update: XOR<AccountUpdateWithoutPlatformInput, AccountUncheckedUpdateWithoutPlatformInput>
    create: XOR<AccountCreateWithoutPlatformInput, AccountUncheckedCreateWithoutPlatformInput>
  }

  export type AccountUpdateWithWhereUniqueWithoutPlatformInput = {
    where: AccountWhereUniqueInput
    data: XOR<AccountUpdateWithoutPlatformInput, AccountUncheckedUpdateWithoutPlatformInput>
  }

  export type AccountUpdateManyWithWhereWithoutPlatformInput = {
    where: AccountScalarWhereInput
    data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyWithoutPlatformInput>
  }

  export type AccountScalarWhereInput = {
    AND?: AccountScalarWhereInput | AccountScalarWhereInput[]
    OR?: AccountScalarWhereInput[]
    NOT?: AccountScalarWhereInput | AccountScalarWhereInput[]
    balance?: FloatFilter<"Account"> | number
    comment?: StringNullableFilter<"Account"> | string | null
    createdAt?: DateTimeFilter<"Account"> | Date | string
    currency?: StringNullableFilter<"Account"> | string | null
    id?: StringFilter<"Account"> | string
    isExcluded?: BoolFilter<"Account"> | boolean
    name?: StringNullableFilter<"Account"> | string | null
    platformId?: StringNullableFilter<"Account"> | string | null
    updatedAt?: DateTimeFilter<"Account"> | Date | string
    userId?: StringFilter<"Account"> | string
  }

  export type UserCreateWithoutSettingsInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSettingsInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSettingsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSettingsInput, UserUncheckedCreateWithoutSettingsInput>
  }

  export type UserUpsertWithoutSettingsInput = {
    update: XOR<UserUpdateWithoutSettingsInput, UserUncheckedUpdateWithoutSettingsInput>
    create: XOR<UserCreateWithoutSettingsInput, UserUncheckedCreateWithoutSettingsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSettingsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSettingsInput, UserUncheckedUpdateWithoutSettingsInput>
  }

  export type UserUpdateWithoutSettingsInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSettingsInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type OrderCreateWithoutSymbolProfileInput = {
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    account?: AccountCreateNestedOneWithoutActivitiesInput
    tags?: TagCreateNestedManyWithoutActivitiesInput
    user: UserCreateNestedOneWithoutActivitiesInput
  }

  export type OrderUncheckedCreateWithoutSymbolProfileInput = {
    accountId?: string | null
    accountUserId?: string | null
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    userId: string
    tags?: TagUncheckedCreateNestedManyWithoutActivitiesInput
  }

  export type OrderCreateOrConnectWithoutSymbolProfileInput = {
    where: OrderWhereUniqueInput
    create: XOR<OrderCreateWithoutSymbolProfileInput, OrderUncheckedCreateWithoutSymbolProfileInput>
  }

  export type OrderCreateManySymbolProfileInputEnvelope = {
    data: OrderCreateManySymbolProfileInput | OrderCreateManySymbolProfileInput[]
    skipDuplicates?: boolean
  }

  export type UserCreateWithoutSymbolProfileInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
  }

  export type UserUncheckedCreateWithoutSymbolProfileInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
  }

  export type UserCreateOrConnectWithoutSymbolProfileInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSymbolProfileInput, UserUncheckedCreateWithoutSymbolProfileInput>
  }

  export type UserCreateWithoutWatchlistInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutWatchlistInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutWatchlistInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutWatchlistInput, UserUncheckedCreateWithoutWatchlistInput>
  }

  export type SymbolProfileOverridesCreateWithoutSymbolProfileInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    url?: string | null
  }

  export type SymbolProfileOverridesUncheckedCreateWithoutSymbolProfileInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    url?: string | null
  }

  export type SymbolProfileOverridesCreateOrConnectWithoutSymbolProfileInput = {
    where: SymbolProfileOverridesWhereUniqueInput
    create: XOR<SymbolProfileOverridesCreateWithoutSymbolProfileInput, SymbolProfileOverridesUncheckedCreateWithoutSymbolProfileInput>
  }

  export type OrderUpsertWithWhereUniqueWithoutSymbolProfileInput = {
    where: OrderWhereUniqueInput
    update: XOR<OrderUpdateWithoutSymbolProfileInput, OrderUncheckedUpdateWithoutSymbolProfileInput>
    create: XOR<OrderCreateWithoutSymbolProfileInput, OrderUncheckedCreateWithoutSymbolProfileInput>
  }

  export type OrderUpdateWithWhereUniqueWithoutSymbolProfileInput = {
    where: OrderWhereUniqueInput
    data: XOR<OrderUpdateWithoutSymbolProfileInput, OrderUncheckedUpdateWithoutSymbolProfileInput>
  }

  export type OrderUpdateManyWithWhereWithoutSymbolProfileInput = {
    where: OrderScalarWhereInput
    data: XOR<OrderUpdateManyMutationInput, OrderUncheckedUpdateManyWithoutSymbolProfileInput>
  }

  export type UserUpsertWithoutSymbolProfileInput = {
    update: XOR<UserUpdateWithoutSymbolProfileInput, UserUncheckedUpdateWithoutSymbolProfileInput>
    create: XOR<UserCreateWithoutSymbolProfileInput, UserUncheckedCreateWithoutSymbolProfileInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSymbolProfileInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSymbolProfileInput, UserUncheckedUpdateWithoutSymbolProfileInput>
  }

  export type UserUpdateWithoutSymbolProfileInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
  }

  export type UserUncheckedUpdateWithoutSymbolProfileInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
  }

  export type UserUpsertWithWhereUniqueWithoutWatchlistInput = {
    where: UserWhereUniqueInput
    update: XOR<UserUpdateWithoutWatchlistInput, UserUncheckedUpdateWithoutWatchlistInput>
    create: XOR<UserCreateWithoutWatchlistInput, UserUncheckedCreateWithoutWatchlistInput>
  }

  export type UserUpdateWithWhereUniqueWithoutWatchlistInput = {
    where: UserWhereUniqueInput
    data: XOR<UserUpdateWithoutWatchlistInput, UserUncheckedUpdateWithoutWatchlistInput>
  }

  export type UserUpdateManyWithWhereWithoutWatchlistInput = {
    where: UserScalarWhereInput
    data: XOR<UserUpdateManyMutationInput, UserUncheckedUpdateManyWithoutWatchlistInput>
  }

  export type UserScalarWhereInput = {
    AND?: UserScalarWhereInput | UserScalarWhereInput[]
    OR?: UserScalarWhereInput[]
    NOT?: UserScalarWhereInput | UserScalarWhereInput[]
    accessToken?: StringNullableFilter<"User"> | string | null
    authChallenge?: StringNullableFilter<"User"> | string | null
    createdAt?: DateTimeFilter<"User"> | Date | string
    id?: StringFilter<"User"> | string
    provider?: EnumProviderFilter<"User"> | $Enums.Provider
    role?: EnumRoleFilter<"User"> | $Enums.Role
    thirdPartyId?: StringNullableFilter<"User"> | string | null
    updatedAt?: DateTimeFilter<"User"> | Date | string
  }

  export type SymbolProfileOverridesUpsertWithoutSymbolProfileInput = {
    update: XOR<SymbolProfileOverridesUpdateWithoutSymbolProfileInput, SymbolProfileOverridesUncheckedUpdateWithoutSymbolProfileInput>
    create: XOR<SymbolProfileOverridesCreateWithoutSymbolProfileInput, SymbolProfileOverridesUncheckedCreateWithoutSymbolProfileInput>
    where?: SymbolProfileOverridesWhereInput
  }

  export type SymbolProfileOverridesUpdateToOneWithWhereWithoutSymbolProfileInput = {
    where?: SymbolProfileOverridesWhereInput
    data: XOR<SymbolProfileOverridesUpdateWithoutSymbolProfileInput, SymbolProfileOverridesUncheckedUpdateWithoutSymbolProfileInput>
  }

  export type SymbolProfileOverridesUpdateWithoutSymbolProfileInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: NullableStringFieldUpdateOperationsInput | string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    url?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SymbolProfileOverridesUncheckedUpdateWithoutSymbolProfileInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    holdings?: NullableJsonNullValueInput | InputJsonValue
    name?: NullableStringFieldUpdateOperationsInput | string | null
    sectors?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    url?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SymbolProfileCreateWithoutSymbolProfileOverridesInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    activities?: OrderCreateNestedManyWithoutSymbolProfileInput
    user?: UserCreateNestedOneWithoutSymbolProfileInput
    watchedBy?: UserCreateNestedManyWithoutWatchlistInput
  }

  export type SymbolProfileUncheckedCreateWithoutSymbolProfileOverridesInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    userId?: string | null
    activities?: OrderUncheckedCreateNestedManyWithoutSymbolProfileInput
    watchedBy?: UserUncheckedCreateNestedManyWithoutWatchlistInput
  }

  export type SymbolProfileCreateOrConnectWithoutSymbolProfileOverridesInput = {
    where: SymbolProfileWhereUniqueInput
    create: XOR<SymbolProfileCreateWithoutSymbolProfileOverridesInput, SymbolProfileUncheckedCreateWithoutSymbolProfileOverridesInput>
  }

  export type SymbolProfileUpsertWithoutSymbolProfileOverridesInput = {
    update: XOR<SymbolProfileUpdateWithoutSymbolProfileOverridesInput, SymbolProfileUncheckedUpdateWithoutSymbolProfileOverridesInput>
    create: XOR<SymbolProfileCreateWithoutSymbolProfileOverridesInput, SymbolProfileUncheckedCreateWithoutSymbolProfileOverridesInput>
    where?: SymbolProfileWhereInput
  }

  export type SymbolProfileUpdateToOneWithWhereWithoutSymbolProfileOverridesInput = {
    where?: SymbolProfileWhereInput
    data: XOR<SymbolProfileUpdateWithoutSymbolProfileOverridesInput, SymbolProfileUncheckedUpdateWithoutSymbolProfileOverridesInput>
  }

  export type SymbolProfileUpdateWithoutSymbolProfileOverridesInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    activities?: OrderUpdateManyWithoutSymbolProfileNestedInput
    user?: UserUpdateOneWithoutSymbolProfileNestedInput
    watchedBy?: UserUpdateManyWithoutWatchlistNestedInput
  }

  export type SymbolProfileUncheckedUpdateWithoutSymbolProfileOverridesInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    activities?: OrderUncheckedUpdateManyWithoutSymbolProfileNestedInput
    watchedBy?: UserUncheckedUpdateManyWithoutWatchlistNestedInput
  }

  export type UserCreateWithoutSubscriptionsInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    tags?: TagCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutSubscriptionsInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    tags?: TagUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutSubscriptionsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutSubscriptionsInput, UserUncheckedCreateWithoutSubscriptionsInput>
  }

  export type UserUpsertWithoutSubscriptionsInput = {
    update: XOR<UserUpdateWithoutSubscriptionsInput, UserUncheckedUpdateWithoutSubscriptionsInput>
    create: XOR<UserCreateWithoutSubscriptionsInput, UserUncheckedCreateWithoutSubscriptionsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutSubscriptionsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutSubscriptionsInput, UserUncheckedUpdateWithoutSubscriptionsInput>
  }

  export type UserUpdateWithoutSubscriptionsInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutSubscriptionsInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type OrderCreateWithoutTagsInput = {
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    account?: AccountCreateNestedOneWithoutActivitiesInput
    user: UserCreateNestedOneWithoutActivitiesInput
    SymbolProfile: SymbolProfileCreateNestedOneWithoutActivitiesInput
  }

  export type OrderUncheckedCreateWithoutTagsInput = {
    accountId?: string | null
    accountUserId?: string | null
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    symbolProfileId: string
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    userId: string
  }

  export type OrderCreateOrConnectWithoutTagsInput = {
    where: OrderWhereUniqueInput
    create: XOR<OrderCreateWithoutTagsInput, OrderUncheckedCreateWithoutTagsInput>
  }

  export type UserCreateWithoutTagsInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessCreateNestedManyWithoutUserInput
    accounts?: AccountCreateNestedManyWithoutUserInput
    activities?: OrderCreateNestedManyWithoutUserInput
    analytics?: AnalyticsCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceCreateNestedManyWithoutUserInput
    settings?: SettingsCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutTagsInput = {
    accessToken?: string | null
    authChallenge?: string | null
    createdAt?: Date | string
    id?: string
    provider?: $Enums.Provider
    role?: $Enums.Role
    thirdPartyId?: string | null
    updatedAt?: Date | string
    accessesGet?: AccessUncheckedCreateNestedManyWithoutGranteeUserInput
    accessesGive?: AccessUncheckedCreateNestedManyWithoutUserInput
    accounts?: AccountUncheckedCreateNestedManyWithoutUserInput
    activities?: OrderUncheckedCreateNestedManyWithoutUserInput
    analytics?: AnalyticsUncheckedCreateNestedOneWithoutUserInput
    apiKeys?: ApiKeyUncheckedCreateNestedManyWithoutUserInput
    authDevices?: AuthDeviceUncheckedCreateNestedManyWithoutUserInput
    settings?: SettingsUncheckedCreateNestedOneWithoutUserInput
    subscriptions?: SubscriptionUncheckedCreateNestedManyWithoutUserInput
    watchlist?: SymbolProfileUncheckedCreateNestedManyWithoutWatchedByInput
    SymbolProfile?: SymbolProfileUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutTagsInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutTagsInput, UserUncheckedCreateWithoutTagsInput>
  }

  export type OrderUpsertWithWhereUniqueWithoutTagsInput = {
    where: OrderWhereUniqueInput
    update: XOR<OrderUpdateWithoutTagsInput, OrderUncheckedUpdateWithoutTagsInput>
    create: XOR<OrderCreateWithoutTagsInput, OrderUncheckedCreateWithoutTagsInput>
  }

  export type OrderUpdateWithWhereUniqueWithoutTagsInput = {
    where: OrderWhereUniqueInput
    data: XOR<OrderUpdateWithoutTagsInput, OrderUncheckedUpdateWithoutTagsInput>
  }

  export type OrderUpdateManyWithWhereWithoutTagsInput = {
    where: OrderScalarWhereInput
    data: XOR<OrderUpdateManyMutationInput, OrderUncheckedUpdateManyWithoutTagsInput>
  }

  export type UserUpsertWithoutTagsInput = {
    update: XOR<UserUpdateWithoutTagsInput, UserUncheckedUpdateWithoutTagsInput>
    create: XOR<UserCreateWithoutTagsInput, UserUncheckedCreateWithoutTagsInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutTagsInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutTagsInput, UserUncheckedUpdateWithoutTagsInput>
  }

  export type UserUpdateWithoutTagsInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutTagsInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    watchlist?: SymbolProfileUncheckedUpdateManyWithoutWatchedByNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type AccessCreateWithoutGranteeUserInput = {
    alias?: string | null
    createdAt?: Date | string
    id?: string
    permissions?: AccessCreatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    user: UserCreateNestedOneWithoutAccessesGiveInput
  }

  export type AccessUncheckedCreateWithoutGranteeUserInput = {
    alias?: string | null
    createdAt?: Date | string
    id?: string
    permissions?: AccessCreatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    userId: string
  }

  export type AccessCreateOrConnectWithoutGranteeUserInput = {
    where: AccessWhereUniqueInput
    create: XOR<AccessCreateWithoutGranteeUserInput, AccessUncheckedCreateWithoutGranteeUserInput>
  }

  export type AccessCreateManyGranteeUserInputEnvelope = {
    data: AccessCreateManyGranteeUserInput | AccessCreateManyGranteeUserInput[]
    skipDuplicates?: boolean
  }

  export type AccessCreateWithoutUserInput = {
    alias?: string | null
    createdAt?: Date | string
    id?: string
    permissions?: AccessCreatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    granteeUser?: UserCreateNestedOneWithoutAccessesGetInput
  }

  export type AccessUncheckedCreateWithoutUserInput = {
    alias?: string | null
    createdAt?: Date | string
    granteeUserId?: string | null
    id?: string
    permissions?: AccessCreatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
  }

  export type AccessCreateOrConnectWithoutUserInput = {
    where: AccessWhereUniqueInput
    create: XOR<AccessCreateWithoutUserInput, AccessUncheckedCreateWithoutUserInput>
  }

  export type AccessCreateManyUserInputEnvelope = {
    data: AccessCreateManyUserInput | AccessCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AccountCreateWithoutUserInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    updatedAt?: Date | string
    activities?: OrderCreateNestedManyWithoutAccountInput
    balances?: AccountBalanceCreateNestedManyWithoutAccountInput
    platform?: PlatformCreateNestedOneWithoutAccountsInput
  }

  export type AccountUncheckedCreateWithoutUserInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    platformId?: string | null
    updatedAt?: Date | string
    activities?: OrderUncheckedCreateNestedManyWithoutAccountInput
    balances?: AccountBalanceUncheckedCreateNestedManyWithoutAccountInput
  }

  export type AccountCreateOrConnectWithoutUserInput = {
    where: AccountWhereUniqueInput
    create: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput>
  }

  export type AccountCreateManyUserInputEnvelope = {
    data: AccountCreateManyUserInput | AccountCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type OrderCreateWithoutUserInput = {
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    account?: AccountCreateNestedOneWithoutActivitiesInput
    tags?: TagCreateNestedManyWithoutActivitiesInput
    SymbolProfile: SymbolProfileCreateNestedOneWithoutActivitiesInput
  }

  export type OrderUncheckedCreateWithoutUserInput = {
    accountId?: string | null
    accountUserId?: string | null
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    symbolProfileId: string
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    tags?: TagUncheckedCreateNestedManyWithoutActivitiesInput
  }

  export type OrderCreateOrConnectWithoutUserInput = {
    where: OrderWhereUniqueInput
    create: XOR<OrderCreateWithoutUserInput, OrderUncheckedCreateWithoutUserInput>
  }

  export type OrderCreateManyUserInputEnvelope = {
    data: OrderCreateManyUserInput | OrderCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AnalyticsCreateWithoutUserInput = {
    activityCount?: number
    country?: string | null
    dataProviderGhostfolioDailyRequests?: number
    lastRequestAt?: Date | string
    updatedAt?: Date | string
  }

  export type AnalyticsUncheckedCreateWithoutUserInput = {
    activityCount?: number
    country?: string | null
    dataProviderGhostfolioDailyRequests?: number
    lastRequestAt?: Date | string
    updatedAt?: Date | string
  }

  export type AnalyticsCreateOrConnectWithoutUserInput = {
    where: AnalyticsWhereUniqueInput
    create: XOR<AnalyticsCreateWithoutUserInput, AnalyticsUncheckedCreateWithoutUserInput>
  }

  export type ApiKeyCreateWithoutUserInput = {
    createdAt?: Date | string
    hashedKey: string
    id?: string
    updatedAt?: Date | string
  }

  export type ApiKeyUncheckedCreateWithoutUserInput = {
    createdAt?: Date | string
    hashedKey: string
    id?: string
    updatedAt?: Date | string
  }

  export type ApiKeyCreateOrConnectWithoutUserInput = {
    where: ApiKeyWhereUniqueInput
    create: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput>
  }

  export type ApiKeyCreateManyUserInputEnvelope = {
    data: ApiKeyCreateManyUserInput | ApiKeyCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AuthDeviceCreateWithoutUserInput = {
    createdAt?: Date | string
    credentialId: Bytes
    credentialPublicKey: Bytes
    counter: number
    id?: string
    updatedAt?: Date | string
  }

  export type AuthDeviceUncheckedCreateWithoutUserInput = {
    createdAt?: Date | string
    credentialId: Bytes
    credentialPublicKey: Bytes
    counter: number
    id?: string
    updatedAt?: Date | string
  }

  export type AuthDeviceCreateOrConnectWithoutUserInput = {
    where: AuthDeviceWhereUniqueInput
    create: XOR<AuthDeviceCreateWithoutUserInput, AuthDeviceUncheckedCreateWithoutUserInput>
  }

  export type AuthDeviceCreateManyUserInputEnvelope = {
    data: AuthDeviceCreateManyUserInput | AuthDeviceCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type SettingsCreateWithoutUserInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
  }

  export type SettingsUncheckedCreateWithoutUserInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
  }

  export type SettingsCreateOrConnectWithoutUserInput = {
    where: SettingsWhereUniqueInput
    create: XOR<SettingsCreateWithoutUserInput, SettingsUncheckedCreateWithoutUserInput>
  }

  export type SubscriptionCreateWithoutUserInput = {
    createdAt?: Date | string
    expiresAt: Date | string
    id?: string
    price?: number | null
    updatedAt?: Date | string
  }

  export type SubscriptionUncheckedCreateWithoutUserInput = {
    createdAt?: Date | string
    expiresAt: Date | string
    id?: string
    price?: number | null
    updatedAt?: Date | string
  }

  export type SubscriptionCreateOrConnectWithoutUserInput = {
    where: SubscriptionWhereUniqueInput
    create: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput>
  }

  export type SubscriptionCreateManyUserInputEnvelope = {
    data: SubscriptionCreateManyUserInput | SubscriptionCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type TagCreateWithoutUserInput = {
    id?: string
    name: string
    activities?: OrderCreateNestedManyWithoutTagsInput
  }

  export type TagUncheckedCreateWithoutUserInput = {
    id?: string
    name: string
    activities?: OrderUncheckedCreateNestedManyWithoutTagsInput
  }

  export type TagCreateOrConnectWithoutUserInput = {
    where: TagWhereUniqueInput
    create: XOR<TagCreateWithoutUserInput, TagUncheckedCreateWithoutUserInput>
  }

  export type TagCreateManyUserInputEnvelope = {
    data: TagCreateManyUserInput | TagCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type SymbolProfileCreateWithoutWatchedByInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    activities?: OrderCreateNestedManyWithoutSymbolProfileInput
    user?: UserCreateNestedOneWithoutSymbolProfileInput
    SymbolProfileOverrides?: SymbolProfileOverridesCreateNestedOneWithoutSymbolProfileInput
  }

  export type SymbolProfileUncheckedCreateWithoutWatchedByInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    userId?: string | null
    activities?: OrderUncheckedCreateNestedManyWithoutSymbolProfileInput
    SymbolProfileOverrides?: SymbolProfileOverridesUncheckedCreateNestedOneWithoutSymbolProfileInput
  }

  export type SymbolProfileCreateOrConnectWithoutWatchedByInput = {
    where: SymbolProfileWhereUniqueInput
    create: XOR<SymbolProfileCreateWithoutWatchedByInput, SymbolProfileUncheckedCreateWithoutWatchedByInput>
  }

  export type SymbolProfileCreateWithoutUserInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    activities?: OrderCreateNestedManyWithoutSymbolProfileInput
    watchedBy?: UserCreateNestedManyWithoutWatchlistInput
    SymbolProfileOverrides?: SymbolProfileOverridesCreateNestedOneWithoutSymbolProfileInput
  }

  export type SymbolProfileUncheckedCreateWithoutUserInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
    activities?: OrderUncheckedCreateNestedManyWithoutSymbolProfileInput
    watchedBy?: UserUncheckedCreateNestedManyWithoutWatchlistInput
    SymbolProfileOverrides?: SymbolProfileOverridesUncheckedCreateNestedOneWithoutSymbolProfileInput
  }

  export type SymbolProfileCreateOrConnectWithoutUserInput = {
    where: SymbolProfileWhereUniqueInput
    create: XOR<SymbolProfileCreateWithoutUserInput, SymbolProfileUncheckedCreateWithoutUserInput>
  }

  export type SymbolProfileCreateManyUserInputEnvelope = {
    data: SymbolProfileCreateManyUserInput | SymbolProfileCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type AccessUpsertWithWhereUniqueWithoutGranteeUserInput = {
    where: AccessWhereUniqueInput
    update: XOR<AccessUpdateWithoutGranteeUserInput, AccessUncheckedUpdateWithoutGranteeUserInput>
    create: XOR<AccessCreateWithoutGranteeUserInput, AccessUncheckedCreateWithoutGranteeUserInput>
  }

  export type AccessUpdateWithWhereUniqueWithoutGranteeUserInput = {
    where: AccessWhereUniqueInput
    data: XOR<AccessUpdateWithoutGranteeUserInput, AccessUncheckedUpdateWithoutGranteeUserInput>
  }

  export type AccessUpdateManyWithWhereWithoutGranteeUserInput = {
    where: AccessScalarWhereInput
    data: XOR<AccessUpdateManyMutationInput, AccessUncheckedUpdateManyWithoutGranteeUserInput>
  }

  export type AccessScalarWhereInput = {
    AND?: AccessScalarWhereInput | AccessScalarWhereInput[]
    OR?: AccessScalarWhereInput[]
    NOT?: AccessScalarWhereInput | AccessScalarWhereInput[]
    alias?: StringNullableFilter<"Access"> | string | null
    createdAt?: DateTimeFilter<"Access"> | Date | string
    granteeUserId?: StringNullableFilter<"Access"> | string | null
    id?: StringFilter<"Access"> | string
    permissions?: EnumAccessPermissionNullableListFilter<"Access">
    settings?: JsonFilter<"Access">
    updatedAt?: DateTimeFilter<"Access"> | Date | string
    userId?: StringFilter<"Access"> | string
  }

  export type AccessUpsertWithWhereUniqueWithoutUserInput = {
    where: AccessWhereUniqueInput
    update: XOR<AccessUpdateWithoutUserInput, AccessUncheckedUpdateWithoutUserInput>
    create: XOR<AccessCreateWithoutUserInput, AccessUncheckedCreateWithoutUserInput>
  }

  export type AccessUpdateWithWhereUniqueWithoutUserInput = {
    where: AccessWhereUniqueInput
    data: XOR<AccessUpdateWithoutUserInput, AccessUncheckedUpdateWithoutUserInput>
  }

  export type AccessUpdateManyWithWhereWithoutUserInput = {
    where: AccessScalarWhereInput
    data: XOR<AccessUpdateManyMutationInput, AccessUncheckedUpdateManyWithoutUserInput>
  }

  export type AccountUpsertWithWhereUniqueWithoutUserInput = {
    where: AccountWhereUniqueInput
    update: XOR<AccountUpdateWithoutUserInput, AccountUncheckedUpdateWithoutUserInput>
    create: XOR<AccountCreateWithoutUserInput, AccountUncheckedCreateWithoutUserInput>
  }

  export type AccountUpdateWithWhereUniqueWithoutUserInput = {
    where: AccountWhereUniqueInput
    data: XOR<AccountUpdateWithoutUserInput, AccountUncheckedUpdateWithoutUserInput>
  }

  export type AccountUpdateManyWithWhereWithoutUserInput = {
    where: AccountScalarWhereInput
    data: XOR<AccountUpdateManyMutationInput, AccountUncheckedUpdateManyWithoutUserInput>
  }

  export type OrderUpsertWithWhereUniqueWithoutUserInput = {
    where: OrderWhereUniqueInput
    update: XOR<OrderUpdateWithoutUserInput, OrderUncheckedUpdateWithoutUserInput>
    create: XOR<OrderCreateWithoutUserInput, OrderUncheckedCreateWithoutUserInput>
  }

  export type OrderUpdateWithWhereUniqueWithoutUserInput = {
    where: OrderWhereUniqueInput
    data: XOR<OrderUpdateWithoutUserInput, OrderUncheckedUpdateWithoutUserInput>
  }

  export type OrderUpdateManyWithWhereWithoutUserInput = {
    where: OrderScalarWhereInput
    data: XOR<OrderUpdateManyMutationInput, OrderUncheckedUpdateManyWithoutUserInput>
  }

  export type AnalyticsUpsertWithoutUserInput = {
    update: XOR<AnalyticsUpdateWithoutUserInput, AnalyticsUncheckedUpdateWithoutUserInput>
    create: XOR<AnalyticsCreateWithoutUserInput, AnalyticsUncheckedCreateWithoutUserInput>
    where?: AnalyticsWhereInput
  }

  export type AnalyticsUpdateToOneWithWhereWithoutUserInput = {
    where?: AnalyticsWhereInput
    data: XOR<AnalyticsUpdateWithoutUserInput, AnalyticsUncheckedUpdateWithoutUserInput>
  }

  export type AnalyticsUpdateWithoutUserInput = {
    activityCount?: IntFieldUpdateOperationsInput | number
    country?: NullableStringFieldUpdateOperationsInput | string | null
    dataProviderGhostfolioDailyRequests?: IntFieldUpdateOperationsInput | number
    lastRequestAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AnalyticsUncheckedUpdateWithoutUserInput = {
    activityCount?: IntFieldUpdateOperationsInput | number
    country?: NullableStringFieldUpdateOperationsInput | string | null
    dataProviderGhostfolioDailyRequests?: IntFieldUpdateOperationsInput | number
    lastRequestAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ApiKeyUpsertWithWhereUniqueWithoutUserInput = {
    where: ApiKeyWhereUniqueInput
    update: XOR<ApiKeyUpdateWithoutUserInput, ApiKeyUncheckedUpdateWithoutUserInput>
    create: XOR<ApiKeyCreateWithoutUserInput, ApiKeyUncheckedCreateWithoutUserInput>
  }

  export type ApiKeyUpdateWithWhereUniqueWithoutUserInput = {
    where: ApiKeyWhereUniqueInput
    data: XOR<ApiKeyUpdateWithoutUserInput, ApiKeyUncheckedUpdateWithoutUserInput>
  }

  export type ApiKeyUpdateManyWithWhereWithoutUserInput = {
    where: ApiKeyScalarWhereInput
    data: XOR<ApiKeyUpdateManyMutationInput, ApiKeyUncheckedUpdateManyWithoutUserInput>
  }

  export type ApiKeyScalarWhereInput = {
    AND?: ApiKeyScalarWhereInput | ApiKeyScalarWhereInput[]
    OR?: ApiKeyScalarWhereInput[]
    NOT?: ApiKeyScalarWhereInput | ApiKeyScalarWhereInput[]
    createdAt?: DateTimeFilter<"ApiKey"> | Date | string
    hashedKey?: StringFilter<"ApiKey"> | string
    id?: StringFilter<"ApiKey"> | string
    updatedAt?: DateTimeFilter<"ApiKey"> | Date | string
    userId?: StringFilter<"ApiKey"> | string
  }

  export type AuthDeviceUpsertWithWhereUniqueWithoutUserInput = {
    where: AuthDeviceWhereUniqueInput
    update: XOR<AuthDeviceUpdateWithoutUserInput, AuthDeviceUncheckedUpdateWithoutUserInput>
    create: XOR<AuthDeviceCreateWithoutUserInput, AuthDeviceUncheckedCreateWithoutUserInput>
  }

  export type AuthDeviceUpdateWithWhereUniqueWithoutUserInput = {
    where: AuthDeviceWhereUniqueInput
    data: XOR<AuthDeviceUpdateWithoutUserInput, AuthDeviceUncheckedUpdateWithoutUserInput>
  }

  export type AuthDeviceUpdateManyWithWhereWithoutUserInput = {
    where: AuthDeviceScalarWhereInput
    data: XOR<AuthDeviceUpdateManyMutationInput, AuthDeviceUncheckedUpdateManyWithoutUserInput>
  }

  export type AuthDeviceScalarWhereInput = {
    AND?: AuthDeviceScalarWhereInput | AuthDeviceScalarWhereInput[]
    OR?: AuthDeviceScalarWhereInput[]
    NOT?: AuthDeviceScalarWhereInput | AuthDeviceScalarWhereInput[]
    createdAt?: DateTimeFilter<"AuthDevice"> | Date | string
    credentialId?: BytesFilter<"AuthDevice"> | Bytes
    credentialPublicKey?: BytesFilter<"AuthDevice"> | Bytes
    counter?: IntFilter<"AuthDevice"> | number
    id?: StringFilter<"AuthDevice"> | string
    updatedAt?: DateTimeFilter<"AuthDevice"> | Date | string
    userId?: StringFilter<"AuthDevice"> | string
  }

  export type SettingsUpsertWithoutUserInput = {
    update: XOR<SettingsUpdateWithoutUserInput, SettingsUncheckedUpdateWithoutUserInput>
    create: XOR<SettingsCreateWithoutUserInput, SettingsUncheckedCreateWithoutUserInput>
    where?: SettingsWhereInput
  }

  export type SettingsUpdateToOneWithWhereWithoutUserInput = {
    where?: SettingsWhereInput
    data: XOR<SettingsUpdateWithoutUserInput, SettingsUncheckedUpdateWithoutUserInput>
  }

  export type SettingsUpdateWithoutUserInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SettingsUncheckedUpdateWithoutUserInput = {
    settings?: NullableJsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscriptionUpsertWithWhereUniqueWithoutUserInput = {
    where: SubscriptionWhereUniqueInput
    update: XOR<SubscriptionUpdateWithoutUserInput, SubscriptionUncheckedUpdateWithoutUserInput>
    create: XOR<SubscriptionCreateWithoutUserInput, SubscriptionUncheckedCreateWithoutUserInput>
  }

  export type SubscriptionUpdateWithWhereUniqueWithoutUserInput = {
    where: SubscriptionWhereUniqueInput
    data: XOR<SubscriptionUpdateWithoutUserInput, SubscriptionUncheckedUpdateWithoutUserInput>
  }

  export type SubscriptionUpdateManyWithWhereWithoutUserInput = {
    where: SubscriptionScalarWhereInput
    data: XOR<SubscriptionUpdateManyMutationInput, SubscriptionUncheckedUpdateManyWithoutUserInput>
  }

  export type SubscriptionScalarWhereInput = {
    AND?: SubscriptionScalarWhereInput | SubscriptionScalarWhereInput[]
    OR?: SubscriptionScalarWhereInput[]
    NOT?: SubscriptionScalarWhereInput | SubscriptionScalarWhereInput[]
    createdAt?: DateTimeFilter<"Subscription"> | Date | string
    expiresAt?: DateTimeFilter<"Subscription"> | Date | string
    id?: StringFilter<"Subscription"> | string
    price?: FloatNullableFilter<"Subscription"> | number | null
    updatedAt?: DateTimeFilter<"Subscription"> | Date | string
    userId?: StringFilter<"Subscription"> | string
  }

  export type TagUpsertWithWhereUniqueWithoutUserInput = {
    where: TagWhereUniqueInput
    update: XOR<TagUpdateWithoutUserInput, TagUncheckedUpdateWithoutUserInput>
    create: XOR<TagCreateWithoutUserInput, TagUncheckedCreateWithoutUserInput>
  }

  export type TagUpdateWithWhereUniqueWithoutUserInput = {
    where: TagWhereUniqueInput
    data: XOR<TagUpdateWithoutUserInput, TagUncheckedUpdateWithoutUserInput>
  }

  export type TagUpdateManyWithWhereWithoutUserInput = {
    where: TagScalarWhereInput
    data: XOR<TagUpdateManyMutationInput, TagUncheckedUpdateManyWithoutUserInput>
  }

  export type SymbolProfileUpsertWithWhereUniqueWithoutWatchedByInput = {
    where: SymbolProfileWhereUniqueInput
    update: XOR<SymbolProfileUpdateWithoutWatchedByInput, SymbolProfileUncheckedUpdateWithoutWatchedByInput>
    create: XOR<SymbolProfileCreateWithoutWatchedByInput, SymbolProfileUncheckedCreateWithoutWatchedByInput>
  }

  export type SymbolProfileUpdateWithWhereUniqueWithoutWatchedByInput = {
    where: SymbolProfileWhereUniqueInput
    data: XOR<SymbolProfileUpdateWithoutWatchedByInput, SymbolProfileUncheckedUpdateWithoutWatchedByInput>
  }

  export type SymbolProfileUpdateManyWithWhereWithoutWatchedByInput = {
    where: SymbolProfileScalarWhereInput
    data: XOR<SymbolProfileUpdateManyMutationInput, SymbolProfileUncheckedUpdateManyWithoutWatchedByInput>
  }

  export type SymbolProfileScalarWhereInput = {
    AND?: SymbolProfileScalarWhereInput | SymbolProfileScalarWhereInput[]
    OR?: SymbolProfileScalarWhereInput[]
    NOT?: SymbolProfileScalarWhereInput | SymbolProfileScalarWhereInput[]
    assetClass?: EnumAssetClassNullableFilter<"SymbolProfile"> | $Enums.AssetClass | null
    assetSubClass?: EnumAssetSubClassNullableFilter<"SymbolProfile"> | $Enums.AssetSubClass | null
    comment?: StringNullableFilter<"SymbolProfile"> | string | null
    countries?: JsonNullableFilter<"SymbolProfile">
    createdAt?: DateTimeFilter<"SymbolProfile"> | Date | string
    currency?: StringFilter<"SymbolProfile"> | string
    cusip?: StringNullableFilter<"SymbolProfile"> | string | null
    dataSource?: EnumDataSourceFilter<"SymbolProfile"> | $Enums.DataSource
    figi?: StringNullableFilter<"SymbolProfile"> | string | null
    figiComposite?: StringNullableFilter<"SymbolProfile"> | string | null
    figiShareClass?: StringNullableFilter<"SymbolProfile"> | string | null
    holdings?: JsonNullableFilter<"SymbolProfile">
    id?: StringFilter<"SymbolProfile"> | string
    isActive?: BoolFilter<"SymbolProfile"> | boolean
    isin?: StringNullableFilter<"SymbolProfile"> | string | null
    name?: StringNullableFilter<"SymbolProfile"> | string | null
    updatedAt?: DateTimeFilter<"SymbolProfile"> | Date | string
    scraperConfiguration?: JsonNullableFilter<"SymbolProfile">
    sectors?: JsonNullableFilter<"SymbolProfile">
    symbol?: StringFilter<"SymbolProfile"> | string
    symbolMapping?: JsonNullableFilter<"SymbolProfile">
    url?: StringNullableFilter<"SymbolProfile"> | string | null
    userId?: StringNullableFilter<"SymbolProfile"> | string | null
  }

  export type SymbolProfileUpsertWithWhereUniqueWithoutUserInput = {
    where: SymbolProfileWhereUniqueInput
    update: XOR<SymbolProfileUpdateWithoutUserInput, SymbolProfileUncheckedUpdateWithoutUserInput>
    create: XOR<SymbolProfileCreateWithoutUserInput, SymbolProfileUncheckedCreateWithoutUserInput>
  }

  export type SymbolProfileUpdateWithWhereUniqueWithoutUserInput = {
    where: SymbolProfileWhereUniqueInput
    data: XOR<SymbolProfileUpdateWithoutUserInput, SymbolProfileUncheckedUpdateWithoutUserInput>
  }

  export type SymbolProfileUpdateManyWithWhereWithoutUserInput = {
    where: SymbolProfileScalarWhereInput
    data: XOR<SymbolProfileUpdateManyMutationInput, SymbolProfileUncheckedUpdateManyWithoutUserInput>
  }

  export type OrderCreateManyAccountInput = {
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    symbolProfileId: string
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    userId: string
  }

  export type AccountBalanceCreateManyAccountInput = {
    createdAt?: Date | string
    date?: Date | string
    id?: string
    updatedAt?: Date | string
    value: number
  }

  export type OrderUpdateWithoutAccountInput = {
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tags?: TagUpdateManyWithoutActivitiesNestedInput
    user?: UserUpdateOneRequiredWithoutActivitiesNestedInput
    SymbolProfile?: SymbolProfileUpdateOneRequiredWithoutActivitiesNestedInput
  }

  export type OrderUncheckedUpdateWithoutAccountInput = {
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    symbolProfileId?: StringFieldUpdateOperationsInput | string
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    tags?: TagUncheckedUpdateManyWithoutActivitiesNestedInput
  }

  export type OrderUncheckedUpdateManyWithoutAccountInput = {
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    symbolProfileId?: StringFieldUpdateOperationsInput | string
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AccountBalanceUpdateWithoutAccountInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    value?: FloatFieldUpdateOperationsInput | number
  }

  export type AccountBalanceUncheckedUpdateWithoutAccountInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    value?: FloatFieldUpdateOperationsInput | number
  }

  export type AccountBalanceUncheckedUpdateManyWithoutAccountInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    value?: FloatFieldUpdateOperationsInput | number
  }

  export type TagUpdateWithoutActivitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    user?: UserUpdateOneWithoutTagsNestedInput
  }

  export type TagUncheckedUpdateWithoutActivitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type TagUncheckedUpdateManyWithoutActivitiesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AccountCreateManyPlatformInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    updatedAt?: Date | string
    userId: string
  }

  export type AccountUpdateWithoutPlatformInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    activities?: OrderUpdateManyWithoutAccountNestedInput
    balances?: AccountBalanceUpdateManyWithoutAccountNestedInput
    user?: UserUpdateOneRequiredWithoutAccountsNestedInput
  }

  export type AccountUncheckedUpdateWithoutPlatformInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    activities?: OrderUncheckedUpdateManyWithoutAccountNestedInput
    balances?: AccountBalanceUncheckedUpdateManyWithoutAccountNestedInput
  }

  export type AccountUncheckedUpdateManyWithoutPlatformInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type OrderCreateManySymbolProfileInput = {
    accountId?: string | null
    accountUserId?: string | null
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
    userId: string
  }

  export type OrderUpdateWithoutSymbolProfileInput = {
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    account?: AccountUpdateOneWithoutActivitiesNestedInput
    tags?: TagUpdateManyWithoutActivitiesNestedInput
    user?: UserUpdateOneRequiredWithoutActivitiesNestedInput
  }

  export type OrderUncheckedUpdateWithoutSymbolProfileInput = {
    accountId?: NullableStringFieldUpdateOperationsInput | string | null
    accountUserId?: NullableStringFieldUpdateOperationsInput | string | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
    tags?: TagUncheckedUpdateManyWithoutActivitiesNestedInput
  }

  export type OrderUncheckedUpdateManyWithoutSymbolProfileInput = {
    accountId?: NullableStringFieldUpdateOperationsInput | string | null
    accountUserId?: NullableStringFieldUpdateOperationsInput | string | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type UserUpdateWithoutWatchlistInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUpdateManyWithoutUserNestedInput
    accounts?: AccountUpdateManyWithoutUserNestedInput
    activities?: OrderUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUpdateManyWithoutUserNestedInput
    settings?: SettingsUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUpdateManyWithoutUserNestedInput
    tags?: TagUpdateManyWithoutUserNestedInput
    SymbolProfile?: SymbolProfileUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutWatchlistInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    accessesGet?: AccessUncheckedUpdateManyWithoutGranteeUserNestedInput
    accessesGive?: AccessUncheckedUpdateManyWithoutUserNestedInput
    accounts?: AccountUncheckedUpdateManyWithoutUserNestedInput
    activities?: OrderUncheckedUpdateManyWithoutUserNestedInput
    analytics?: AnalyticsUncheckedUpdateOneWithoutUserNestedInput
    apiKeys?: ApiKeyUncheckedUpdateManyWithoutUserNestedInput
    authDevices?: AuthDeviceUncheckedUpdateManyWithoutUserNestedInput
    settings?: SettingsUncheckedUpdateOneWithoutUserNestedInput
    subscriptions?: SubscriptionUncheckedUpdateManyWithoutUserNestedInput
    tags?: TagUncheckedUpdateManyWithoutUserNestedInput
    SymbolProfile?: SymbolProfileUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateManyWithoutWatchlistInput = {
    accessToken?: NullableStringFieldUpdateOperationsInput | string | null
    authChallenge?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    provider?: EnumProviderFieldUpdateOperationsInput | $Enums.Provider
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    thirdPartyId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OrderUpdateWithoutTagsInput = {
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    account?: AccountUpdateOneWithoutActivitiesNestedInput
    user?: UserUpdateOneRequiredWithoutActivitiesNestedInput
    SymbolProfile?: SymbolProfileUpdateOneRequiredWithoutActivitiesNestedInput
  }

  export type OrderUncheckedUpdateWithoutTagsInput = {
    accountId?: NullableStringFieldUpdateOperationsInput | string | null
    accountUserId?: NullableStringFieldUpdateOperationsInput | string | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    symbolProfileId?: StringFieldUpdateOperationsInput | string
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type OrderUncheckedUpdateManyWithoutTagsInput = {
    accountId?: NullableStringFieldUpdateOperationsInput | string | null
    accountUserId?: NullableStringFieldUpdateOperationsInput | string | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    symbolProfileId?: StringFieldUpdateOperationsInput | string
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AccessCreateManyGranteeUserInput = {
    alias?: string | null
    createdAt?: Date | string
    id?: string
    permissions?: AccessCreatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
    userId: string
  }

  export type AccessCreateManyUserInput = {
    alias?: string | null
    createdAt?: Date | string
    granteeUserId?: string | null
    id?: string
    permissions?: AccessCreatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
  }

  export type AccountCreateManyUserInput = {
    balance?: number
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    id?: string
    isExcluded?: boolean
    name?: string | null
    platformId?: string | null
    updatedAt?: Date | string
  }

  export type OrderCreateManyUserInput = {
    accountId?: string | null
    accountUserId?: string | null
    comment?: string | null
    createdAt?: Date | string
    currency?: string | null
    date: Date | string
    fee: number
    id?: string
    isDraft?: boolean
    quantity: number
    symbolProfileId: string
    type: $Enums.Type
    unitPrice: number
    updatedAt?: Date | string
  }

  export type ApiKeyCreateManyUserInput = {
    createdAt?: Date | string
    hashedKey: string
    id?: string
    updatedAt?: Date | string
  }

  export type AuthDeviceCreateManyUserInput = {
    createdAt?: Date | string
    credentialId: Bytes
    credentialPublicKey: Bytes
    counter: number
    id?: string
    updatedAt?: Date | string
  }

  export type SubscriptionCreateManyUserInput = {
    createdAt?: Date | string
    expiresAt: Date | string
    id?: string
    price?: number | null
    updatedAt?: Date | string
  }

  export type TagCreateManyUserInput = {
    id?: string
    name: string
  }

  export type SymbolProfileCreateManyUserInput = {
    assetClass?: $Enums.AssetClass | null
    assetSubClass?: $Enums.AssetSubClass | null
    comment?: string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: Date | string
    currency: string
    cusip?: string | null
    dataSource: $Enums.DataSource
    figi?: string | null
    figiComposite?: string | null
    figiShareClass?: string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: string
    isActive?: boolean
    isin?: string | null
    name?: string | null
    updatedAt?: Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol: string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: string | null
  }

  export type AccessUpdateWithoutGranteeUserInput = {
    alias?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    permissions?: AccessUpdatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    user?: UserUpdateOneRequiredWithoutAccessesGiveNestedInput
  }

  export type AccessUncheckedUpdateWithoutGranteeUserInput = {
    alias?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    permissions?: AccessUpdatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AccessUncheckedUpdateManyWithoutGranteeUserInput = {
    alias?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    permissions?: AccessUpdatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    userId?: StringFieldUpdateOperationsInput | string
  }

  export type AccessUpdateWithoutUserInput = {
    alias?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    permissions?: AccessUpdatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    granteeUser?: UserUpdateOneWithoutAccessesGetNestedInput
  }

  export type AccessUncheckedUpdateWithoutUserInput = {
    alias?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    granteeUserId?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    permissions?: AccessUpdatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccessUncheckedUpdateManyWithoutUserInput = {
    alias?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    granteeUserId?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    permissions?: AccessUpdatepermissionsInput | $Enums.AccessPermission[]
    settings?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AccountUpdateWithoutUserInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    activities?: OrderUpdateManyWithoutAccountNestedInput
    balances?: AccountBalanceUpdateManyWithoutAccountNestedInput
    platform?: PlatformUpdateOneWithoutAccountsNestedInput
  }

  export type AccountUncheckedUpdateWithoutUserInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    platformId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    activities?: OrderUncheckedUpdateManyWithoutAccountNestedInput
    balances?: AccountBalanceUncheckedUpdateManyWithoutAccountNestedInput
  }

  export type AccountUncheckedUpdateManyWithoutUserInput = {
    balance?: FloatFieldUpdateOperationsInput | number
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    id?: StringFieldUpdateOperationsInput | string
    isExcluded?: BoolFieldUpdateOperationsInput | boolean
    name?: NullableStringFieldUpdateOperationsInput | string | null
    platformId?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OrderUpdateWithoutUserInput = {
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    account?: AccountUpdateOneWithoutActivitiesNestedInput
    tags?: TagUpdateManyWithoutActivitiesNestedInput
    SymbolProfile?: SymbolProfileUpdateOneRequiredWithoutActivitiesNestedInput
  }

  export type OrderUncheckedUpdateWithoutUserInput = {
    accountId?: NullableStringFieldUpdateOperationsInput | string | null
    accountUserId?: NullableStringFieldUpdateOperationsInput | string | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    symbolProfileId?: StringFieldUpdateOperationsInput | string
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    tags?: TagUncheckedUpdateManyWithoutActivitiesNestedInput
  }

  export type OrderUncheckedUpdateManyWithoutUserInput = {
    accountId?: NullableStringFieldUpdateOperationsInput | string | null
    accountUserId?: NullableStringFieldUpdateOperationsInput | string | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: NullableStringFieldUpdateOperationsInput | string | null
    date?: DateTimeFieldUpdateOperationsInput | Date | string
    fee?: FloatFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    isDraft?: BoolFieldUpdateOperationsInput | boolean
    quantity?: FloatFieldUpdateOperationsInput | number
    symbolProfileId?: StringFieldUpdateOperationsInput | string
    type?: EnumTypeFieldUpdateOperationsInput | $Enums.Type
    unitPrice?: FloatFieldUpdateOperationsInput | number
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ApiKeyUpdateWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    hashedKey?: StringFieldUpdateOperationsInput | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ApiKeyUncheckedUpdateWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    hashedKey?: StringFieldUpdateOperationsInput | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ApiKeyUncheckedUpdateManyWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    hashedKey?: StringFieldUpdateOperationsInput | string
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AuthDeviceUpdateWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    credentialId?: BytesFieldUpdateOperationsInput | Bytes
    credentialPublicKey?: BytesFieldUpdateOperationsInput | Bytes
    counter?: IntFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AuthDeviceUncheckedUpdateWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    credentialId?: BytesFieldUpdateOperationsInput | Bytes
    credentialPublicKey?: BytesFieldUpdateOperationsInput | Bytes
    counter?: IntFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AuthDeviceUncheckedUpdateManyWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    credentialId?: BytesFieldUpdateOperationsInput | Bytes
    credentialPublicKey?: BytesFieldUpdateOperationsInput | Bytes
    counter?: IntFieldUpdateOperationsInput | number
    id?: StringFieldUpdateOperationsInput | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscriptionUpdateWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    price?: NullableFloatFieldUpdateOperationsInput | number | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscriptionUncheckedUpdateWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    price?: NullableFloatFieldUpdateOperationsInput | number | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscriptionUncheckedUpdateManyWithoutUserInput = {
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    id?: StringFieldUpdateOperationsInput | string
    price?: NullableFloatFieldUpdateOperationsInput | number | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TagUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activities?: OrderUpdateManyWithoutTagsNestedInput
  }

  export type TagUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    activities?: OrderUncheckedUpdateManyWithoutTagsNestedInput
  }

  export type TagUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
  }

  export type SymbolProfileUpdateWithoutWatchedByInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    activities?: OrderUpdateManyWithoutSymbolProfileNestedInput
    user?: UserUpdateOneWithoutSymbolProfileNestedInput
    SymbolProfileOverrides?: SymbolProfileOverridesUpdateOneWithoutSymbolProfileNestedInput
  }

  export type SymbolProfileUncheckedUpdateWithoutWatchedByInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    userId?: NullableStringFieldUpdateOperationsInput | string | null
    activities?: OrderUncheckedUpdateManyWithoutSymbolProfileNestedInput
    SymbolProfileOverrides?: SymbolProfileOverridesUncheckedUpdateOneWithoutSymbolProfileNestedInput
  }

  export type SymbolProfileUncheckedUpdateManyWithoutWatchedByInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    userId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SymbolProfileUpdateWithoutUserInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    activities?: OrderUpdateManyWithoutSymbolProfileNestedInput
    watchedBy?: UserUpdateManyWithoutWatchlistNestedInput
    SymbolProfileOverrides?: SymbolProfileOverridesUpdateOneWithoutSymbolProfileNestedInput
  }

  export type SymbolProfileUncheckedUpdateWithoutUserInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
    activities?: OrderUncheckedUpdateManyWithoutSymbolProfileNestedInput
    watchedBy?: UserUncheckedUpdateManyWithoutWatchlistNestedInput
    SymbolProfileOverrides?: SymbolProfileOverridesUncheckedUpdateOneWithoutSymbolProfileNestedInput
  }

  export type SymbolProfileUncheckedUpdateManyWithoutUserInput = {
    assetClass?: NullableEnumAssetClassFieldUpdateOperationsInput | $Enums.AssetClass | null
    assetSubClass?: NullableEnumAssetSubClassFieldUpdateOperationsInput | $Enums.AssetSubClass | null
    comment?: NullableStringFieldUpdateOperationsInput | string | null
    countries?: NullableJsonNullValueInput | InputJsonValue
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    currency?: StringFieldUpdateOperationsInput | string
    cusip?: NullableStringFieldUpdateOperationsInput | string | null
    dataSource?: EnumDataSourceFieldUpdateOperationsInput | $Enums.DataSource
    figi?: NullableStringFieldUpdateOperationsInput | string | null
    figiComposite?: NullableStringFieldUpdateOperationsInput | string | null
    figiShareClass?: NullableStringFieldUpdateOperationsInput | string | null
    holdings?: NullableJsonNullValueInput | InputJsonValue
    id?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isin?: NullableStringFieldUpdateOperationsInput | string | null
    name?: NullableStringFieldUpdateOperationsInput | string | null
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    scraperConfiguration?: NullableJsonNullValueInput | InputJsonValue
    sectors?: NullableJsonNullValueInput | InputJsonValue
    symbol?: StringFieldUpdateOperationsInput | string
    symbolMapping?: NullableJsonNullValueInput | InputJsonValue
    url?: NullableStringFieldUpdateOperationsInput | string | null
  }



  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}