Clara Zetkin
19016 lines
676 KiB
TypeScript
19016 lines
676 KiB
TypeScript
|
|
/**
|
|
* 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 Unit
|
|
*
|
|
*/
|
|
export type Unit = $Result.DefaultSelection<Prisma.$UnitPayload>
|
|
/**
|
|
* Model Person
|
|
*
|
|
*/
|
|
export type Person = $Result.DefaultSelection<Prisma.$PersonPayload>
|
|
/**
|
|
* Model Group
|
|
*
|
|
*/
|
|
export type Group = $Result.DefaultSelection<Prisma.$GroupPayload>
|
|
/**
|
|
* Model GroupMembership
|
|
*
|
|
*/
|
|
export type GroupMembership = $Result.DefaultSelection<Prisma.$GroupMembershipPayload>
|
|
/**
|
|
* Model Event
|
|
*
|
|
*/
|
|
export type Event = $Result.DefaultSelection<Prisma.$EventPayload>
|
|
/**
|
|
* Model cities
|
|
* This model or at least one of its fields has comments in the database, and requires an additional setup for migrations: Read more: https://pris.ly/d/database-comments
|
|
*/
|
|
export type cities = $Result.DefaultSelection<Prisma.$citiesPayload>
|
|
/**
|
|
* Model countries
|
|
* This model or at least one of its fields has comments in the database, and requires an additional setup for migrations: Read more: https://pris.ly/d/database-comments
|
|
*/
|
|
export type countries = $Result.DefaultSelection<Prisma.$countriesPayload>
|
|
/**
|
|
* Model states
|
|
* This model or at least one of its fields has comments in the database, and requires an additional setup for migrations: Read more: https://pris.ly/d/database-comments
|
|
*/
|
|
export type states = $Result.DefaultSelection<Prisma.$statesPayload>
|
|
/**
|
|
* Model Address
|
|
*
|
|
*/
|
|
export type Address = $Result.DefaultSelection<Prisma.$AddressPayload>
|
|
/**
|
|
* Model VaultData
|
|
*
|
|
*/
|
|
export type VaultData = $Result.DefaultSelection<Prisma.$VaultDataPayload>
|
|
|
|
/**
|
|
* ## Prisma Client ʲˢ
|
|
*
|
|
* Type-safe database client for TypeScript & Node.js
|
|
* @example
|
|
* ```
|
|
* const prisma = new PrismaClient()
|
|
* // Fetch zero or more Units
|
|
* const units = await prisma.unit.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 Units
|
|
* const units = await prisma.unit.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.unit`: Exposes CRUD operations for the **Unit** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Units
|
|
* const units = await prisma.unit.findMany()
|
|
* ```
|
|
*/
|
|
get unit(): Prisma.UnitDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.person`: Exposes CRUD operations for the **Person** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more People
|
|
* const people = await prisma.person.findMany()
|
|
* ```
|
|
*/
|
|
get person(): Prisma.PersonDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.group`: Exposes CRUD operations for the **Group** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Groups
|
|
* const groups = await prisma.group.findMany()
|
|
* ```
|
|
*/
|
|
get group(): Prisma.GroupDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.groupMembership`: Exposes CRUD operations for the **GroupMembership** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more GroupMemberships
|
|
* const groupMemberships = await prisma.groupMembership.findMany()
|
|
* ```
|
|
*/
|
|
get groupMembership(): Prisma.GroupMembershipDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.event`: Exposes CRUD operations for the **Event** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Events
|
|
* const events = await prisma.event.findMany()
|
|
* ```
|
|
*/
|
|
get event(): Prisma.EventDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.cities`: Exposes CRUD operations for the **cities** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Cities
|
|
* const cities = await prisma.cities.findMany()
|
|
* ```
|
|
*/
|
|
get cities(): Prisma.citiesDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.countries`: Exposes CRUD operations for the **countries** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Countries
|
|
* const countries = await prisma.countries.findMany()
|
|
* ```
|
|
*/
|
|
get countries(): Prisma.countriesDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.states`: Exposes CRUD operations for the **states** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more States
|
|
* const states = await prisma.states.findMany()
|
|
* ```
|
|
*/
|
|
get states(): Prisma.statesDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.address`: Exposes CRUD operations for the **Address** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more Addresses
|
|
* const addresses = await prisma.address.findMany()
|
|
* ```
|
|
*/
|
|
get address(): Prisma.AddressDelegate<ExtArgs, ClientOptions>;
|
|
|
|
/**
|
|
* `prisma.vaultData`: Exposes CRUD operations for the **VaultData** model.
|
|
* Example usage:
|
|
* ```ts
|
|
* // Fetch zero or more VaultData
|
|
* const vaultData = await prisma.vaultData.findMany()
|
|
* ```
|
|
*/
|
|
get vaultData(): Prisma.VaultDataDelegate<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.3
|
|
* Query Engine version: a9055b89e58b4b5bfb59600785423b1db3d0e75d
|
|
*/
|
|
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: {
|
|
Unit: 'Unit',
|
|
Person: 'Person',
|
|
Group: 'Group',
|
|
GroupMembership: 'GroupMembership',
|
|
Event: 'Event',
|
|
cities: 'cities',
|
|
countries: 'countries',
|
|
states: 'states',
|
|
Address: 'Address',
|
|
VaultData: 'VaultData'
|
|
};
|
|
|
|
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: "unit" | "person" | "group" | "groupMembership" | "event" | "cities" | "countries" | "states" | "address" | "vaultData"
|
|
txIsolationLevel: Prisma.TransactionIsolationLevel
|
|
}
|
|
model: {
|
|
Unit: {
|
|
payload: Prisma.$UnitPayload<ExtArgs>
|
|
fields: Prisma.UnitFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.UnitFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.UnitFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.UnitFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.UnitFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.UnitFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.UnitCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.UnitCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.UnitCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.UnitDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.UnitUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.UnitDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.UnitUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.UnitUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.UnitUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$UnitPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.UnitAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateUnit>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.UnitGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<UnitGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.UnitCountArgs<ExtArgs>
|
|
result: $Utils.Optional<UnitCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Person: {
|
|
payload: Prisma.$PersonPayload<ExtArgs>
|
|
fields: Prisma.PersonFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.PersonFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.PersonFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.PersonFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.PersonFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.PersonFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.PersonCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.PersonCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.PersonCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.PersonDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.PersonUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.PersonDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.PersonUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.PersonUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.PersonUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$PersonPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.PersonAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregatePerson>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.PersonGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<PersonGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.PersonCountArgs<ExtArgs>
|
|
result: $Utils.Optional<PersonCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Group: {
|
|
payload: Prisma.$GroupPayload<ExtArgs>
|
|
fields: Prisma.GroupFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.GroupFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.GroupFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.GroupFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.GroupFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.GroupFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.GroupCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.GroupCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.GroupCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.GroupDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.GroupUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.GroupDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.GroupUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.GroupUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.GroupUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.GroupAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateGroup>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.GroupGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<GroupGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.GroupCountArgs<ExtArgs>
|
|
result: $Utils.Optional<GroupCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
GroupMembership: {
|
|
payload: Prisma.$GroupMembershipPayload<ExtArgs>
|
|
fields: Prisma.GroupMembershipFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.GroupMembershipFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.GroupMembershipFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.GroupMembershipFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.GroupMembershipFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.GroupMembershipFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.GroupMembershipCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.GroupMembershipCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.GroupMembershipCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.GroupMembershipDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.GroupMembershipUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.GroupMembershipDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.GroupMembershipUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.GroupMembershipUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.GroupMembershipUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$GroupMembershipPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.GroupMembershipAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateGroupMembership>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.GroupMembershipGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<GroupMembershipGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.GroupMembershipCountArgs<ExtArgs>
|
|
result: $Utils.Optional<GroupMembershipCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Event: {
|
|
payload: Prisma.$EventPayload<ExtArgs>
|
|
fields: Prisma.EventFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.EventFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.EventFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.EventFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.EventFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.EventFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.EventCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.EventCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.EventCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.EventDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.EventUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.EventDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.EventUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.EventUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.EventUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$EventPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.EventAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateEvent>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.EventGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<EventGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.EventCountArgs<ExtArgs>
|
|
result: $Utils.Optional<EventCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
cities: {
|
|
payload: Prisma.$citiesPayload<ExtArgs>
|
|
fields: Prisma.citiesFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.citiesFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.citiesFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.citiesFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.citiesFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.citiesFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.citiesCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.citiesCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.citiesCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.citiesDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.citiesUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.citiesDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.citiesUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.citiesUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.citiesUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$citiesPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.CitiesAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateCities>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.citiesGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<CitiesGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.citiesCountArgs<ExtArgs>
|
|
result: $Utils.Optional<CitiesCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
countries: {
|
|
payload: Prisma.$countriesPayload<ExtArgs>
|
|
fields: Prisma.countriesFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.countriesFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.countriesFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.countriesFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.countriesFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.countriesFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.countriesCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.countriesCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.countriesCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.countriesDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.countriesUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.countriesDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.countriesUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.countriesUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.countriesUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$countriesPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.CountriesAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateCountries>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.countriesGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<CountriesGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.countriesCountArgs<ExtArgs>
|
|
result: $Utils.Optional<CountriesCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
states: {
|
|
payload: Prisma.$statesPayload<ExtArgs>
|
|
fields: Prisma.statesFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.statesFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.statesFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.statesFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.statesFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.statesFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.statesCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.statesCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.statesCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.statesDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.statesUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.statesDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.statesUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.statesUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.statesUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$statesPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.StatesAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateStates>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.statesGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<StatesGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.statesCountArgs<ExtArgs>
|
|
result: $Utils.Optional<StatesCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
Address: {
|
|
payload: Prisma.$AddressPayload<ExtArgs>
|
|
fields: Prisma.AddressFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.AddressFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.AddressFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.AddressFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.AddressFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.AddressFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.AddressCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.AddressCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.AddressCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.AddressDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.AddressUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.AddressDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.AddressUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.AddressUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.AddressUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$AddressPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.AddressAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateAddress>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.AddressGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<AddressGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.AddressCountArgs<ExtArgs>
|
|
result: $Utils.Optional<AddressCountAggregateOutputType> | number
|
|
}
|
|
}
|
|
}
|
|
VaultData: {
|
|
payload: Prisma.$VaultDataPayload<ExtArgs>
|
|
fields: Prisma.VaultDataFieldRefs
|
|
operations: {
|
|
findUnique: {
|
|
args: Prisma.VaultDataFindUniqueArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload> | null
|
|
}
|
|
findUniqueOrThrow: {
|
|
args: Prisma.VaultDataFindUniqueOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload>
|
|
}
|
|
findFirst: {
|
|
args: Prisma.VaultDataFindFirstArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload> | null
|
|
}
|
|
findFirstOrThrow: {
|
|
args: Prisma.VaultDataFindFirstOrThrowArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload>
|
|
}
|
|
findMany: {
|
|
args: Prisma.VaultDataFindManyArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload>[]
|
|
}
|
|
create: {
|
|
args: Prisma.VaultDataCreateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload>
|
|
}
|
|
createMany: {
|
|
args: Prisma.VaultDataCreateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
createManyAndReturn: {
|
|
args: Prisma.VaultDataCreateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload>[]
|
|
}
|
|
delete: {
|
|
args: Prisma.VaultDataDeleteArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload>
|
|
}
|
|
update: {
|
|
args: Prisma.VaultDataUpdateArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload>
|
|
}
|
|
deleteMany: {
|
|
args: Prisma.VaultDataDeleteManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateMany: {
|
|
args: Prisma.VaultDataUpdateManyArgs<ExtArgs>
|
|
result: BatchPayload
|
|
}
|
|
updateManyAndReturn: {
|
|
args: Prisma.VaultDataUpdateManyAndReturnArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload>[]
|
|
}
|
|
upsert: {
|
|
args: Prisma.VaultDataUpsertArgs<ExtArgs>
|
|
result: $Utils.PayloadToResult<Prisma.$VaultDataPayload>
|
|
}
|
|
aggregate: {
|
|
args: Prisma.VaultDataAggregateArgs<ExtArgs>
|
|
result: $Utils.Optional<AggregateVaultData>
|
|
}
|
|
groupBy: {
|
|
args: Prisma.VaultDataGroupByArgs<ExtArgs>
|
|
result: $Utils.Optional<VaultDataGroupByOutputType>[]
|
|
}
|
|
count: {
|
|
args: Prisma.VaultDataCountArgs<ExtArgs>
|
|
result: $Utils.Optional<VaultDataCountAggregateOutputType> | 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 = {
|
|
unit?: UnitOmit
|
|
person?: PersonOmit
|
|
group?: GroupOmit
|
|
groupMembership?: GroupMembershipOmit
|
|
event?: EventOmit
|
|
cities?: citiesOmit
|
|
countries?: countriesOmit
|
|
states?: statesOmit
|
|
address?: AddressOmit
|
|
vaultData?: VaultDataOmit
|
|
}
|
|
|
|
/* 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 UnitCountOutputType
|
|
*/
|
|
|
|
export type UnitCountOutputType = {
|
|
children: number
|
|
}
|
|
|
|
export type UnitCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
children?: boolean | UnitCountOutputTypeCountChildrenArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* UnitCountOutputType without action
|
|
*/
|
|
export type UnitCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the UnitCountOutputType
|
|
*/
|
|
select?: UnitCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* UnitCountOutputType without action
|
|
*/
|
|
export type UnitCountOutputTypeCountChildrenArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UnitWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type PersonCountOutputType
|
|
*/
|
|
|
|
export type PersonCountOutputType = {
|
|
groupMemberships: number
|
|
}
|
|
|
|
export type PersonCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
groupMemberships?: boolean | PersonCountOutputTypeCountGroupMembershipsArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* PersonCountOutputType without action
|
|
*/
|
|
export type PersonCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the PersonCountOutputType
|
|
*/
|
|
select?: PersonCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* PersonCountOutputType without action
|
|
*/
|
|
export type PersonCountOutputTypeCountGroupMembershipsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: GroupMembershipWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type GroupCountOutputType
|
|
*/
|
|
|
|
export type GroupCountOutputType = {
|
|
members: number
|
|
}
|
|
|
|
export type GroupCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
members?: boolean | GroupCountOutputTypeCountMembersArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* GroupCountOutputType without action
|
|
*/
|
|
export type GroupCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupCountOutputType
|
|
*/
|
|
select?: GroupCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* GroupCountOutputType without action
|
|
*/
|
|
export type GroupCountOutputTypeCountMembersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: GroupMembershipWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type CountriesCountOutputType
|
|
*/
|
|
|
|
export type CountriesCountOutputType = {
|
|
cities: number
|
|
states: number
|
|
}
|
|
|
|
export type CountriesCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
cities?: boolean | CountriesCountOutputTypeCountCitiesArgs
|
|
states?: boolean | CountriesCountOutputTypeCountStatesArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* CountriesCountOutputType without action
|
|
*/
|
|
export type CountriesCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the CountriesCountOutputType
|
|
*/
|
|
select?: CountriesCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* CountriesCountOutputType without action
|
|
*/
|
|
export type CountriesCountOutputTypeCountCitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: citiesWhereInput
|
|
}
|
|
|
|
/**
|
|
* CountriesCountOutputType without action
|
|
*/
|
|
export type CountriesCountOutputTypeCountStatesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: statesWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Count Type StatesCountOutputType
|
|
*/
|
|
|
|
export type StatesCountOutputType = {
|
|
cities: number
|
|
}
|
|
|
|
export type StatesCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
cities?: boolean | StatesCountOutputTypeCountCitiesArgs
|
|
}
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* StatesCountOutputType without action
|
|
*/
|
|
export type StatesCountOutputTypeDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the StatesCountOutputType
|
|
*/
|
|
select?: StatesCountOutputTypeSelect<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* StatesCountOutputType without action
|
|
*/
|
|
export type StatesCountOutputTypeCountCitiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: citiesWhereInput
|
|
}
|
|
|
|
|
|
/**
|
|
* Models
|
|
*/
|
|
|
|
/**
|
|
* Model Unit
|
|
*/
|
|
|
|
export type AggregateUnit = {
|
|
_count: UnitCountAggregateOutputType | null
|
|
_min: UnitMinAggregateOutputType | null
|
|
_max: UnitMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type UnitMinAggregateOutputType = {
|
|
id: string | null
|
|
name: string | null
|
|
description: string | null
|
|
parentId: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type UnitMaxAggregateOutputType = {
|
|
id: string | null
|
|
name: string | null
|
|
description: string | null
|
|
parentId: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type UnitCountAggregateOutputType = {
|
|
id: number
|
|
name: number
|
|
description: number
|
|
parentId: number
|
|
traits: number
|
|
createdAt: number
|
|
updatedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type UnitMinAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
description?: true
|
|
parentId?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type UnitMaxAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
description?: true
|
|
parentId?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type UnitCountAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
description?: true
|
|
parentId?: true
|
|
traits?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type UnitAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Unit to aggregate.
|
|
*/
|
|
where?: UnitWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Units to fetch.
|
|
*/
|
|
orderBy?: UnitOrderByWithRelationInput | UnitOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: UnitWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Units 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` Units.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Units
|
|
**/
|
|
_count?: true | UnitCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: UnitMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: UnitMaxAggregateInputType
|
|
}
|
|
|
|
export type GetUnitAggregateType<T extends UnitAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateUnit]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateUnit[P]>
|
|
: GetScalarType<T[P], AggregateUnit[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type UnitGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: UnitWhereInput
|
|
orderBy?: UnitOrderByWithAggregationInput | UnitOrderByWithAggregationInput[]
|
|
by: UnitScalarFieldEnum[] | UnitScalarFieldEnum
|
|
having?: UnitScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: UnitCountAggregateInputType | true
|
|
_min?: UnitMinAggregateInputType
|
|
_max?: UnitMaxAggregateInputType
|
|
}
|
|
|
|
export type UnitGroupByOutputType = {
|
|
id: string
|
|
name: string
|
|
description: string | null
|
|
parentId: string | null
|
|
traits: JsonValue
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
_count: UnitCountAggregateOutputType | null
|
|
_min: UnitMinAggregateOutputType | null
|
|
_max: UnitMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetUnitGroupByPayload<T extends UnitGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<UnitGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof UnitGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], UnitGroupByOutputType[P]>
|
|
: GetScalarType<T[P], UnitGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type UnitSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
description?: boolean
|
|
parentId?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
parent?: boolean | Unit$parentArgs<ExtArgs>
|
|
children?: boolean | Unit$childrenArgs<ExtArgs>
|
|
_count?: boolean | UnitCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["unit"]>
|
|
|
|
export type UnitSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
description?: boolean
|
|
parentId?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
parent?: boolean | Unit$parentArgs<ExtArgs>
|
|
}, ExtArgs["result"]["unit"]>
|
|
|
|
export type UnitSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
description?: boolean
|
|
parentId?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
parent?: boolean | Unit$parentArgs<ExtArgs>
|
|
}, ExtArgs["result"]["unit"]>
|
|
|
|
export type UnitSelectScalar = {
|
|
id?: boolean
|
|
name?: boolean
|
|
description?: boolean
|
|
parentId?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}
|
|
|
|
export type UnitOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "description" | "parentId" | "traits" | "createdAt" | "updatedAt", ExtArgs["result"]["unit"]>
|
|
export type UnitInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
parent?: boolean | Unit$parentArgs<ExtArgs>
|
|
children?: boolean | Unit$childrenArgs<ExtArgs>
|
|
_count?: boolean | UnitCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type UnitIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
parent?: boolean | Unit$parentArgs<ExtArgs>
|
|
}
|
|
export type UnitIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
parent?: boolean | Unit$parentArgs<ExtArgs>
|
|
}
|
|
|
|
export type $UnitPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Unit"
|
|
objects: {
|
|
parent: Prisma.$UnitPayload<ExtArgs> | null
|
|
children: Prisma.$UnitPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
name: string
|
|
description: string | null
|
|
parentId: string | null
|
|
traits: Prisma.JsonValue
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
}, ExtArgs["result"]["unit"]>
|
|
composites: {}
|
|
}
|
|
|
|
type UnitGetPayload<S extends boolean | null | undefined | UnitDefaultArgs> = $Result.GetResult<Prisma.$UnitPayload, S>
|
|
|
|
type UnitCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<UnitFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: UnitCountAggregateInputType | true
|
|
}
|
|
|
|
export interface UnitDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Unit'], meta: { name: 'Unit' } }
|
|
/**
|
|
* Find zero or one Unit that matches the filter.
|
|
* @param {UnitFindUniqueArgs} args - Arguments to find a Unit
|
|
* @example
|
|
* // Get one Unit
|
|
* const unit = await prisma.unit.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends UnitFindUniqueArgs>(args: SelectSubset<T, UnitFindUniqueArgs<ExtArgs>>): Prisma__UnitClient<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Unit that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {UnitFindUniqueOrThrowArgs} args - Arguments to find a Unit
|
|
* @example
|
|
* // Get one Unit
|
|
* const unit = await prisma.unit.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends UnitFindUniqueOrThrowArgs>(args: SelectSubset<T, UnitFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UnitClient<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Unit 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 {UnitFindFirstArgs} args - Arguments to find a Unit
|
|
* @example
|
|
* // Get one Unit
|
|
* const unit = await prisma.unit.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends UnitFindFirstArgs>(args?: SelectSubset<T, UnitFindFirstArgs<ExtArgs>>): Prisma__UnitClient<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Unit 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 {UnitFindFirstOrThrowArgs} args - Arguments to find a Unit
|
|
* @example
|
|
* // Get one Unit
|
|
* const unit = await prisma.unit.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends UnitFindFirstOrThrowArgs>(args?: SelectSubset<T, UnitFindFirstOrThrowArgs<ExtArgs>>): Prisma__UnitClient<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Units 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 {UnitFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Units
|
|
* const units = await prisma.unit.findMany()
|
|
*
|
|
* // Get first 10 Units
|
|
* const units = await prisma.unit.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const unitWithIdOnly = await prisma.unit.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends UnitFindManyArgs>(args?: SelectSubset<T, UnitFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Unit.
|
|
* @param {UnitCreateArgs} args - Arguments to create a Unit.
|
|
* @example
|
|
* // Create one Unit
|
|
* const Unit = await prisma.unit.create({
|
|
* data: {
|
|
* // ... data to create a Unit
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends UnitCreateArgs>(args: SelectSubset<T, UnitCreateArgs<ExtArgs>>): Prisma__UnitClient<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Units.
|
|
* @param {UnitCreateManyArgs} args - Arguments to create many Units.
|
|
* @example
|
|
* // Create many Units
|
|
* const unit = await prisma.unit.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends UnitCreateManyArgs>(args?: SelectSubset<T, UnitCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Units and returns the data saved in the database.
|
|
* @param {UnitCreateManyAndReturnArgs} args - Arguments to create many Units.
|
|
* @example
|
|
* // Create many Units
|
|
* const unit = await prisma.unit.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Units and only return the `id`
|
|
* const unitWithIdOnly = await prisma.unit.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 UnitCreateManyAndReturnArgs>(args?: SelectSubset<T, UnitCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Unit.
|
|
* @param {UnitDeleteArgs} args - Arguments to delete one Unit.
|
|
* @example
|
|
* // Delete one Unit
|
|
* const Unit = await prisma.unit.delete({
|
|
* where: {
|
|
* // ... filter to delete one Unit
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends UnitDeleteArgs>(args: SelectSubset<T, UnitDeleteArgs<ExtArgs>>): Prisma__UnitClient<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Unit.
|
|
* @param {UnitUpdateArgs} args - Arguments to update one Unit.
|
|
* @example
|
|
* // Update one Unit
|
|
* const unit = await prisma.unit.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends UnitUpdateArgs>(args: SelectSubset<T, UnitUpdateArgs<ExtArgs>>): Prisma__UnitClient<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Units.
|
|
* @param {UnitDeleteManyArgs} args - Arguments to filter Units to delete.
|
|
* @example
|
|
* // Delete a few Units
|
|
* const { count } = await prisma.unit.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends UnitDeleteManyArgs>(args?: SelectSubset<T, UnitDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Units.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UnitUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Units
|
|
* const unit = await prisma.unit.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends UnitUpdateManyArgs>(args: SelectSubset<T, UnitUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Units and returns the data updated in the database.
|
|
* @param {UnitUpdateManyAndReturnArgs} args - Arguments to update many Units.
|
|
* @example
|
|
* // Update many Units
|
|
* const unit = await prisma.unit.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Units and only return the `id`
|
|
* const unitWithIdOnly = await prisma.unit.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 UnitUpdateManyAndReturnArgs>(args: SelectSubset<T, UnitUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Unit.
|
|
* @param {UnitUpsertArgs} args - Arguments to update or create a Unit.
|
|
* @example
|
|
* // Update or create a Unit
|
|
* const unit = await prisma.unit.upsert({
|
|
* create: {
|
|
* // ... data to create a Unit
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Unit we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends UnitUpsertArgs>(args: SelectSubset<T, UnitUpsertArgs<ExtArgs>>): Prisma__UnitClient<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Units.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UnitCountArgs} args - Arguments to filter Units to count.
|
|
* @example
|
|
* // Count the number of Units
|
|
* const count = await prisma.unit.count({
|
|
* where: {
|
|
* // ... the filter for the Units we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends UnitCountArgs>(
|
|
args?: Subset<T, UnitCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], UnitCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Unit.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UnitAggregateArgs} 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 UnitAggregateArgs>(args: Subset<T, UnitAggregateArgs>): Prisma.PrismaPromise<GetUnitAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Unit.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {UnitGroupByArgs} 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 UnitGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: UnitGroupByArgs['orderBy'] }
|
|
: { orderBy?: UnitGroupByArgs['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, UnitGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUnitGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Unit model
|
|
*/
|
|
readonly fields: UnitFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Unit.
|
|
* 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__UnitClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
parent<T extends Unit$parentArgs<ExtArgs> = {}>(args?: Subset<T, Unit$parentArgs<ExtArgs>>): Prisma__UnitClient<$Result.GetResult<Prisma.$UnitPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
children<T extends Unit$childrenArgs<ExtArgs> = {}>(args?: Subset<T, Unit$childrenArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UnitPayload<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 Unit model
|
|
*/
|
|
interface UnitFieldRefs {
|
|
readonly id: FieldRef<"Unit", 'String'>
|
|
readonly name: FieldRef<"Unit", 'String'>
|
|
readonly description: FieldRef<"Unit", 'String'>
|
|
readonly parentId: FieldRef<"Unit", 'String'>
|
|
readonly traits: FieldRef<"Unit", 'Json'>
|
|
readonly createdAt: FieldRef<"Unit", 'DateTime'>
|
|
readonly updatedAt: FieldRef<"Unit", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Unit findUnique
|
|
*/
|
|
export type UnitFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Unit to fetch.
|
|
*/
|
|
where: UnitWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Unit findUniqueOrThrow
|
|
*/
|
|
export type UnitFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Unit to fetch.
|
|
*/
|
|
where: UnitWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Unit findFirst
|
|
*/
|
|
export type UnitFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Unit to fetch.
|
|
*/
|
|
where?: UnitWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Units to fetch.
|
|
*/
|
|
orderBy?: UnitOrderByWithRelationInput | UnitOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Units.
|
|
*/
|
|
cursor?: UnitWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Units 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` Units.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Units.
|
|
*/
|
|
distinct?: UnitScalarFieldEnum | UnitScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Unit findFirstOrThrow
|
|
*/
|
|
export type UnitFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Unit to fetch.
|
|
*/
|
|
where?: UnitWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Units to fetch.
|
|
*/
|
|
orderBy?: UnitOrderByWithRelationInput | UnitOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Units.
|
|
*/
|
|
cursor?: UnitWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Units 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` Units.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Units.
|
|
*/
|
|
distinct?: UnitScalarFieldEnum | UnitScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Unit findMany
|
|
*/
|
|
export type UnitFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Units to fetch.
|
|
*/
|
|
where?: UnitWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Units to fetch.
|
|
*/
|
|
orderBy?: UnitOrderByWithRelationInput | UnitOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Units.
|
|
*/
|
|
cursor?: UnitWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Units 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` Units.
|
|
*/
|
|
skip?: number
|
|
distinct?: UnitScalarFieldEnum | UnitScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Unit create
|
|
*/
|
|
export type UnitCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Unit.
|
|
*/
|
|
data: XOR<UnitCreateInput, UnitUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Unit createMany
|
|
*/
|
|
export type UnitCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Units.
|
|
*/
|
|
data: UnitCreateManyInput | UnitCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Unit createManyAndReturn
|
|
*/
|
|
export type UnitCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Units.
|
|
*/
|
|
data: UnitCreateManyInput | UnitCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Unit update
|
|
*/
|
|
export type UnitUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Unit.
|
|
*/
|
|
data: XOR<UnitUpdateInput, UnitUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Unit to update.
|
|
*/
|
|
where: UnitWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Unit updateMany
|
|
*/
|
|
export type UnitUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Units.
|
|
*/
|
|
data: XOR<UnitUpdateManyMutationInput, UnitUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Units to update
|
|
*/
|
|
where?: UnitWhereInput
|
|
/**
|
|
* Limit how many Units to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Unit updateManyAndReturn
|
|
*/
|
|
export type UnitUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Units.
|
|
*/
|
|
data: XOR<UnitUpdateManyMutationInput, UnitUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Units to update
|
|
*/
|
|
where?: UnitWhereInput
|
|
/**
|
|
* Limit how many Units to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* Unit upsert
|
|
*/
|
|
export type UnitUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Unit to update in case it exists.
|
|
*/
|
|
where: UnitWhereUniqueInput
|
|
/**
|
|
* In case the Unit found by the `where` argument doesn't exist, create a new Unit with this data.
|
|
*/
|
|
create: XOR<UnitCreateInput, UnitUncheckedCreateInput>
|
|
/**
|
|
* In case the Unit was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<UnitUpdateInput, UnitUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Unit delete
|
|
*/
|
|
export type UnitDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Unit to delete.
|
|
*/
|
|
where: UnitWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Unit deleteMany
|
|
*/
|
|
export type UnitDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Units to delete
|
|
*/
|
|
where?: UnitWhereInput
|
|
/**
|
|
* Limit how many Units to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Unit.parent
|
|
*/
|
|
export type Unit$parentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
where?: UnitWhereInput
|
|
}
|
|
|
|
/**
|
|
* Unit.children
|
|
*/
|
|
export type Unit$childrenArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
where?: UnitWhereInput
|
|
orderBy?: UnitOrderByWithRelationInput | UnitOrderByWithRelationInput[]
|
|
cursor?: UnitWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: UnitScalarFieldEnum | UnitScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Unit without action
|
|
*/
|
|
export type UnitDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Unit
|
|
*/
|
|
select?: UnitSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Unit
|
|
*/
|
|
omit?: UnitOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: UnitInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Person
|
|
*/
|
|
|
|
export type AggregatePerson = {
|
|
_count: PersonCountAggregateOutputType | null
|
|
_min: PersonMinAggregateOutputType | null
|
|
_max: PersonMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type PersonMinAggregateOutputType = {
|
|
id: string | null
|
|
firstName: string | null
|
|
lastName: string | null
|
|
email: string | null
|
|
phone: string | null
|
|
ssoId: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type PersonMaxAggregateOutputType = {
|
|
id: string | null
|
|
firstName: string | null
|
|
lastName: string | null
|
|
email: string | null
|
|
phone: string | null
|
|
ssoId: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type PersonCountAggregateOutputType = {
|
|
id: number
|
|
firstName: number
|
|
lastName: number
|
|
email: number
|
|
phone: number
|
|
ssoId: number
|
|
traits: number
|
|
createdAt: number
|
|
updatedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type PersonMinAggregateInputType = {
|
|
id?: true
|
|
firstName?: true
|
|
lastName?: true
|
|
email?: true
|
|
phone?: true
|
|
ssoId?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type PersonMaxAggregateInputType = {
|
|
id?: true
|
|
firstName?: true
|
|
lastName?: true
|
|
email?: true
|
|
phone?: true
|
|
ssoId?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type PersonCountAggregateInputType = {
|
|
id?: true
|
|
firstName?: true
|
|
lastName?: true
|
|
email?: true
|
|
phone?: true
|
|
ssoId?: true
|
|
traits?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type PersonAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Person to aggregate.
|
|
*/
|
|
where?: PersonWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of People to fetch.
|
|
*/
|
|
orderBy?: PersonOrderByWithRelationInput | PersonOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: PersonWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` People 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` People.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned People
|
|
**/
|
|
_count?: true | PersonCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: PersonMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: PersonMaxAggregateInputType
|
|
}
|
|
|
|
export type GetPersonAggregateType<T extends PersonAggregateArgs> = {
|
|
[P in keyof T & keyof AggregatePerson]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregatePerson[P]>
|
|
: GetScalarType<T[P], AggregatePerson[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type PersonGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: PersonWhereInput
|
|
orderBy?: PersonOrderByWithAggregationInput | PersonOrderByWithAggregationInput[]
|
|
by: PersonScalarFieldEnum[] | PersonScalarFieldEnum
|
|
having?: PersonScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: PersonCountAggregateInputType | true
|
|
_min?: PersonMinAggregateInputType
|
|
_max?: PersonMaxAggregateInputType
|
|
}
|
|
|
|
export type PersonGroupByOutputType = {
|
|
id: string
|
|
firstName: string
|
|
lastName: string
|
|
email: string | null
|
|
phone: string | null
|
|
ssoId: string | null
|
|
traits: JsonValue
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
_count: PersonCountAggregateOutputType | null
|
|
_min: PersonMinAggregateOutputType | null
|
|
_max: PersonMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetPersonGroupByPayload<T extends PersonGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<PersonGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof PersonGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], PersonGroupByOutputType[P]>
|
|
: GetScalarType<T[P], PersonGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type PersonSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
firstName?: boolean
|
|
lastName?: boolean
|
|
email?: boolean
|
|
phone?: boolean
|
|
ssoId?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
groupMemberships?: boolean | Person$groupMembershipsArgs<ExtArgs>
|
|
_count?: boolean | PersonCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["person"]>
|
|
|
|
export type PersonSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
firstName?: boolean
|
|
lastName?: boolean
|
|
email?: boolean
|
|
phone?: boolean
|
|
ssoId?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["person"]>
|
|
|
|
export type PersonSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
firstName?: boolean
|
|
lastName?: boolean
|
|
email?: boolean
|
|
phone?: boolean
|
|
ssoId?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["person"]>
|
|
|
|
export type PersonSelectScalar = {
|
|
id?: boolean
|
|
firstName?: boolean
|
|
lastName?: boolean
|
|
email?: boolean
|
|
phone?: boolean
|
|
ssoId?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}
|
|
|
|
export type PersonOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "firstName" | "lastName" | "email" | "phone" | "ssoId" | "traits" | "createdAt" | "updatedAt", ExtArgs["result"]["person"]>
|
|
export type PersonInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
groupMemberships?: boolean | Person$groupMembershipsArgs<ExtArgs>
|
|
_count?: boolean | PersonCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type PersonIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
export type PersonIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
|
|
export type $PersonPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Person"
|
|
objects: {
|
|
groupMemberships: Prisma.$GroupMembershipPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
firstName: string
|
|
lastName: string
|
|
email: string | null
|
|
phone: string | null
|
|
ssoId: string | null
|
|
traits: Prisma.JsonValue
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
}, ExtArgs["result"]["person"]>
|
|
composites: {}
|
|
}
|
|
|
|
type PersonGetPayload<S extends boolean | null | undefined | PersonDefaultArgs> = $Result.GetResult<Prisma.$PersonPayload, S>
|
|
|
|
type PersonCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<PersonFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: PersonCountAggregateInputType | true
|
|
}
|
|
|
|
export interface PersonDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Person'], meta: { name: 'Person' } }
|
|
/**
|
|
* Find zero or one Person that matches the filter.
|
|
* @param {PersonFindUniqueArgs} args - Arguments to find a Person
|
|
* @example
|
|
* // Get one Person
|
|
* const person = await prisma.person.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends PersonFindUniqueArgs>(args: SelectSubset<T, PersonFindUniqueArgs<ExtArgs>>): Prisma__PersonClient<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Person that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {PersonFindUniqueOrThrowArgs} args - Arguments to find a Person
|
|
* @example
|
|
* // Get one Person
|
|
* const person = await prisma.person.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends PersonFindUniqueOrThrowArgs>(args: SelectSubset<T, PersonFindUniqueOrThrowArgs<ExtArgs>>): Prisma__PersonClient<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Person 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 {PersonFindFirstArgs} args - Arguments to find a Person
|
|
* @example
|
|
* // Get one Person
|
|
* const person = await prisma.person.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends PersonFindFirstArgs>(args?: SelectSubset<T, PersonFindFirstArgs<ExtArgs>>): Prisma__PersonClient<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Person 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 {PersonFindFirstOrThrowArgs} args - Arguments to find a Person
|
|
* @example
|
|
* // Get one Person
|
|
* const person = await prisma.person.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends PersonFindFirstOrThrowArgs>(args?: SelectSubset<T, PersonFindFirstOrThrowArgs<ExtArgs>>): Prisma__PersonClient<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more People 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 {PersonFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all People
|
|
* const people = await prisma.person.findMany()
|
|
*
|
|
* // Get first 10 People
|
|
* const people = await prisma.person.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const personWithIdOnly = await prisma.person.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends PersonFindManyArgs>(args?: SelectSubset<T, PersonFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Person.
|
|
* @param {PersonCreateArgs} args - Arguments to create a Person.
|
|
* @example
|
|
* // Create one Person
|
|
* const Person = await prisma.person.create({
|
|
* data: {
|
|
* // ... data to create a Person
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends PersonCreateArgs>(args: SelectSubset<T, PersonCreateArgs<ExtArgs>>): Prisma__PersonClient<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many People.
|
|
* @param {PersonCreateManyArgs} args - Arguments to create many People.
|
|
* @example
|
|
* // Create many People
|
|
* const person = await prisma.person.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends PersonCreateManyArgs>(args?: SelectSubset<T, PersonCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many People and returns the data saved in the database.
|
|
* @param {PersonCreateManyAndReturnArgs} args - Arguments to create many People.
|
|
* @example
|
|
* // Create many People
|
|
* const person = await prisma.person.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many People and only return the `id`
|
|
* const personWithIdOnly = await prisma.person.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 PersonCreateManyAndReturnArgs>(args?: SelectSubset<T, PersonCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Person.
|
|
* @param {PersonDeleteArgs} args - Arguments to delete one Person.
|
|
* @example
|
|
* // Delete one Person
|
|
* const Person = await prisma.person.delete({
|
|
* where: {
|
|
* // ... filter to delete one Person
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends PersonDeleteArgs>(args: SelectSubset<T, PersonDeleteArgs<ExtArgs>>): Prisma__PersonClient<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Person.
|
|
* @param {PersonUpdateArgs} args - Arguments to update one Person.
|
|
* @example
|
|
* // Update one Person
|
|
* const person = await prisma.person.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends PersonUpdateArgs>(args: SelectSubset<T, PersonUpdateArgs<ExtArgs>>): Prisma__PersonClient<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more People.
|
|
* @param {PersonDeleteManyArgs} args - Arguments to filter People to delete.
|
|
* @example
|
|
* // Delete a few People
|
|
* const { count } = await prisma.person.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends PersonDeleteManyArgs>(args?: SelectSubset<T, PersonDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more People.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {PersonUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many People
|
|
* const person = await prisma.person.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends PersonUpdateManyArgs>(args: SelectSubset<T, PersonUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more People and returns the data updated in the database.
|
|
* @param {PersonUpdateManyAndReturnArgs} args - Arguments to update many People.
|
|
* @example
|
|
* // Update many People
|
|
* const person = await prisma.person.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more People and only return the `id`
|
|
* const personWithIdOnly = await prisma.person.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 PersonUpdateManyAndReturnArgs>(args: SelectSubset<T, PersonUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Person.
|
|
* @param {PersonUpsertArgs} args - Arguments to update or create a Person.
|
|
* @example
|
|
* // Update or create a Person
|
|
* const person = await prisma.person.upsert({
|
|
* create: {
|
|
* // ... data to create a Person
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Person we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends PersonUpsertArgs>(args: SelectSubset<T, PersonUpsertArgs<ExtArgs>>): Prisma__PersonClient<$Result.GetResult<Prisma.$PersonPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of People.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {PersonCountArgs} args - Arguments to filter People to count.
|
|
* @example
|
|
* // Count the number of People
|
|
* const count = await prisma.person.count({
|
|
* where: {
|
|
* // ... the filter for the People we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends PersonCountArgs>(
|
|
args?: Subset<T, PersonCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], PersonCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Person.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {PersonAggregateArgs} 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 PersonAggregateArgs>(args: Subset<T, PersonAggregateArgs>): Prisma.PrismaPromise<GetPersonAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Person.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {PersonGroupByArgs} 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 PersonGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: PersonGroupByArgs['orderBy'] }
|
|
: { orderBy?: PersonGroupByArgs['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, PersonGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPersonGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Person model
|
|
*/
|
|
readonly fields: PersonFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Person.
|
|
* 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__PersonClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
groupMemberships<T extends Person$groupMembershipsArgs<ExtArgs> = {}>(args?: Subset<T, Person$groupMembershipsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupMembershipPayload<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 Person model
|
|
*/
|
|
interface PersonFieldRefs {
|
|
readonly id: FieldRef<"Person", 'String'>
|
|
readonly firstName: FieldRef<"Person", 'String'>
|
|
readonly lastName: FieldRef<"Person", 'String'>
|
|
readonly email: FieldRef<"Person", 'String'>
|
|
readonly phone: FieldRef<"Person", 'String'>
|
|
readonly ssoId: FieldRef<"Person", 'String'>
|
|
readonly traits: FieldRef<"Person", 'Json'>
|
|
readonly createdAt: FieldRef<"Person", 'DateTime'>
|
|
readonly updatedAt: FieldRef<"Person", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Person findUnique
|
|
*/
|
|
export type PersonFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PersonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Person to fetch.
|
|
*/
|
|
where: PersonWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Person findUniqueOrThrow
|
|
*/
|
|
export type PersonFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PersonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Person to fetch.
|
|
*/
|
|
where: PersonWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Person findFirst
|
|
*/
|
|
export type PersonFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PersonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Person to fetch.
|
|
*/
|
|
where?: PersonWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of People to fetch.
|
|
*/
|
|
orderBy?: PersonOrderByWithRelationInput | PersonOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for People.
|
|
*/
|
|
cursor?: PersonWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` People 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` People.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of People.
|
|
*/
|
|
distinct?: PersonScalarFieldEnum | PersonScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Person findFirstOrThrow
|
|
*/
|
|
export type PersonFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PersonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Person to fetch.
|
|
*/
|
|
where?: PersonWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of People to fetch.
|
|
*/
|
|
orderBy?: PersonOrderByWithRelationInput | PersonOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for People.
|
|
*/
|
|
cursor?: PersonWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` People 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` People.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of People.
|
|
*/
|
|
distinct?: PersonScalarFieldEnum | PersonScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Person findMany
|
|
*/
|
|
export type PersonFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PersonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which People to fetch.
|
|
*/
|
|
where?: PersonWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of People to fetch.
|
|
*/
|
|
orderBy?: PersonOrderByWithRelationInput | PersonOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing People.
|
|
*/
|
|
cursor?: PersonWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` People 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` People.
|
|
*/
|
|
skip?: number
|
|
distinct?: PersonScalarFieldEnum | PersonScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Person create
|
|
*/
|
|
export type PersonCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PersonInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Person.
|
|
*/
|
|
data: XOR<PersonCreateInput, PersonUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Person createMany
|
|
*/
|
|
export type PersonCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many People.
|
|
*/
|
|
data: PersonCreateManyInput | PersonCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Person createManyAndReturn
|
|
*/
|
|
export type PersonCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many People.
|
|
*/
|
|
data: PersonCreateManyInput | PersonCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Person update
|
|
*/
|
|
export type PersonUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PersonInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Person.
|
|
*/
|
|
data: XOR<PersonUpdateInput, PersonUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Person to update.
|
|
*/
|
|
where: PersonWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Person updateMany
|
|
*/
|
|
export type PersonUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update People.
|
|
*/
|
|
data: XOR<PersonUpdateManyMutationInput, PersonUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which People to update
|
|
*/
|
|
where?: PersonWhereInput
|
|
/**
|
|
* Limit how many People to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Person updateManyAndReturn
|
|
*/
|
|
export type PersonUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update People.
|
|
*/
|
|
data: XOR<PersonUpdateManyMutationInput, PersonUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which People to update
|
|
*/
|
|
where?: PersonWhereInput
|
|
/**
|
|
* Limit how many People to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Person upsert
|
|
*/
|
|
export type PersonUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PersonInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Person to update in case it exists.
|
|
*/
|
|
where: PersonWhereUniqueInput
|
|
/**
|
|
* In case the Person found by the `where` argument doesn't exist, create a new Person with this data.
|
|
*/
|
|
create: XOR<PersonCreateInput, PersonUncheckedCreateInput>
|
|
/**
|
|
* In case the Person was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<PersonUpdateInput, PersonUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Person delete
|
|
*/
|
|
export type PersonDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PersonInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Person to delete.
|
|
*/
|
|
where: PersonWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Person deleteMany
|
|
*/
|
|
export type PersonDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which People to delete
|
|
*/
|
|
where?: PersonWhereInput
|
|
/**
|
|
* Limit how many People to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Person.groupMemberships
|
|
*/
|
|
export type Person$groupMembershipsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
where?: GroupMembershipWhereInput
|
|
orderBy?: GroupMembershipOrderByWithRelationInput | GroupMembershipOrderByWithRelationInput[]
|
|
cursor?: GroupMembershipWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: GroupMembershipScalarFieldEnum | GroupMembershipScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Person without action
|
|
*/
|
|
export type PersonDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Person
|
|
*/
|
|
select?: PersonSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Person
|
|
*/
|
|
omit?: PersonOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: PersonInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Group
|
|
*/
|
|
|
|
export type AggregateGroup = {
|
|
_count: GroupCountAggregateOutputType | null
|
|
_min: GroupMinAggregateOutputType | null
|
|
_max: GroupMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type GroupMinAggregateOutputType = {
|
|
id: string | null
|
|
name: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type GroupMaxAggregateOutputType = {
|
|
id: string | null
|
|
name: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type GroupCountAggregateOutputType = {
|
|
id: number
|
|
name: number
|
|
traits: number
|
|
createdAt: number
|
|
updatedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type GroupMinAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type GroupMaxAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type GroupCountAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
traits?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type GroupAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Group to aggregate.
|
|
*/
|
|
where?: GroupWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Groups to fetch.
|
|
*/
|
|
orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: GroupWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Groups from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Groups.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Groups
|
|
**/
|
|
_count?: true | GroupCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: GroupMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: GroupMaxAggregateInputType
|
|
}
|
|
|
|
export type GetGroupAggregateType<T extends GroupAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateGroup]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateGroup[P]>
|
|
: GetScalarType<T[P], AggregateGroup[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type GroupGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: GroupWhereInput
|
|
orderBy?: GroupOrderByWithAggregationInput | GroupOrderByWithAggregationInput[]
|
|
by: GroupScalarFieldEnum[] | GroupScalarFieldEnum
|
|
having?: GroupScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: GroupCountAggregateInputType | true
|
|
_min?: GroupMinAggregateInputType
|
|
_max?: GroupMaxAggregateInputType
|
|
}
|
|
|
|
export type GroupGroupByOutputType = {
|
|
id: string
|
|
name: string
|
|
traits: JsonValue
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
_count: GroupCountAggregateOutputType | null
|
|
_min: GroupMinAggregateOutputType | null
|
|
_max: GroupMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetGroupGroupByPayload<T extends GroupGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<GroupGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof GroupGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], GroupGroupByOutputType[P]>
|
|
: GetScalarType<T[P], GroupGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type GroupSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
members?: boolean | Group$membersArgs<ExtArgs>
|
|
_count?: boolean | GroupCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["group"]>
|
|
|
|
export type GroupSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["group"]>
|
|
|
|
export type GroupSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["group"]>
|
|
|
|
export type GroupSelectScalar = {
|
|
id?: boolean
|
|
name?: boolean
|
|
traits?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}
|
|
|
|
export type GroupOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "traits" | "createdAt" | "updatedAt", ExtArgs["result"]["group"]>
|
|
export type GroupInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
members?: boolean | Group$membersArgs<ExtArgs>
|
|
_count?: boolean | GroupCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type GroupIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
export type GroupIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
|
|
export type $GroupPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Group"
|
|
objects: {
|
|
members: Prisma.$GroupMembershipPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
name: string
|
|
traits: Prisma.JsonValue
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
}, ExtArgs["result"]["group"]>
|
|
composites: {}
|
|
}
|
|
|
|
type GroupGetPayload<S extends boolean | null | undefined | GroupDefaultArgs> = $Result.GetResult<Prisma.$GroupPayload, S>
|
|
|
|
type GroupCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<GroupFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: GroupCountAggregateInputType | true
|
|
}
|
|
|
|
export interface GroupDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Group'], meta: { name: 'Group' } }
|
|
/**
|
|
* Find zero or one Group that matches the filter.
|
|
* @param {GroupFindUniqueArgs} args - Arguments to find a Group
|
|
* @example
|
|
* // Get one Group
|
|
* const group = await prisma.group.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends GroupFindUniqueArgs>(args: SelectSubset<T, GroupFindUniqueArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Group that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {GroupFindUniqueOrThrowArgs} args - Arguments to find a Group
|
|
* @example
|
|
* // Get one Group
|
|
* const group = await prisma.group.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends GroupFindUniqueOrThrowArgs>(args: SelectSubset<T, GroupFindUniqueOrThrowArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Group that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupFindFirstArgs} args - Arguments to find a Group
|
|
* @example
|
|
* // Get one Group
|
|
* const group = await prisma.group.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends GroupFindFirstArgs>(args?: SelectSubset<T, GroupFindFirstArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Group that matches the filter or
|
|
* throw `PrismaKnownClientError` with `P2025` code if no matches were found.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupFindFirstOrThrowArgs} args - Arguments to find a Group
|
|
* @example
|
|
* // Get one Group
|
|
* const group = await prisma.group.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends GroupFindFirstOrThrowArgs>(args?: SelectSubset<T, GroupFindFirstOrThrowArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Groups that matches the filter.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Groups
|
|
* const groups = await prisma.group.findMany()
|
|
*
|
|
* // Get first 10 Groups
|
|
* const groups = await prisma.group.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const groupWithIdOnly = await prisma.group.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends GroupFindManyArgs>(args?: SelectSubset<T, GroupFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Group.
|
|
* @param {GroupCreateArgs} args - Arguments to create a Group.
|
|
* @example
|
|
* // Create one Group
|
|
* const Group = await prisma.group.create({
|
|
* data: {
|
|
* // ... data to create a Group
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends GroupCreateArgs>(args: SelectSubset<T, GroupCreateArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Groups.
|
|
* @param {GroupCreateManyArgs} args - Arguments to create many Groups.
|
|
* @example
|
|
* // Create many Groups
|
|
* const group = await prisma.group.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends GroupCreateManyArgs>(args?: SelectSubset<T, GroupCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Groups and returns the data saved in the database.
|
|
* @param {GroupCreateManyAndReturnArgs} args - Arguments to create many Groups.
|
|
* @example
|
|
* // Create many Groups
|
|
* const group = await prisma.group.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Groups and only return the `id`
|
|
* const groupWithIdOnly = await prisma.group.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 GroupCreateManyAndReturnArgs>(args?: SelectSubset<T, GroupCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Group.
|
|
* @param {GroupDeleteArgs} args - Arguments to delete one Group.
|
|
* @example
|
|
* // Delete one Group
|
|
* const Group = await prisma.group.delete({
|
|
* where: {
|
|
* // ... filter to delete one Group
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends GroupDeleteArgs>(args: SelectSubset<T, GroupDeleteArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Group.
|
|
* @param {GroupUpdateArgs} args - Arguments to update one Group.
|
|
* @example
|
|
* // Update one Group
|
|
* const group = await prisma.group.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends GroupUpdateArgs>(args: SelectSubset<T, GroupUpdateArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Groups.
|
|
* @param {GroupDeleteManyArgs} args - Arguments to filter Groups to delete.
|
|
* @example
|
|
* // Delete a few Groups
|
|
* const { count } = await prisma.group.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends GroupDeleteManyArgs>(args?: SelectSubset<T, GroupDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Groups.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Groups
|
|
* const group = await prisma.group.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends GroupUpdateManyArgs>(args: SelectSubset<T, GroupUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Groups and returns the data updated in the database.
|
|
* @param {GroupUpdateManyAndReturnArgs} args - Arguments to update many Groups.
|
|
* @example
|
|
* // Update many Groups
|
|
* const group = await prisma.group.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Groups and only return the `id`
|
|
* const groupWithIdOnly = await prisma.group.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 GroupUpdateManyAndReturnArgs>(args: SelectSubset<T, GroupUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Group.
|
|
* @param {GroupUpsertArgs} args - Arguments to update or create a Group.
|
|
* @example
|
|
* // Update or create a Group
|
|
* const group = await prisma.group.upsert({
|
|
* create: {
|
|
* // ... data to create a Group
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Group we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends GroupUpsertArgs>(args: SelectSubset<T, GroupUpsertArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Groups.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupCountArgs} args - Arguments to filter Groups to count.
|
|
* @example
|
|
* // Count the number of Groups
|
|
* const count = await prisma.group.count({
|
|
* where: {
|
|
* // ... the filter for the Groups we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends GroupCountArgs>(
|
|
args?: Subset<T, GroupCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], GroupCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Group.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
|
|
* @example
|
|
* // Ordered by age ascending
|
|
* // Where email contains prisma.io
|
|
* // Limited to the 10 users
|
|
* const aggregations = await prisma.user.aggregate({
|
|
* _avg: {
|
|
* age: true,
|
|
* },
|
|
* where: {
|
|
* email: {
|
|
* contains: "prisma.io",
|
|
* },
|
|
* },
|
|
* orderBy: {
|
|
* age: "asc",
|
|
* },
|
|
* take: 10,
|
|
* })
|
|
**/
|
|
aggregate<T extends GroupAggregateArgs>(args: Subset<T, GroupAggregateArgs>): Prisma.PrismaPromise<GetGroupAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Group.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupGroupByArgs} args - Group by arguments.
|
|
* @example
|
|
* // Group by city, order by createdAt, get count
|
|
* const result = await prisma.user.groupBy({
|
|
* by: ['city', 'createdAt'],
|
|
* orderBy: {
|
|
* createdAt: true
|
|
* },
|
|
* _count: {
|
|
* _all: true
|
|
* },
|
|
* })
|
|
*
|
|
**/
|
|
groupBy<
|
|
T extends GroupGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: GroupGroupByArgs['orderBy'] }
|
|
: { orderBy?: GroupGroupByArgs['orderBy'] },
|
|
OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
|
|
ByFields extends MaybeTupleToUnion<T['by']>,
|
|
ByValid extends Has<ByFields, OrderFields>,
|
|
HavingFields extends GetHavingFields<T['having']>,
|
|
HavingValid extends Has<ByFields, HavingFields>,
|
|
ByEmpty extends T['by'] extends never[] ? True : False,
|
|
InputErrors extends ByEmpty extends True
|
|
? `Error: "by" must not be empty.`
|
|
: HavingValid extends False
|
|
? {
|
|
[P in HavingFields]: P extends ByFields
|
|
? never
|
|
: P extends string
|
|
? `Error: Field "${P}" used in "having" needs to be provided in "by".`
|
|
: [
|
|
Error,
|
|
'Field ',
|
|
P,
|
|
` in "having" needs to be provided in "by"`,
|
|
]
|
|
}[HavingFields]
|
|
: 'take' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "take", you also need to provide "orderBy"'
|
|
: 'skip' extends Keys<T>
|
|
? 'orderBy' extends Keys<T>
|
|
? ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
: 'Error: If you provide "skip", you also need to provide "orderBy"'
|
|
: ByValid extends True
|
|
? {}
|
|
: {
|
|
[P in OrderFields]: P extends ByFields
|
|
? never
|
|
: `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
|
|
}[OrderFields]
|
|
>(args: SubsetIntersection<T, GroupGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetGroupGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Group model
|
|
*/
|
|
readonly fields: GroupFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Group.
|
|
* Why is this prefixed with `Prisma__`?
|
|
* Because we want to prevent naming conflicts as mentioned in
|
|
* https://github.com/prisma/prisma-client-js/issues/707
|
|
*/
|
|
export interface Prisma__GroupClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
members<T extends Group$membersArgs<ExtArgs> = {}>(args?: Subset<T, Group$membersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupMembershipPayload<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 Group model
|
|
*/
|
|
interface GroupFieldRefs {
|
|
readonly id: FieldRef<"Group", 'String'>
|
|
readonly name: FieldRef<"Group", 'String'>
|
|
readonly traits: FieldRef<"Group", 'Json'>
|
|
readonly createdAt: FieldRef<"Group", 'DateTime'>
|
|
readonly updatedAt: FieldRef<"Group", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Group findUnique
|
|
*/
|
|
export type GroupFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Group to fetch.
|
|
*/
|
|
where: GroupWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Group findUniqueOrThrow
|
|
*/
|
|
export type GroupFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Group to fetch.
|
|
*/
|
|
where: GroupWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Group findFirst
|
|
*/
|
|
export type GroupFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Group to fetch.
|
|
*/
|
|
where?: GroupWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Groups to fetch.
|
|
*/
|
|
orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Groups.
|
|
*/
|
|
cursor?: GroupWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Groups from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Groups.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Groups.
|
|
*/
|
|
distinct?: GroupScalarFieldEnum | GroupScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Group findFirstOrThrow
|
|
*/
|
|
export type GroupFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Group to fetch.
|
|
*/
|
|
where?: GroupWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Groups to fetch.
|
|
*/
|
|
orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Groups.
|
|
*/
|
|
cursor?: GroupWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Groups from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Groups.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Groups.
|
|
*/
|
|
distinct?: GroupScalarFieldEnum | GroupScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Group findMany
|
|
*/
|
|
export type GroupFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which Groups to fetch.
|
|
*/
|
|
where?: GroupWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Groups to fetch.
|
|
*/
|
|
orderBy?: GroupOrderByWithRelationInput | GroupOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Groups.
|
|
*/
|
|
cursor?: GroupWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Groups from the position of the cursor.
|
|
*/
|
|
take?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Skip the first `n` Groups.
|
|
*/
|
|
skip?: number
|
|
distinct?: GroupScalarFieldEnum | GroupScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Group create
|
|
*/
|
|
export type GroupCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Group.
|
|
*/
|
|
data: XOR<GroupCreateInput, GroupUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Group createMany
|
|
*/
|
|
export type GroupCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Groups.
|
|
*/
|
|
data: GroupCreateManyInput | GroupCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Group createManyAndReturn
|
|
*/
|
|
export type GroupCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Groups.
|
|
*/
|
|
data: GroupCreateManyInput | GroupCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Group update
|
|
*/
|
|
export type GroupUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Group.
|
|
*/
|
|
data: XOR<GroupUpdateInput, GroupUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Group to update.
|
|
*/
|
|
where: GroupWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Group updateMany
|
|
*/
|
|
export type GroupUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Groups.
|
|
*/
|
|
data: XOR<GroupUpdateManyMutationInput, GroupUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Groups to update
|
|
*/
|
|
where?: GroupWhereInput
|
|
/**
|
|
* Limit how many Groups to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Group updateManyAndReturn
|
|
*/
|
|
export type GroupUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Groups.
|
|
*/
|
|
data: XOR<GroupUpdateManyMutationInput, GroupUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Groups to update
|
|
*/
|
|
where?: GroupWhereInput
|
|
/**
|
|
* Limit how many Groups to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Group upsert
|
|
*/
|
|
export type GroupUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Group to update in case it exists.
|
|
*/
|
|
where: GroupWhereUniqueInput
|
|
/**
|
|
* In case the Group found by the `where` argument doesn't exist, create a new Group with this data.
|
|
*/
|
|
create: XOR<GroupCreateInput, GroupUncheckedCreateInput>
|
|
/**
|
|
* In case the Group was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<GroupUpdateInput, GroupUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Group delete
|
|
*/
|
|
export type GroupDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which Group to delete.
|
|
*/
|
|
where: GroupWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Group deleteMany
|
|
*/
|
|
export type GroupDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Groups to delete
|
|
*/
|
|
where?: GroupWhereInput
|
|
/**
|
|
* Limit how many Groups to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Group.members
|
|
*/
|
|
export type Group$membersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
where?: GroupMembershipWhereInput
|
|
orderBy?: GroupMembershipOrderByWithRelationInput | GroupMembershipOrderByWithRelationInput[]
|
|
cursor?: GroupMembershipWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: GroupMembershipScalarFieldEnum | GroupMembershipScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Group without action
|
|
*/
|
|
export type GroupDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Group
|
|
*/
|
|
select?: GroupSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Group
|
|
*/
|
|
omit?: GroupOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model GroupMembership
|
|
*/
|
|
|
|
export type AggregateGroupMembership = {
|
|
_count: GroupMembershipCountAggregateOutputType | null
|
|
_min: GroupMembershipMinAggregateOutputType | null
|
|
_max: GroupMembershipMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type GroupMembershipMinAggregateOutputType = {
|
|
id: string | null
|
|
personId: string | null
|
|
groupId: string | null
|
|
role: string | null
|
|
}
|
|
|
|
export type GroupMembershipMaxAggregateOutputType = {
|
|
id: string | null
|
|
personId: string | null
|
|
groupId: string | null
|
|
role: string | null
|
|
}
|
|
|
|
export type GroupMembershipCountAggregateOutputType = {
|
|
id: number
|
|
personId: number
|
|
groupId: number
|
|
role: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type GroupMembershipMinAggregateInputType = {
|
|
id?: true
|
|
personId?: true
|
|
groupId?: true
|
|
role?: true
|
|
}
|
|
|
|
export type GroupMembershipMaxAggregateInputType = {
|
|
id?: true
|
|
personId?: true
|
|
groupId?: true
|
|
role?: true
|
|
}
|
|
|
|
export type GroupMembershipCountAggregateInputType = {
|
|
id?: true
|
|
personId?: true
|
|
groupId?: true
|
|
role?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type GroupMembershipAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which GroupMembership to aggregate.
|
|
*/
|
|
where?: GroupMembershipWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of GroupMemberships to fetch.
|
|
*/
|
|
orderBy?: GroupMembershipOrderByWithRelationInput | GroupMembershipOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: GroupMembershipWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` GroupMemberships 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` GroupMemberships.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned GroupMemberships
|
|
**/
|
|
_count?: true | GroupMembershipCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: GroupMembershipMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: GroupMembershipMaxAggregateInputType
|
|
}
|
|
|
|
export type GetGroupMembershipAggregateType<T extends GroupMembershipAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateGroupMembership]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateGroupMembership[P]>
|
|
: GetScalarType<T[P], AggregateGroupMembership[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type GroupMembershipGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: GroupMembershipWhereInput
|
|
orderBy?: GroupMembershipOrderByWithAggregationInput | GroupMembershipOrderByWithAggregationInput[]
|
|
by: GroupMembershipScalarFieldEnum[] | GroupMembershipScalarFieldEnum
|
|
having?: GroupMembershipScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: GroupMembershipCountAggregateInputType | true
|
|
_min?: GroupMembershipMinAggregateInputType
|
|
_max?: GroupMembershipMaxAggregateInputType
|
|
}
|
|
|
|
export type GroupMembershipGroupByOutputType = {
|
|
id: string
|
|
personId: string
|
|
groupId: string
|
|
role: string
|
|
_count: GroupMembershipCountAggregateOutputType | null
|
|
_min: GroupMembershipMinAggregateOutputType | null
|
|
_max: GroupMembershipMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetGroupMembershipGroupByPayload<T extends GroupMembershipGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<GroupMembershipGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof GroupMembershipGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], GroupMembershipGroupByOutputType[P]>
|
|
: GetScalarType<T[P], GroupMembershipGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type GroupMembershipSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
personId?: boolean
|
|
groupId?: boolean
|
|
role?: boolean
|
|
group?: boolean | GroupDefaultArgs<ExtArgs>
|
|
person?: boolean | PersonDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["groupMembership"]>
|
|
|
|
export type GroupMembershipSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
personId?: boolean
|
|
groupId?: boolean
|
|
role?: boolean
|
|
group?: boolean | GroupDefaultArgs<ExtArgs>
|
|
person?: boolean | PersonDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["groupMembership"]>
|
|
|
|
export type GroupMembershipSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
personId?: boolean
|
|
groupId?: boolean
|
|
role?: boolean
|
|
group?: boolean | GroupDefaultArgs<ExtArgs>
|
|
person?: boolean | PersonDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["groupMembership"]>
|
|
|
|
export type GroupMembershipSelectScalar = {
|
|
id?: boolean
|
|
personId?: boolean
|
|
groupId?: boolean
|
|
role?: boolean
|
|
}
|
|
|
|
export type GroupMembershipOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "personId" | "groupId" | "role", ExtArgs["result"]["groupMembership"]>
|
|
export type GroupMembershipInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
group?: boolean | GroupDefaultArgs<ExtArgs>
|
|
person?: boolean | PersonDefaultArgs<ExtArgs>
|
|
}
|
|
export type GroupMembershipIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
group?: boolean | GroupDefaultArgs<ExtArgs>
|
|
person?: boolean | PersonDefaultArgs<ExtArgs>
|
|
}
|
|
export type GroupMembershipIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
group?: boolean | GroupDefaultArgs<ExtArgs>
|
|
person?: boolean | PersonDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $GroupMembershipPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "GroupMembership"
|
|
objects: {
|
|
group: Prisma.$GroupPayload<ExtArgs>
|
|
person: Prisma.$PersonPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
personId: string
|
|
groupId: string
|
|
role: string
|
|
}, ExtArgs["result"]["groupMembership"]>
|
|
composites: {}
|
|
}
|
|
|
|
type GroupMembershipGetPayload<S extends boolean | null | undefined | GroupMembershipDefaultArgs> = $Result.GetResult<Prisma.$GroupMembershipPayload, S>
|
|
|
|
type GroupMembershipCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<GroupMembershipFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: GroupMembershipCountAggregateInputType | true
|
|
}
|
|
|
|
export interface GroupMembershipDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['GroupMembership'], meta: { name: 'GroupMembership' } }
|
|
/**
|
|
* Find zero or one GroupMembership that matches the filter.
|
|
* @param {GroupMembershipFindUniqueArgs} args - Arguments to find a GroupMembership
|
|
* @example
|
|
* // Get one GroupMembership
|
|
* const groupMembership = await prisma.groupMembership.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends GroupMembershipFindUniqueArgs>(args: SelectSubset<T, GroupMembershipFindUniqueArgs<ExtArgs>>): Prisma__GroupMembershipClient<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one GroupMembership that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {GroupMembershipFindUniqueOrThrowArgs} args - Arguments to find a GroupMembership
|
|
* @example
|
|
* // Get one GroupMembership
|
|
* const groupMembership = await prisma.groupMembership.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends GroupMembershipFindUniqueOrThrowArgs>(args: SelectSubset<T, GroupMembershipFindUniqueOrThrowArgs<ExtArgs>>): Prisma__GroupMembershipClient<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first GroupMembership 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 {GroupMembershipFindFirstArgs} args - Arguments to find a GroupMembership
|
|
* @example
|
|
* // Get one GroupMembership
|
|
* const groupMembership = await prisma.groupMembership.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends GroupMembershipFindFirstArgs>(args?: SelectSubset<T, GroupMembershipFindFirstArgs<ExtArgs>>): Prisma__GroupMembershipClient<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first GroupMembership 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 {GroupMembershipFindFirstOrThrowArgs} args - Arguments to find a GroupMembership
|
|
* @example
|
|
* // Get one GroupMembership
|
|
* const groupMembership = await prisma.groupMembership.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends GroupMembershipFindFirstOrThrowArgs>(args?: SelectSubset<T, GroupMembershipFindFirstOrThrowArgs<ExtArgs>>): Prisma__GroupMembershipClient<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more GroupMemberships 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 {GroupMembershipFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all GroupMemberships
|
|
* const groupMemberships = await prisma.groupMembership.findMany()
|
|
*
|
|
* // Get first 10 GroupMemberships
|
|
* const groupMemberships = await prisma.groupMembership.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const groupMembershipWithIdOnly = await prisma.groupMembership.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends GroupMembershipFindManyArgs>(args?: SelectSubset<T, GroupMembershipFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a GroupMembership.
|
|
* @param {GroupMembershipCreateArgs} args - Arguments to create a GroupMembership.
|
|
* @example
|
|
* // Create one GroupMembership
|
|
* const GroupMembership = await prisma.groupMembership.create({
|
|
* data: {
|
|
* // ... data to create a GroupMembership
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends GroupMembershipCreateArgs>(args: SelectSubset<T, GroupMembershipCreateArgs<ExtArgs>>): Prisma__GroupMembershipClient<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many GroupMemberships.
|
|
* @param {GroupMembershipCreateManyArgs} args - Arguments to create many GroupMemberships.
|
|
* @example
|
|
* // Create many GroupMemberships
|
|
* const groupMembership = await prisma.groupMembership.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends GroupMembershipCreateManyArgs>(args?: SelectSubset<T, GroupMembershipCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many GroupMemberships and returns the data saved in the database.
|
|
* @param {GroupMembershipCreateManyAndReturnArgs} args - Arguments to create many GroupMemberships.
|
|
* @example
|
|
* // Create many GroupMemberships
|
|
* const groupMembership = await prisma.groupMembership.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many GroupMemberships and only return the `id`
|
|
* const groupMembershipWithIdOnly = await prisma.groupMembership.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 GroupMembershipCreateManyAndReturnArgs>(args?: SelectSubset<T, GroupMembershipCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a GroupMembership.
|
|
* @param {GroupMembershipDeleteArgs} args - Arguments to delete one GroupMembership.
|
|
* @example
|
|
* // Delete one GroupMembership
|
|
* const GroupMembership = await prisma.groupMembership.delete({
|
|
* where: {
|
|
* // ... filter to delete one GroupMembership
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends GroupMembershipDeleteArgs>(args: SelectSubset<T, GroupMembershipDeleteArgs<ExtArgs>>): Prisma__GroupMembershipClient<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one GroupMembership.
|
|
* @param {GroupMembershipUpdateArgs} args - Arguments to update one GroupMembership.
|
|
* @example
|
|
* // Update one GroupMembership
|
|
* const groupMembership = await prisma.groupMembership.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends GroupMembershipUpdateArgs>(args: SelectSubset<T, GroupMembershipUpdateArgs<ExtArgs>>): Prisma__GroupMembershipClient<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more GroupMemberships.
|
|
* @param {GroupMembershipDeleteManyArgs} args - Arguments to filter GroupMemberships to delete.
|
|
* @example
|
|
* // Delete a few GroupMemberships
|
|
* const { count } = await prisma.groupMembership.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends GroupMembershipDeleteManyArgs>(args?: SelectSubset<T, GroupMembershipDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more GroupMemberships.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupMembershipUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many GroupMemberships
|
|
* const groupMembership = await prisma.groupMembership.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends GroupMembershipUpdateManyArgs>(args: SelectSubset<T, GroupMembershipUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more GroupMemberships and returns the data updated in the database.
|
|
* @param {GroupMembershipUpdateManyAndReturnArgs} args - Arguments to update many GroupMemberships.
|
|
* @example
|
|
* // Update many GroupMemberships
|
|
* const groupMembership = await prisma.groupMembership.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more GroupMemberships and only return the `id`
|
|
* const groupMembershipWithIdOnly = await prisma.groupMembership.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 GroupMembershipUpdateManyAndReturnArgs>(args: SelectSubset<T, GroupMembershipUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one GroupMembership.
|
|
* @param {GroupMembershipUpsertArgs} args - Arguments to update or create a GroupMembership.
|
|
* @example
|
|
* // Update or create a GroupMembership
|
|
* const groupMembership = await prisma.groupMembership.upsert({
|
|
* create: {
|
|
* // ... data to create a GroupMembership
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the GroupMembership we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends GroupMembershipUpsertArgs>(args: SelectSubset<T, GroupMembershipUpsertArgs<ExtArgs>>): Prisma__GroupMembershipClient<$Result.GetResult<Prisma.$GroupMembershipPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of GroupMemberships.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupMembershipCountArgs} args - Arguments to filter GroupMemberships to count.
|
|
* @example
|
|
* // Count the number of GroupMemberships
|
|
* const count = await prisma.groupMembership.count({
|
|
* where: {
|
|
* // ... the filter for the GroupMemberships we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends GroupMembershipCountArgs>(
|
|
args?: Subset<T, GroupMembershipCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], GroupMembershipCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a GroupMembership.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupMembershipAggregateArgs} 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 GroupMembershipAggregateArgs>(args: Subset<T, GroupMembershipAggregateArgs>): Prisma.PrismaPromise<GetGroupMembershipAggregateType<T>>
|
|
|
|
/**
|
|
* Group by GroupMembership.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {GroupMembershipGroupByArgs} 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 GroupMembershipGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: GroupMembershipGroupByArgs['orderBy'] }
|
|
: { orderBy?: GroupMembershipGroupByArgs['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, GroupMembershipGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetGroupMembershipGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the GroupMembership model
|
|
*/
|
|
readonly fields: GroupMembershipFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for GroupMembership.
|
|
* 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__GroupMembershipClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
group<T extends GroupDefaultArgs<ExtArgs> = {}>(args?: Subset<T, GroupDefaultArgs<ExtArgs>>): Prisma__GroupClient<$Result.GetResult<Prisma.$GroupPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
person<T extends PersonDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PersonDefaultArgs<ExtArgs>>): Prisma__PersonClient<$Result.GetResult<Prisma.$PersonPayload<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 GroupMembership model
|
|
*/
|
|
interface GroupMembershipFieldRefs {
|
|
readonly id: FieldRef<"GroupMembership", 'String'>
|
|
readonly personId: FieldRef<"GroupMembership", 'String'>
|
|
readonly groupId: FieldRef<"GroupMembership", 'String'>
|
|
readonly role: FieldRef<"GroupMembership", 'String'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* GroupMembership findUnique
|
|
*/
|
|
export type GroupMembershipFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which GroupMembership to fetch.
|
|
*/
|
|
where: GroupMembershipWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* GroupMembership findUniqueOrThrow
|
|
*/
|
|
export type GroupMembershipFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which GroupMembership to fetch.
|
|
*/
|
|
where: GroupMembershipWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* GroupMembership findFirst
|
|
*/
|
|
export type GroupMembershipFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which GroupMembership to fetch.
|
|
*/
|
|
where?: GroupMembershipWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of GroupMemberships to fetch.
|
|
*/
|
|
orderBy?: GroupMembershipOrderByWithRelationInput | GroupMembershipOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for GroupMemberships.
|
|
*/
|
|
cursor?: GroupMembershipWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` GroupMemberships 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` GroupMemberships.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of GroupMemberships.
|
|
*/
|
|
distinct?: GroupMembershipScalarFieldEnum | GroupMembershipScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* GroupMembership findFirstOrThrow
|
|
*/
|
|
export type GroupMembershipFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which GroupMembership to fetch.
|
|
*/
|
|
where?: GroupMembershipWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of GroupMemberships to fetch.
|
|
*/
|
|
orderBy?: GroupMembershipOrderByWithRelationInput | GroupMembershipOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for GroupMemberships.
|
|
*/
|
|
cursor?: GroupMembershipWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` GroupMemberships 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` GroupMemberships.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of GroupMemberships.
|
|
*/
|
|
distinct?: GroupMembershipScalarFieldEnum | GroupMembershipScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* GroupMembership findMany
|
|
*/
|
|
export type GroupMembershipFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which GroupMemberships to fetch.
|
|
*/
|
|
where?: GroupMembershipWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of GroupMemberships to fetch.
|
|
*/
|
|
orderBy?: GroupMembershipOrderByWithRelationInput | GroupMembershipOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing GroupMemberships.
|
|
*/
|
|
cursor?: GroupMembershipWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` GroupMemberships 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` GroupMemberships.
|
|
*/
|
|
skip?: number
|
|
distinct?: GroupMembershipScalarFieldEnum | GroupMembershipScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* GroupMembership create
|
|
*/
|
|
export type GroupMembershipCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a GroupMembership.
|
|
*/
|
|
data: XOR<GroupMembershipCreateInput, GroupMembershipUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* GroupMembership createMany
|
|
*/
|
|
export type GroupMembershipCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many GroupMemberships.
|
|
*/
|
|
data: GroupMembershipCreateManyInput | GroupMembershipCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* GroupMembership createManyAndReturn
|
|
*/
|
|
export type GroupMembershipCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many GroupMemberships.
|
|
*/
|
|
data: GroupMembershipCreateManyInput | GroupMembershipCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* GroupMembership update
|
|
*/
|
|
export type GroupMembershipUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a GroupMembership.
|
|
*/
|
|
data: XOR<GroupMembershipUpdateInput, GroupMembershipUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which GroupMembership to update.
|
|
*/
|
|
where: GroupMembershipWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* GroupMembership updateMany
|
|
*/
|
|
export type GroupMembershipUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update GroupMemberships.
|
|
*/
|
|
data: XOR<GroupMembershipUpdateManyMutationInput, GroupMembershipUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which GroupMemberships to update
|
|
*/
|
|
where?: GroupMembershipWhereInput
|
|
/**
|
|
* Limit how many GroupMemberships to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* GroupMembership updateManyAndReturn
|
|
*/
|
|
export type GroupMembershipUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update GroupMemberships.
|
|
*/
|
|
data: XOR<GroupMembershipUpdateManyMutationInput, GroupMembershipUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which GroupMemberships to update
|
|
*/
|
|
where?: GroupMembershipWhereInput
|
|
/**
|
|
* Limit how many GroupMemberships to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* GroupMembership upsert
|
|
*/
|
|
export type GroupMembershipUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the GroupMembership to update in case it exists.
|
|
*/
|
|
where: GroupMembershipWhereUniqueInput
|
|
/**
|
|
* In case the GroupMembership found by the `where` argument doesn't exist, create a new GroupMembership with this data.
|
|
*/
|
|
create: XOR<GroupMembershipCreateInput, GroupMembershipUncheckedCreateInput>
|
|
/**
|
|
* In case the GroupMembership was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<GroupMembershipUpdateInput, GroupMembershipUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* GroupMembership delete
|
|
*/
|
|
export type GroupMembershipDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which GroupMembership to delete.
|
|
*/
|
|
where: GroupMembershipWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* GroupMembership deleteMany
|
|
*/
|
|
export type GroupMembershipDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which GroupMemberships to delete
|
|
*/
|
|
where?: GroupMembershipWhereInput
|
|
/**
|
|
* Limit how many GroupMemberships to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* GroupMembership without action
|
|
*/
|
|
export type GroupMembershipDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the GroupMembership
|
|
*/
|
|
select?: GroupMembershipSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the GroupMembership
|
|
*/
|
|
omit?: GroupMembershipOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: GroupMembershipInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Event
|
|
*/
|
|
|
|
export type AggregateEvent = {
|
|
_count: EventCountAggregateOutputType | null
|
|
_min: EventMinAggregateOutputType | null
|
|
_max: EventMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type EventMinAggregateOutputType = {
|
|
id: string | null
|
|
type: string | null
|
|
status: string | null
|
|
startTime: Date | null
|
|
endTime: Date | null
|
|
targetUnitId: string | null
|
|
targetGroupId: string | null
|
|
targetPersonId: string | null
|
|
parentEventId: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type EventMaxAggregateOutputType = {
|
|
id: string | null
|
|
type: string | null
|
|
status: string | null
|
|
startTime: Date | null
|
|
endTime: Date | null
|
|
targetUnitId: string | null
|
|
targetGroupId: string | null
|
|
targetPersonId: string | null
|
|
parentEventId: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type EventCountAggregateOutputType = {
|
|
id: number
|
|
type: number
|
|
status: number
|
|
startTime: number
|
|
endTime: number
|
|
targetUnitId: number
|
|
targetGroupId: number
|
|
targetPersonId: number
|
|
payload: number
|
|
parentEventId: number
|
|
createdAt: number
|
|
updatedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type EventMinAggregateInputType = {
|
|
id?: true
|
|
type?: true
|
|
status?: true
|
|
startTime?: true
|
|
endTime?: true
|
|
targetUnitId?: true
|
|
targetGroupId?: true
|
|
targetPersonId?: true
|
|
parentEventId?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type EventMaxAggregateInputType = {
|
|
id?: true
|
|
type?: true
|
|
status?: true
|
|
startTime?: true
|
|
endTime?: true
|
|
targetUnitId?: true
|
|
targetGroupId?: true
|
|
targetPersonId?: true
|
|
parentEventId?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type EventCountAggregateInputType = {
|
|
id?: true
|
|
type?: true
|
|
status?: true
|
|
startTime?: true
|
|
endTime?: true
|
|
targetUnitId?: true
|
|
targetGroupId?: true
|
|
targetPersonId?: true
|
|
payload?: true
|
|
parentEventId?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type EventAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Event to aggregate.
|
|
*/
|
|
where?: EventWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Events to fetch.
|
|
*/
|
|
orderBy?: EventOrderByWithRelationInput | EventOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: EventWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Events 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` Events.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Events
|
|
**/
|
|
_count?: true | EventCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: EventMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: EventMaxAggregateInputType
|
|
}
|
|
|
|
export type GetEventAggregateType<T extends EventAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateEvent]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateEvent[P]>
|
|
: GetScalarType<T[P], AggregateEvent[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type EventGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: EventWhereInput
|
|
orderBy?: EventOrderByWithAggregationInput | EventOrderByWithAggregationInput[]
|
|
by: EventScalarFieldEnum[] | EventScalarFieldEnum
|
|
having?: EventScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: EventCountAggregateInputType | true
|
|
_min?: EventMinAggregateInputType
|
|
_max?: EventMaxAggregateInputType
|
|
}
|
|
|
|
export type EventGroupByOutputType = {
|
|
id: string
|
|
type: string
|
|
status: string
|
|
startTime: Date
|
|
endTime: Date | null
|
|
targetUnitId: string | null
|
|
targetGroupId: string | null
|
|
targetPersonId: string | null
|
|
payload: JsonValue
|
|
parentEventId: string | null
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
_count: EventCountAggregateOutputType | null
|
|
_min: EventMinAggregateOutputType | null
|
|
_max: EventMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetEventGroupByPayload<T extends EventGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<EventGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof EventGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], EventGroupByOutputType[P]>
|
|
: GetScalarType<T[P], EventGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type EventSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
type?: boolean
|
|
status?: boolean
|
|
startTime?: boolean
|
|
endTime?: boolean
|
|
targetUnitId?: boolean
|
|
targetGroupId?: boolean
|
|
targetPersonId?: boolean
|
|
payload?: boolean
|
|
parentEventId?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["event"]>
|
|
|
|
export type EventSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
type?: boolean
|
|
status?: boolean
|
|
startTime?: boolean
|
|
endTime?: boolean
|
|
targetUnitId?: boolean
|
|
targetGroupId?: boolean
|
|
targetPersonId?: boolean
|
|
payload?: boolean
|
|
parentEventId?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["event"]>
|
|
|
|
export type EventSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
type?: boolean
|
|
status?: boolean
|
|
startTime?: boolean
|
|
endTime?: boolean
|
|
targetUnitId?: boolean
|
|
targetGroupId?: boolean
|
|
targetPersonId?: boolean
|
|
payload?: boolean
|
|
parentEventId?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["event"]>
|
|
|
|
export type EventSelectScalar = {
|
|
id?: boolean
|
|
type?: boolean
|
|
status?: boolean
|
|
startTime?: boolean
|
|
endTime?: boolean
|
|
targetUnitId?: boolean
|
|
targetGroupId?: boolean
|
|
targetPersonId?: boolean
|
|
payload?: boolean
|
|
parentEventId?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}
|
|
|
|
export type EventOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "type" | "status" | "startTime" | "endTime" | "targetUnitId" | "targetGroupId" | "targetPersonId" | "payload" | "parentEventId" | "createdAt" | "updatedAt", ExtArgs["result"]["event"]>
|
|
|
|
export type $EventPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Event"
|
|
objects: {}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
type: string
|
|
status: string
|
|
startTime: Date
|
|
endTime: Date | null
|
|
targetUnitId: string | null
|
|
targetGroupId: string | null
|
|
targetPersonId: string | null
|
|
payload: Prisma.JsonValue
|
|
parentEventId: string | null
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
}, ExtArgs["result"]["event"]>
|
|
composites: {}
|
|
}
|
|
|
|
type EventGetPayload<S extends boolean | null | undefined | EventDefaultArgs> = $Result.GetResult<Prisma.$EventPayload, S>
|
|
|
|
type EventCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<EventFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: EventCountAggregateInputType | true
|
|
}
|
|
|
|
export interface EventDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Event'], meta: { name: 'Event' } }
|
|
/**
|
|
* Find zero or one Event that matches the filter.
|
|
* @param {EventFindUniqueArgs} args - Arguments to find a Event
|
|
* @example
|
|
* // Get one Event
|
|
* const event = await prisma.event.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends EventFindUniqueArgs>(args: SelectSubset<T, EventFindUniqueArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Event that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {EventFindUniqueOrThrowArgs} args - Arguments to find a Event
|
|
* @example
|
|
* // Get one Event
|
|
* const event = await prisma.event.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends EventFindUniqueOrThrowArgs>(args: SelectSubset<T, EventFindUniqueOrThrowArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Event 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 {EventFindFirstArgs} args - Arguments to find a Event
|
|
* @example
|
|
* // Get one Event
|
|
* const event = await prisma.event.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends EventFindFirstArgs>(args?: SelectSubset<T, EventFindFirstArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Event 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 {EventFindFirstOrThrowArgs} args - Arguments to find a Event
|
|
* @example
|
|
* // Get one Event
|
|
* const event = await prisma.event.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends EventFindFirstOrThrowArgs>(args?: SelectSubset<T, EventFindFirstOrThrowArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Events 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 {EventFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Events
|
|
* const events = await prisma.event.findMany()
|
|
*
|
|
* // Get first 10 Events
|
|
* const events = await prisma.event.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const eventWithIdOnly = await prisma.event.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends EventFindManyArgs>(args?: SelectSubset<T, EventFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Event.
|
|
* @param {EventCreateArgs} args - Arguments to create a Event.
|
|
* @example
|
|
* // Create one Event
|
|
* const Event = await prisma.event.create({
|
|
* data: {
|
|
* // ... data to create a Event
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends EventCreateArgs>(args: SelectSubset<T, EventCreateArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Events.
|
|
* @param {EventCreateManyArgs} args - Arguments to create many Events.
|
|
* @example
|
|
* // Create many Events
|
|
* const event = await prisma.event.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends EventCreateManyArgs>(args?: SelectSubset<T, EventCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Events and returns the data saved in the database.
|
|
* @param {EventCreateManyAndReturnArgs} args - Arguments to create many Events.
|
|
* @example
|
|
* // Create many Events
|
|
* const event = await prisma.event.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Events and only return the `id`
|
|
* const eventWithIdOnly = await prisma.event.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 EventCreateManyAndReturnArgs>(args?: SelectSubset<T, EventCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Event.
|
|
* @param {EventDeleteArgs} args - Arguments to delete one Event.
|
|
* @example
|
|
* // Delete one Event
|
|
* const Event = await prisma.event.delete({
|
|
* where: {
|
|
* // ... filter to delete one Event
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends EventDeleteArgs>(args: SelectSubset<T, EventDeleteArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Event.
|
|
* @param {EventUpdateArgs} args - Arguments to update one Event.
|
|
* @example
|
|
* // Update one Event
|
|
* const event = await prisma.event.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends EventUpdateArgs>(args: SelectSubset<T, EventUpdateArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Events.
|
|
* @param {EventDeleteManyArgs} args - Arguments to filter Events to delete.
|
|
* @example
|
|
* // Delete a few Events
|
|
* const { count } = await prisma.event.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends EventDeleteManyArgs>(args?: SelectSubset<T, EventDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Events.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {EventUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Events
|
|
* const event = await prisma.event.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends EventUpdateManyArgs>(args: SelectSubset<T, EventUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Events and returns the data updated in the database.
|
|
* @param {EventUpdateManyAndReturnArgs} args - Arguments to update many Events.
|
|
* @example
|
|
* // Update many Events
|
|
* const event = await prisma.event.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Events and only return the `id`
|
|
* const eventWithIdOnly = await prisma.event.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 EventUpdateManyAndReturnArgs>(args: SelectSubset<T, EventUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Event.
|
|
* @param {EventUpsertArgs} args - Arguments to update or create a Event.
|
|
* @example
|
|
* // Update or create a Event
|
|
* const event = await prisma.event.upsert({
|
|
* create: {
|
|
* // ... data to create a Event
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Event we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends EventUpsertArgs>(args: SelectSubset<T, EventUpsertArgs<ExtArgs>>): Prisma__EventClient<$Result.GetResult<Prisma.$EventPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Events.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {EventCountArgs} args - Arguments to filter Events to count.
|
|
* @example
|
|
* // Count the number of Events
|
|
* const count = await prisma.event.count({
|
|
* where: {
|
|
* // ... the filter for the Events we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends EventCountArgs>(
|
|
args?: Subset<T, EventCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], EventCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Event.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {EventAggregateArgs} 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 EventAggregateArgs>(args: Subset<T, EventAggregateArgs>): Prisma.PrismaPromise<GetEventAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Event.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {EventGroupByArgs} 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 EventGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: EventGroupByArgs['orderBy'] }
|
|
: { orderBy?: EventGroupByArgs['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, EventGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetEventGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Event model
|
|
*/
|
|
readonly fields: EventFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Event.
|
|
* 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__EventClient<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 Event model
|
|
*/
|
|
interface EventFieldRefs {
|
|
readonly id: FieldRef<"Event", 'String'>
|
|
readonly type: FieldRef<"Event", 'String'>
|
|
readonly status: FieldRef<"Event", 'String'>
|
|
readonly startTime: FieldRef<"Event", 'DateTime'>
|
|
readonly endTime: FieldRef<"Event", 'DateTime'>
|
|
readonly targetUnitId: FieldRef<"Event", 'String'>
|
|
readonly targetGroupId: FieldRef<"Event", 'String'>
|
|
readonly targetPersonId: FieldRef<"Event", 'String'>
|
|
readonly payload: FieldRef<"Event", 'Json'>
|
|
readonly parentEventId: FieldRef<"Event", 'String'>
|
|
readonly createdAt: FieldRef<"Event", 'DateTime'>
|
|
readonly updatedAt: FieldRef<"Event", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Event findUnique
|
|
*/
|
|
export type EventFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which Event to fetch.
|
|
*/
|
|
where: EventWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Event findUniqueOrThrow
|
|
*/
|
|
export type EventFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which Event to fetch.
|
|
*/
|
|
where: EventWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Event findFirst
|
|
*/
|
|
export type EventFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which Event to fetch.
|
|
*/
|
|
where?: EventWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Events to fetch.
|
|
*/
|
|
orderBy?: EventOrderByWithRelationInput | EventOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Events.
|
|
*/
|
|
cursor?: EventWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Events 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` Events.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Events.
|
|
*/
|
|
distinct?: EventScalarFieldEnum | EventScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Event findFirstOrThrow
|
|
*/
|
|
export type EventFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which Event to fetch.
|
|
*/
|
|
where?: EventWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Events to fetch.
|
|
*/
|
|
orderBy?: EventOrderByWithRelationInput | EventOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Events.
|
|
*/
|
|
cursor?: EventWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Events 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` Events.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Events.
|
|
*/
|
|
distinct?: EventScalarFieldEnum | EventScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Event findMany
|
|
*/
|
|
export type EventFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which Events to fetch.
|
|
*/
|
|
where?: EventWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Events to fetch.
|
|
*/
|
|
orderBy?: EventOrderByWithRelationInput | EventOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Events.
|
|
*/
|
|
cursor?: EventWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Events 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` Events.
|
|
*/
|
|
skip?: number
|
|
distinct?: EventScalarFieldEnum | EventScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Event create
|
|
*/
|
|
export type EventCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Event.
|
|
*/
|
|
data: XOR<EventCreateInput, EventUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Event createMany
|
|
*/
|
|
export type EventCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Events.
|
|
*/
|
|
data: EventCreateManyInput | EventCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Event createManyAndReturn
|
|
*/
|
|
export type EventCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Events.
|
|
*/
|
|
data: EventCreateManyInput | EventCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Event update
|
|
*/
|
|
export type EventUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Event.
|
|
*/
|
|
data: XOR<EventUpdateInput, EventUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Event to update.
|
|
*/
|
|
where: EventWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Event updateMany
|
|
*/
|
|
export type EventUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Events.
|
|
*/
|
|
data: XOR<EventUpdateManyMutationInput, EventUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Events to update
|
|
*/
|
|
where?: EventWhereInput
|
|
/**
|
|
* Limit how many Events to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Event updateManyAndReturn
|
|
*/
|
|
export type EventUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Events.
|
|
*/
|
|
data: XOR<EventUpdateManyMutationInput, EventUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Events to update
|
|
*/
|
|
where?: EventWhereInput
|
|
/**
|
|
* Limit how many Events to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Event upsert
|
|
*/
|
|
export type EventUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Event to update in case it exists.
|
|
*/
|
|
where: EventWhereUniqueInput
|
|
/**
|
|
* In case the Event found by the `where` argument doesn't exist, create a new Event with this data.
|
|
*/
|
|
create: XOR<EventCreateInput, EventUncheckedCreateInput>
|
|
/**
|
|
* In case the Event was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<EventUpdateInput, EventUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Event delete
|
|
*/
|
|
export type EventDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
/**
|
|
* Filter which Event to delete.
|
|
*/
|
|
where: EventWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Event deleteMany
|
|
*/
|
|
export type EventDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Events to delete
|
|
*/
|
|
where?: EventWhereInput
|
|
/**
|
|
* Limit how many Events to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Event without action
|
|
*/
|
|
export type EventDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Event
|
|
*/
|
|
select?: EventSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Event
|
|
*/
|
|
omit?: EventOmit<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model cities
|
|
*/
|
|
|
|
export type AggregateCities = {
|
|
_count: CitiesCountAggregateOutputType | null
|
|
_avg: CitiesAvgAggregateOutputType | null
|
|
_sum: CitiesSumAggregateOutputType | null
|
|
_min: CitiesMinAggregateOutputType | null
|
|
_max: CitiesMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type CitiesAvgAggregateOutputType = {
|
|
id: number | null
|
|
state_id: number | null
|
|
country_id: number | null
|
|
level: number | null
|
|
parent_id: number | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
population: number | null
|
|
flag: number | null
|
|
}
|
|
|
|
export type CitiesSumAggregateOutputType = {
|
|
id: bigint | null
|
|
state_id: bigint | null
|
|
country_id: bigint | null
|
|
level: number | null
|
|
parent_id: bigint | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
population: bigint | null
|
|
flag: number | null
|
|
}
|
|
|
|
export type CitiesMinAggregateOutputType = {
|
|
id: bigint | null
|
|
name: string | null
|
|
state_id: bigint | null
|
|
state_code: string | null
|
|
country_id: bigint | null
|
|
country_code: string | null
|
|
type: string | null
|
|
level: number | null
|
|
parent_id: bigint | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
native: string | null
|
|
population: bigint | null
|
|
timezone: string | null
|
|
translations: string | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
flag: number | null
|
|
wikiDataId: string | null
|
|
}
|
|
|
|
export type CitiesMaxAggregateOutputType = {
|
|
id: bigint | null
|
|
name: string | null
|
|
state_id: bigint | null
|
|
state_code: string | null
|
|
country_id: bigint | null
|
|
country_code: string | null
|
|
type: string | null
|
|
level: number | null
|
|
parent_id: bigint | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
native: string | null
|
|
population: bigint | null
|
|
timezone: string | null
|
|
translations: string | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
flag: number | null
|
|
wikiDataId: string | null
|
|
}
|
|
|
|
export type CitiesCountAggregateOutputType = {
|
|
id: number
|
|
name: number
|
|
state_id: number
|
|
state_code: number
|
|
country_id: number
|
|
country_code: number
|
|
type: number
|
|
level: number
|
|
parent_id: number
|
|
latitude: number
|
|
longitude: number
|
|
native: number
|
|
population: number
|
|
timezone: number
|
|
translations: number
|
|
created_at: number
|
|
updated_at: number
|
|
flag: number
|
|
wikiDataId: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type CitiesAvgAggregateInputType = {
|
|
id?: true
|
|
state_id?: true
|
|
country_id?: true
|
|
level?: true
|
|
parent_id?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
population?: true
|
|
flag?: true
|
|
}
|
|
|
|
export type CitiesSumAggregateInputType = {
|
|
id?: true
|
|
state_id?: true
|
|
country_id?: true
|
|
level?: true
|
|
parent_id?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
population?: true
|
|
flag?: true
|
|
}
|
|
|
|
export type CitiesMinAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
state_id?: true
|
|
state_code?: true
|
|
country_id?: true
|
|
country_code?: true
|
|
type?: true
|
|
level?: true
|
|
parent_id?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
native?: true
|
|
population?: true
|
|
timezone?: true
|
|
translations?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
flag?: true
|
|
wikiDataId?: true
|
|
}
|
|
|
|
export type CitiesMaxAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
state_id?: true
|
|
state_code?: true
|
|
country_id?: true
|
|
country_code?: true
|
|
type?: true
|
|
level?: true
|
|
parent_id?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
native?: true
|
|
population?: true
|
|
timezone?: true
|
|
translations?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
flag?: true
|
|
wikiDataId?: true
|
|
}
|
|
|
|
export type CitiesCountAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
state_id?: true
|
|
state_code?: true
|
|
country_id?: true
|
|
country_code?: true
|
|
type?: true
|
|
level?: true
|
|
parent_id?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
native?: true
|
|
population?: true
|
|
timezone?: true
|
|
translations?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
flag?: true
|
|
wikiDataId?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type CitiesAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which cities to aggregate.
|
|
*/
|
|
where?: citiesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of cities to fetch.
|
|
*/
|
|
orderBy?: citiesOrderByWithRelationInput | citiesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: citiesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` cities 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` cities.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned cities
|
|
**/
|
|
_count?: true | CitiesCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: CitiesAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: CitiesSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: CitiesMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: CitiesMaxAggregateInputType
|
|
}
|
|
|
|
export type GetCitiesAggregateType<T extends CitiesAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateCities]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateCities[P]>
|
|
: GetScalarType<T[P], AggregateCities[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type citiesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: citiesWhereInput
|
|
orderBy?: citiesOrderByWithAggregationInput | citiesOrderByWithAggregationInput[]
|
|
by: CitiesScalarFieldEnum[] | CitiesScalarFieldEnum
|
|
having?: citiesScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: CitiesCountAggregateInputType | true
|
|
_avg?: CitiesAvgAggregateInputType
|
|
_sum?: CitiesSumAggregateInputType
|
|
_min?: CitiesMinAggregateInputType
|
|
_max?: CitiesMaxAggregateInputType
|
|
}
|
|
|
|
export type CitiesGroupByOutputType = {
|
|
id: bigint
|
|
name: string
|
|
state_id: bigint
|
|
state_code: string
|
|
country_id: bigint
|
|
country_code: string
|
|
type: string | null
|
|
level: number | null
|
|
parent_id: bigint | null
|
|
latitude: Decimal
|
|
longitude: Decimal
|
|
native: string | null
|
|
population: bigint | null
|
|
timezone: string | null
|
|
translations: string | null
|
|
created_at: Date
|
|
updated_at: Date
|
|
flag: number
|
|
wikiDataId: string | null
|
|
_count: CitiesCountAggregateOutputType | null
|
|
_avg: CitiesAvgAggregateOutputType | null
|
|
_sum: CitiesSumAggregateOutputType | null
|
|
_min: CitiesMinAggregateOutputType | null
|
|
_max: CitiesMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetCitiesGroupByPayload<T extends citiesGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<CitiesGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof CitiesGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], CitiesGroupByOutputType[P]>
|
|
: GetScalarType<T[P], CitiesGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type citiesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
state_id?: boolean
|
|
state_code?: boolean
|
|
country_id?: boolean
|
|
country_code?: boolean
|
|
type?: boolean
|
|
level?: boolean
|
|
parent_id?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
native?: boolean
|
|
population?: boolean
|
|
timezone?: boolean
|
|
translations?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
states?: boolean | statesDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["cities"]>
|
|
|
|
export type citiesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
state_id?: boolean
|
|
state_code?: boolean
|
|
country_id?: boolean
|
|
country_code?: boolean
|
|
type?: boolean
|
|
level?: boolean
|
|
parent_id?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
native?: boolean
|
|
population?: boolean
|
|
timezone?: boolean
|
|
translations?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
states?: boolean | statesDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["cities"]>
|
|
|
|
export type citiesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
state_id?: boolean
|
|
state_code?: boolean
|
|
country_id?: boolean
|
|
country_code?: boolean
|
|
type?: boolean
|
|
level?: boolean
|
|
parent_id?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
native?: boolean
|
|
population?: boolean
|
|
timezone?: boolean
|
|
translations?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
states?: boolean | statesDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["cities"]>
|
|
|
|
export type citiesSelectScalar = {
|
|
id?: boolean
|
|
name?: boolean
|
|
state_id?: boolean
|
|
state_code?: boolean
|
|
country_id?: boolean
|
|
country_code?: boolean
|
|
type?: boolean
|
|
level?: boolean
|
|
parent_id?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
native?: boolean
|
|
population?: boolean
|
|
timezone?: boolean
|
|
translations?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
}
|
|
|
|
export type citiesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "state_id" | "state_code" | "country_id" | "country_code" | "type" | "level" | "parent_id" | "latitude" | "longitude" | "native" | "population" | "timezone" | "translations" | "created_at" | "updated_at" | "flag" | "wikiDataId", ExtArgs["result"]["cities"]>
|
|
export type citiesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
states?: boolean | statesDefaultArgs<ExtArgs>
|
|
}
|
|
export type citiesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
states?: boolean | statesDefaultArgs<ExtArgs>
|
|
}
|
|
export type citiesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
states?: boolean | statesDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $citiesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "cities"
|
|
objects: {
|
|
countries: Prisma.$countriesPayload<ExtArgs>
|
|
states: Prisma.$statesPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: bigint
|
|
name: string
|
|
state_id: bigint
|
|
state_code: string
|
|
country_id: bigint
|
|
country_code: string
|
|
type: string | null
|
|
level: number | null
|
|
parent_id: bigint | null
|
|
latitude: Prisma.Decimal
|
|
longitude: Prisma.Decimal
|
|
native: string | null
|
|
population: bigint | null
|
|
timezone: string | null
|
|
translations: string | null
|
|
created_at: Date
|
|
updated_at: Date
|
|
flag: number
|
|
wikiDataId: string | null
|
|
}, ExtArgs["result"]["cities"]>
|
|
composites: {}
|
|
}
|
|
|
|
type citiesGetPayload<S extends boolean | null | undefined | citiesDefaultArgs> = $Result.GetResult<Prisma.$citiesPayload, S>
|
|
|
|
type citiesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<citiesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: CitiesCountAggregateInputType | true
|
|
}
|
|
|
|
export interface citiesDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['cities'], meta: { name: 'cities' } }
|
|
/**
|
|
* Find zero or one Cities that matches the filter.
|
|
* @param {citiesFindUniqueArgs} args - Arguments to find a Cities
|
|
* @example
|
|
* // Get one Cities
|
|
* const cities = await prisma.cities.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends citiesFindUniqueArgs>(args: SelectSubset<T, citiesFindUniqueArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Cities that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {citiesFindUniqueOrThrowArgs} args - Arguments to find a Cities
|
|
* @example
|
|
* // Get one Cities
|
|
* const cities = await prisma.cities.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends citiesFindUniqueOrThrowArgs>(args: SelectSubset<T, citiesFindUniqueOrThrowArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Cities 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 {citiesFindFirstArgs} args - Arguments to find a Cities
|
|
* @example
|
|
* // Get one Cities
|
|
* const cities = await prisma.cities.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends citiesFindFirstArgs>(args?: SelectSubset<T, citiesFindFirstArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Cities 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 {citiesFindFirstOrThrowArgs} args - Arguments to find a Cities
|
|
* @example
|
|
* // Get one Cities
|
|
* const cities = await prisma.cities.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends citiesFindFirstOrThrowArgs>(args?: SelectSubset<T, citiesFindFirstOrThrowArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Cities 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 {citiesFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Cities
|
|
* const cities = await prisma.cities.findMany()
|
|
*
|
|
* // Get first 10 Cities
|
|
* const cities = await prisma.cities.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const citiesWithIdOnly = await prisma.cities.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends citiesFindManyArgs>(args?: SelectSubset<T, citiesFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Cities.
|
|
* @param {citiesCreateArgs} args - Arguments to create a Cities.
|
|
* @example
|
|
* // Create one Cities
|
|
* const Cities = await prisma.cities.create({
|
|
* data: {
|
|
* // ... data to create a Cities
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends citiesCreateArgs>(args: SelectSubset<T, citiesCreateArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Cities.
|
|
* @param {citiesCreateManyArgs} args - Arguments to create many Cities.
|
|
* @example
|
|
* // Create many Cities
|
|
* const cities = await prisma.cities.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends citiesCreateManyArgs>(args?: SelectSubset<T, citiesCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Cities and returns the data saved in the database.
|
|
* @param {citiesCreateManyAndReturnArgs} args - Arguments to create many Cities.
|
|
* @example
|
|
* // Create many Cities
|
|
* const cities = await prisma.cities.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Cities and only return the `id`
|
|
* const citiesWithIdOnly = await prisma.cities.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 citiesCreateManyAndReturnArgs>(args?: SelectSubset<T, citiesCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Cities.
|
|
* @param {citiesDeleteArgs} args - Arguments to delete one Cities.
|
|
* @example
|
|
* // Delete one Cities
|
|
* const Cities = await prisma.cities.delete({
|
|
* where: {
|
|
* // ... filter to delete one Cities
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends citiesDeleteArgs>(args: SelectSubset<T, citiesDeleteArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Cities.
|
|
* @param {citiesUpdateArgs} args - Arguments to update one Cities.
|
|
* @example
|
|
* // Update one Cities
|
|
* const cities = await prisma.cities.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends citiesUpdateArgs>(args: SelectSubset<T, citiesUpdateArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Cities.
|
|
* @param {citiesDeleteManyArgs} args - Arguments to filter Cities to delete.
|
|
* @example
|
|
* // Delete a few Cities
|
|
* const { count } = await prisma.cities.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends citiesDeleteManyArgs>(args?: SelectSubset<T, citiesDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Cities.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {citiesUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Cities
|
|
* const cities = await prisma.cities.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends citiesUpdateManyArgs>(args: SelectSubset<T, citiesUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Cities and returns the data updated in the database.
|
|
* @param {citiesUpdateManyAndReturnArgs} args - Arguments to update many Cities.
|
|
* @example
|
|
* // Update many Cities
|
|
* const cities = await prisma.cities.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Cities and only return the `id`
|
|
* const citiesWithIdOnly = await prisma.cities.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 citiesUpdateManyAndReturnArgs>(args: SelectSubset<T, citiesUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Cities.
|
|
* @param {citiesUpsertArgs} args - Arguments to update or create a Cities.
|
|
* @example
|
|
* // Update or create a Cities
|
|
* const cities = await prisma.cities.upsert({
|
|
* create: {
|
|
* // ... data to create a Cities
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Cities we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends citiesUpsertArgs>(args: SelectSubset<T, citiesUpsertArgs<ExtArgs>>): Prisma__citiesClient<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Cities.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {citiesCountArgs} args - Arguments to filter Cities to count.
|
|
* @example
|
|
* // Count the number of Cities
|
|
* const count = await prisma.cities.count({
|
|
* where: {
|
|
* // ... the filter for the Cities we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends citiesCountArgs>(
|
|
args?: Subset<T, citiesCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], CitiesCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Cities.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CitiesAggregateArgs} 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 CitiesAggregateArgs>(args: Subset<T, CitiesAggregateArgs>): Prisma.PrismaPromise<GetCitiesAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Cities.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {citiesGroupByArgs} 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 citiesGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: citiesGroupByArgs['orderBy'] }
|
|
: { orderBy?: citiesGroupByArgs['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, citiesGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCitiesGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the cities model
|
|
*/
|
|
readonly fields: citiesFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for cities.
|
|
* 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__citiesClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
countries<T extends countriesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, countriesDefaultArgs<ExtArgs>>): Prisma__countriesClient<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions> | Null, Null, ExtArgs, GlobalOmitOptions>
|
|
states<T extends statesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, statesDefaultArgs<ExtArgs>>): Prisma__statesClient<$Result.GetResult<Prisma.$statesPayload<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 cities model
|
|
*/
|
|
interface citiesFieldRefs {
|
|
readonly id: FieldRef<"cities", 'BigInt'>
|
|
readonly name: FieldRef<"cities", 'String'>
|
|
readonly state_id: FieldRef<"cities", 'BigInt'>
|
|
readonly state_code: FieldRef<"cities", 'String'>
|
|
readonly country_id: FieldRef<"cities", 'BigInt'>
|
|
readonly country_code: FieldRef<"cities", 'String'>
|
|
readonly type: FieldRef<"cities", 'String'>
|
|
readonly level: FieldRef<"cities", 'Int'>
|
|
readonly parent_id: FieldRef<"cities", 'BigInt'>
|
|
readonly latitude: FieldRef<"cities", 'Decimal'>
|
|
readonly longitude: FieldRef<"cities", 'Decimal'>
|
|
readonly native: FieldRef<"cities", 'String'>
|
|
readonly population: FieldRef<"cities", 'BigInt'>
|
|
readonly timezone: FieldRef<"cities", 'String'>
|
|
readonly translations: FieldRef<"cities", 'String'>
|
|
readonly created_at: FieldRef<"cities", 'DateTime'>
|
|
readonly updated_at: FieldRef<"cities", 'DateTime'>
|
|
readonly flag: FieldRef<"cities", 'Int'>
|
|
readonly wikiDataId: FieldRef<"cities", 'String'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* cities findUnique
|
|
*/
|
|
export type citiesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which cities to fetch.
|
|
*/
|
|
where: citiesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* cities findUniqueOrThrow
|
|
*/
|
|
export type citiesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which cities to fetch.
|
|
*/
|
|
where: citiesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* cities findFirst
|
|
*/
|
|
export type citiesFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which cities to fetch.
|
|
*/
|
|
where?: citiesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of cities to fetch.
|
|
*/
|
|
orderBy?: citiesOrderByWithRelationInput | citiesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for cities.
|
|
*/
|
|
cursor?: citiesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` cities 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` cities.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of cities.
|
|
*/
|
|
distinct?: CitiesScalarFieldEnum | CitiesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* cities findFirstOrThrow
|
|
*/
|
|
export type citiesFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which cities to fetch.
|
|
*/
|
|
where?: citiesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of cities to fetch.
|
|
*/
|
|
orderBy?: citiesOrderByWithRelationInput | citiesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for cities.
|
|
*/
|
|
cursor?: citiesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` cities 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` cities.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of cities.
|
|
*/
|
|
distinct?: CitiesScalarFieldEnum | CitiesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* cities findMany
|
|
*/
|
|
export type citiesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which cities to fetch.
|
|
*/
|
|
where?: citiesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of cities to fetch.
|
|
*/
|
|
orderBy?: citiesOrderByWithRelationInput | citiesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing cities.
|
|
*/
|
|
cursor?: citiesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` cities 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` cities.
|
|
*/
|
|
skip?: number
|
|
distinct?: CitiesScalarFieldEnum | CitiesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* cities create
|
|
*/
|
|
export type citiesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a cities.
|
|
*/
|
|
data: XOR<citiesCreateInput, citiesUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* cities createMany
|
|
*/
|
|
export type citiesCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many cities.
|
|
*/
|
|
data: citiesCreateManyInput | citiesCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* cities createManyAndReturn
|
|
*/
|
|
export type citiesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many cities.
|
|
*/
|
|
data: citiesCreateManyInput | citiesCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* cities update
|
|
*/
|
|
export type citiesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a cities.
|
|
*/
|
|
data: XOR<citiesUpdateInput, citiesUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which cities to update.
|
|
*/
|
|
where: citiesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* cities updateMany
|
|
*/
|
|
export type citiesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update cities.
|
|
*/
|
|
data: XOR<citiesUpdateManyMutationInput, citiesUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which cities to update
|
|
*/
|
|
where?: citiesWhereInput
|
|
/**
|
|
* Limit how many cities to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* cities updateManyAndReturn
|
|
*/
|
|
export type citiesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update cities.
|
|
*/
|
|
data: XOR<citiesUpdateManyMutationInput, citiesUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which cities to update
|
|
*/
|
|
where?: citiesWhereInput
|
|
/**
|
|
* Limit how many cities to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* cities upsert
|
|
*/
|
|
export type citiesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the cities to update in case it exists.
|
|
*/
|
|
where: citiesWhereUniqueInput
|
|
/**
|
|
* In case the cities found by the `where` argument doesn't exist, create a new cities with this data.
|
|
*/
|
|
create: XOR<citiesCreateInput, citiesUncheckedCreateInput>
|
|
/**
|
|
* In case the cities was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<citiesUpdateInput, citiesUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* cities delete
|
|
*/
|
|
export type citiesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which cities to delete.
|
|
*/
|
|
where: citiesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* cities deleteMany
|
|
*/
|
|
export type citiesDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which cities to delete
|
|
*/
|
|
where?: citiesWhereInput
|
|
/**
|
|
* Limit how many cities to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* cities without action
|
|
*/
|
|
export type citiesDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model countries
|
|
*/
|
|
|
|
export type AggregateCountries = {
|
|
_count: CountriesCountAggregateOutputType | null
|
|
_avg: CountriesAvgAggregateOutputType | null
|
|
_sum: CountriesSumAggregateOutputType | null
|
|
_min: CountriesMinAggregateOutputType | null
|
|
_max: CountriesMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type CountriesAvgAggregateOutputType = {
|
|
id: number | null
|
|
population: number | null
|
|
gdp: number | null
|
|
region_id: number | null
|
|
subregion_id: number | null
|
|
area_sq_km: number | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
flag: number | null
|
|
}
|
|
|
|
export type CountriesSumAggregateOutputType = {
|
|
id: bigint | null
|
|
population: bigint | null
|
|
gdp: bigint | null
|
|
region_id: bigint | null
|
|
subregion_id: bigint | null
|
|
area_sq_km: number | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
flag: number | null
|
|
}
|
|
|
|
export type CountriesMinAggregateOutputType = {
|
|
id: bigint | null
|
|
name: string | null
|
|
iso3: string | null
|
|
numeric_code: string | null
|
|
iso2: string | null
|
|
phonecode: string | null
|
|
capital: string | null
|
|
currency: string | null
|
|
currency_name: string | null
|
|
currency_symbol: string | null
|
|
tld: string | null
|
|
native: string | null
|
|
population: bigint | null
|
|
gdp: bigint | null
|
|
region: string | null
|
|
region_id: bigint | null
|
|
subregion: string | null
|
|
subregion_id: bigint | null
|
|
nationality: string | null
|
|
area_sq_km: number | null
|
|
postal_code_format: string | null
|
|
postal_code_regex: string | null
|
|
timezones: string | null
|
|
translations: string | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
emoji: string | null
|
|
emojiU: string | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
flag: number | null
|
|
wikiDataId: string | null
|
|
}
|
|
|
|
export type CountriesMaxAggregateOutputType = {
|
|
id: bigint | null
|
|
name: string | null
|
|
iso3: string | null
|
|
numeric_code: string | null
|
|
iso2: string | null
|
|
phonecode: string | null
|
|
capital: string | null
|
|
currency: string | null
|
|
currency_name: string | null
|
|
currency_symbol: string | null
|
|
tld: string | null
|
|
native: string | null
|
|
population: bigint | null
|
|
gdp: bigint | null
|
|
region: string | null
|
|
region_id: bigint | null
|
|
subregion: string | null
|
|
subregion_id: bigint | null
|
|
nationality: string | null
|
|
area_sq_km: number | null
|
|
postal_code_format: string | null
|
|
postal_code_regex: string | null
|
|
timezones: string | null
|
|
translations: string | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
emoji: string | null
|
|
emojiU: string | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
flag: number | null
|
|
wikiDataId: string | null
|
|
}
|
|
|
|
export type CountriesCountAggregateOutputType = {
|
|
id: number
|
|
name: number
|
|
iso3: number
|
|
numeric_code: number
|
|
iso2: number
|
|
phonecode: number
|
|
capital: number
|
|
currency: number
|
|
currency_name: number
|
|
currency_symbol: number
|
|
tld: number
|
|
native: number
|
|
population: number
|
|
gdp: number
|
|
region: number
|
|
region_id: number
|
|
subregion: number
|
|
subregion_id: number
|
|
nationality: number
|
|
area_sq_km: number
|
|
postal_code_format: number
|
|
postal_code_regex: number
|
|
timezones: number
|
|
translations: number
|
|
latitude: number
|
|
longitude: number
|
|
emoji: number
|
|
emojiU: number
|
|
created_at: number
|
|
updated_at: number
|
|
flag: number
|
|
wikiDataId: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type CountriesAvgAggregateInputType = {
|
|
id?: true
|
|
population?: true
|
|
gdp?: true
|
|
region_id?: true
|
|
subregion_id?: true
|
|
area_sq_km?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
flag?: true
|
|
}
|
|
|
|
export type CountriesSumAggregateInputType = {
|
|
id?: true
|
|
population?: true
|
|
gdp?: true
|
|
region_id?: true
|
|
subregion_id?: true
|
|
area_sq_km?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
flag?: true
|
|
}
|
|
|
|
export type CountriesMinAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
iso3?: true
|
|
numeric_code?: true
|
|
iso2?: true
|
|
phonecode?: true
|
|
capital?: true
|
|
currency?: true
|
|
currency_name?: true
|
|
currency_symbol?: true
|
|
tld?: true
|
|
native?: true
|
|
population?: true
|
|
gdp?: true
|
|
region?: true
|
|
region_id?: true
|
|
subregion?: true
|
|
subregion_id?: true
|
|
nationality?: true
|
|
area_sq_km?: true
|
|
postal_code_format?: true
|
|
postal_code_regex?: true
|
|
timezones?: true
|
|
translations?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
emoji?: true
|
|
emojiU?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
flag?: true
|
|
wikiDataId?: true
|
|
}
|
|
|
|
export type CountriesMaxAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
iso3?: true
|
|
numeric_code?: true
|
|
iso2?: true
|
|
phonecode?: true
|
|
capital?: true
|
|
currency?: true
|
|
currency_name?: true
|
|
currency_symbol?: true
|
|
tld?: true
|
|
native?: true
|
|
population?: true
|
|
gdp?: true
|
|
region?: true
|
|
region_id?: true
|
|
subregion?: true
|
|
subregion_id?: true
|
|
nationality?: true
|
|
area_sq_km?: true
|
|
postal_code_format?: true
|
|
postal_code_regex?: true
|
|
timezones?: true
|
|
translations?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
emoji?: true
|
|
emojiU?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
flag?: true
|
|
wikiDataId?: true
|
|
}
|
|
|
|
export type CountriesCountAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
iso3?: true
|
|
numeric_code?: true
|
|
iso2?: true
|
|
phonecode?: true
|
|
capital?: true
|
|
currency?: true
|
|
currency_name?: true
|
|
currency_symbol?: true
|
|
tld?: true
|
|
native?: true
|
|
population?: true
|
|
gdp?: true
|
|
region?: true
|
|
region_id?: true
|
|
subregion?: true
|
|
subregion_id?: true
|
|
nationality?: true
|
|
area_sq_km?: true
|
|
postal_code_format?: true
|
|
postal_code_regex?: true
|
|
timezones?: true
|
|
translations?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
emoji?: true
|
|
emojiU?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
flag?: true
|
|
wikiDataId?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type CountriesAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which countries to aggregate.
|
|
*/
|
|
where?: countriesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of countries to fetch.
|
|
*/
|
|
orderBy?: countriesOrderByWithRelationInput | countriesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: countriesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` countries 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` countries.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned countries
|
|
**/
|
|
_count?: true | CountriesCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: CountriesAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: CountriesSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: CountriesMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: CountriesMaxAggregateInputType
|
|
}
|
|
|
|
export type GetCountriesAggregateType<T extends CountriesAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateCountries]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateCountries[P]>
|
|
: GetScalarType<T[P], AggregateCountries[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type countriesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: countriesWhereInput
|
|
orderBy?: countriesOrderByWithAggregationInput | countriesOrderByWithAggregationInput[]
|
|
by: CountriesScalarFieldEnum[] | CountriesScalarFieldEnum
|
|
having?: countriesScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: CountriesCountAggregateInputType | true
|
|
_avg?: CountriesAvgAggregateInputType
|
|
_sum?: CountriesSumAggregateInputType
|
|
_min?: CountriesMinAggregateInputType
|
|
_max?: CountriesMaxAggregateInputType
|
|
}
|
|
|
|
export type CountriesGroupByOutputType = {
|
|
id: bigint
|
|
name: string
|
|
iso3: string | null
|
|
numeric_code: string | null
|
|
iso2: string | null
|
|
phonecode: string | null
|
|
capital: string | null
|
|
currency: string | null
|
|
currency_name: string | null
|
|
currency_symbol: string | null
|
|
tld: string | null
|
|
native: string | null
|
|
population: bigint | null
|
|
gdp: bigint | null
|
|
region: string | null
|
|
region_id: bigint | null
|
|
subregion: string | null
|
|
subregion_id: bigint | null
|
|
nationality: string | null
|
|
area_sq_km: number | null
|
|
postal_code_format: string | null
|
|
postal_code_regex: string | null
|
|
timezones: string | null
|
|
translations: string | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
emoji: string | null
|
|
emojiU: string | null
|
|
created_at: Date | null
|
|
updated_at: Date
|
|
flag: number
|
|
wikiDataId: string | null
|
|
_count: CountriesCountAggregateOutputType | null
|
|
_avg: CountriesAvgAggregateOutputType | null
|
|
_sum: CountriesSumAggregateOutputType | null
|
|
_min: CountriesMinAggregateOutputType | null
|
|
_max: CountriesMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetCountriesGroupByPayload<T extends countriesGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<CountriesGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof CountriesGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], CountriesGroupByOutputType[P]>
|
|
: GetScalarType<T[P], CountriesGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type countriesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
iso3?: boolean
|
|
numeric_code?: boolean
|
|
iso2?: boolean
|
|
phonecode?: boolean
|
|
capital?: boolean
|
|
currency?: boolean
|
|
currency_name?: boolean
|
|
currency_symbol?: boolean
|
|
tld?: boolean
|
|
native?: boolean
|
|
population?: boolean
|
|
gdp?: boolean
|
|
region?: boolean
|
|
region_id?: boolean
|
|
subregion?: boolean
|
|
subregion_id?: boolean
|
|
nationality?: boolean
|
|
area_sq_km?: boolean
|
|
postal_code_format?: boolean
|
|
postal_code_regex?: boolean
|
|
timezones?: boolean
|
|
translations?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
emoji?: boolean
|
|
emojiU?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
cities?: boolean | countries$citiesArgs<ExtArgs>
|
|
states?: boolean | countries$statesArgs<ExtArgs>
|
|
_count?: boolean | CountriesCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["countries"]>
|
|
|
|
export type countriesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
iso3?: boolean
|
|
numeric_code?: boolean
|
|
iso2?: boolean
|
|
phonecode?: boolean
|
|
capital?: boolean
|
|
currency?: boolean
|
|
currency_name?: boolean
|
|
currency_symbol?: boolean
|
|
tld?: boolean
|
|
native?: boolean
|
|
population?: boolean
|
|
gdp?: boolean
|
|
region?: boolean
|
|
region_id?: boolean
|
|
subregion?: boolean
|
|
subregion_id?: boolean
|
|
nationality?: boolean
|
|
area_sq_km?: boolean
|
|
postal_code_format?: boolean
|
|
postal_code_regex?: boolean
|
|
timezones?: boolean
|
|
translations?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
emoji?: boolean
|
|
emojiU?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
}, ExtArgs["result"]["countries"]>
|
|
|
|
export type countriesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
iso3?: boolean
|
|
numeric_code?: boolean
|
|
iso2?: boolean
|
|
phonecode?: boolean
|
|
capital?: boolean
|
|
currency?: boolean
|
|
currency_name?: boolean
|
|
currency_symbol?: boolean
|
|
tld?: boolean
|
|
native?: boolean
|
|
population?: boolean
|
|
gdp?: boolean
|
|
region?: boolean
|
|
region_id?: boolean
|
|
subregion?: boolean
|
|
subregion_id?: boolean
|
|
nationality?: boolean
|
|
area_sq_km?: boolean
|
|
postal_code_format?: boolean
|
|
postal_code_regex?: boolean
|
|
timezones?: boolean
|
|
translations?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
emoji?: boolean
|
|
emojiU?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
}, ExtArgs["result"]["countries"]>
|
|
|
|
export type countriesSelectScalar = {
|
|
id?: boolean
|
|
name?: boolean
|
|
iso3?: boolean
|
|
numeric_code?: boolean
|
|
iso2?: boolean
|
|
phonecode?: boolean
|
|
capital?: boolean
|
|
currency?: boolean
|
|
currency_name?: boolean
|
|
currency_symbol?: boolean
|
|
tld?: boolean
|
|
native?: boolean
|
|
population?: boolean
|
|
gdp?: boolean
|
|
region?: boolean
|
|
region_id?: boolean
|
|
subregion?: boolean
|
|
subregion_id?: boolean
|
|
nationality?: boolean
|
|
area_sq_km?: boolean
|
|
postal_code_format?: boolean
|
|
postal_code_regex?: boolean
|
|
timezones?: boolean
|
|
translations?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
emoji?: boolean
|
|
emojiU?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
}
|
|
|
|
export type countriesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "iso3" | "numeric_code" | "iso2" | "phonecode" | "capital" | "currency" | "currency_name" | "currency_symbol" | "tld" | "native" | "population" | "gdp" | "region" | "region_id" | "subregion" | "subregion_id" | "nationality" | "area_sq_km" | "postal_code_format" | "postal_code_regex" | "timezones" | "translations" | "latitude" | "longitude" | "emoji" | "emojiU" | "created_at" | "updated_at" | "flag" | "wikiDataId", ExtArgs["result"]["countries"]>
|
|
export type countriesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
cities?: boolean | countries$citiesArgs<ExtArgs>
|
|
states?: boolean | countries$statesArgs<ExtArgs>
|
|
_count?: boolean | CountriesCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type countriesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
export type countriesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}
|
|
|
|
export type $countriesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "countries"
|
|
objects: {
|
|
cities: Prisma.$citiesPayload<ExtArgs>[]
|
|
states: Prisma.$statesPayload<ExtArgs>[]
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: bigint
|
|
name: string
|
|
iso3: string | null
|
|
numeric_code: string | null
|
|
iso2: string | null
|
|
phonecode: string | null
|
|
capital: string | null
|
|
currency: string | null
|
|
currency_name: string | null
|
|
currency_symbol: string | null
|
|
tld: string | null
|
|
native: string | null
|
|
population: bigint | null
|
|
gdp: bigint | null
|
|
region: string | null
|
|
region_id: bigint | null
|
|
subregion: string | null
|
|
subregion_id: bigint | null
|
|
nationality: string | null
|
|
area_sq_km: number | null
|
|
postal_code_format: string | null
|
|
postal_code_regex: string | null
|
|
timezones: string | null
|
|
translations: string | null
|
|
latitude: Prisma.Decimal | null
|
|
longitude: Prisma.Decimal | null
|
|
emoji: string | null
|
|
emojiU: string | null
|
|
created_at: Date | null
|
|
updated_at: Date
|
|
flag: number
|
|
wikiDataId: string | null
|
|
}, ExtArgs["result"]["countries"]>
|
|
composites: {}
|
|
}
|
|
|
|
type countriesGetPayload<S extends boolean | null | undefined | countriesDefaultArgs> = $Result.GetResult<Prisma.$countriesPayload, S>
|
|
|
|
type countriesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<countriesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: CountriesCountAggregateInputType | true
|
|
}
|
|
|
|
export interface countriesDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['countries'], meta: { name: 'countries' } }
|
|
/**
|
|
* Find zero or one Countries that matches the filter.
|
|
* @param {countriesFindUniqueArgs} args - Arguments to find a Countries
|
|
* @example
|
|
* // Get one Countries
|
|
* const countries = await prisma.countries.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends countriesFindUniqueArgs>(args: SelectSubset<T, countriesFindUniqueArgs<ExtArgs>>): Prisma__countriesClient<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Countries that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {countriesFindUniqueOrThrowArgs} args - Arguments to find a Countries
|
|
* @example
|
|
* // Get one Countries
|
|
* const countries = await prisma.countries.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends countriesFindUniqueOrThrowArgs>(args: SelectSubset<T, countriesFindUniqueOrThrowArgs<ExtArgs>>): Prisma__countriesClient<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Countries 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 {countriesFindFirstArgs} args - Arguments to find a Countries
|
|
* @example
|
|
* // Get one Countries
|
|
* const countries = await prisma.countries.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends countriesFindFirstArgs>(args?: SelectSubset<T, countriesFindFirstArgs<ExtArgs>>): Prisma__countriesClient<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Countries 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 {countriesFindFirstOrThrowArgs} args - Arguments to find a Countries
|
|
* @example
|
|
* // Get one Countries
|
|
* const countries = await prisma.countries.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends countriesFindFirstOrThrowArgs>(args?: SelectSubset<T, countriesFindFirstOrThrowArgs<ExtArgs>>): Prisma__countriesClient<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Countries 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 {countriesFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Countries
|
|
* const countries = await prisma.countries.findMany()
|
|
*
|
|
* // Get first 10 Countries
|
|
* const countries = await prisma.countries.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const countriesWithIdOnly = await prisma.countries.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends countriesFindManyArgs>(args?: SelectSubset<T, countriesFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Countries.
|
|
* @param {countriesCreateArgs} args - Arguments to create a Countries.
|
|
* @example
|
|
* // Create one Countries
|
|
* const Countries = await prisma.countries.create({
|
|
* data: {
|
|
* // ... data to create a Countries
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends countriesCreateArgs>(args: SelectSubset<T, countriesCreateArgs<ExtArgs>>): Prisma__countriesClient<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Countries.
|
|
* @param {countriesCreateManyArgs} args - Arguments to create many Countries.
|
|
* @example
|
|
* // Create many Countries
|
|
* const countries = await prisma.countries.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends countriesCreateManyArgs>(args?: SelectSubset<T, countriesCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Countries and returns the data saved in the database.
|
|
* @param {countriesCreateManyAndReturnArgs} args - Arguments to create many Countries.
|
|
* @example
|
|
* // Create many Countries
|
|
* const countries = await prisma.countries.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Countries and only return the `id`
|
|
* const countriesWithIdOnly = await prisma.countries.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 countriesCreateManyAndReturnArgs>(args?: SelectSubset<T, countriesCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Countries.
|
|
* @param {countriesDeleteArgs} args - Arguments to delete one Countries.
|
|
* @example
|
|
* // Delete one Countries
|
|
* const Countries = await prisma.countries.delete({
|
|
* where: {
|
|
* // ... filter to delete one Countries
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends countriesDeleteArgs>(args: SelectSubset<T, countriesDeleteArgs<ExtArgs>>): Prisma__countriesClient<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Countries.
|
|
* @param {countriesUpdateArgs} args - Arguments to update one Countries.
|
|
* @example
|
|
* // Update one Countries
|
|
* const countries = await prisma.countries.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends countriesUpdateArgs>(args: SelectSubset<T, countriesUpdateArgs<ExtArgs>>): Prisma__countriesClient<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Countries.
|
|
* @param {countriesDeleteManyArgs} args - Arguments to filter Countries to delete.
|
|
* @example
|
|
* // Delete a few Countries
|
|
* const { count } = await prisma.countries.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends countriesDeleteManyArgs>(args?: SelectSubset<T, countriesDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Countries.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {countriesUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Countries
|
|
* const countries = await prisma.countries.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends countriesUpdateManyArgs>(args: SelectSubset<T, countriesUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Countries and returns the data updated in the database.
|
|
* @param {countriesUpdateManyAndReturnArgs} args - Arguments to update many Countries.
|
|
* @example
|
|
* // Update many Countries
|
|
* const countries = await prisma.countries.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Countries and only return the `id`
|
|
* const countriesWithIdOnly = await prisma.countries.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 countriesUpdateManyAndReturnArgs>(args: SelectSubset<T, countriesUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Countries.
|
|
* @param {countriesUpsertArgs} args - Arguments to update or create a Countries.
|
|
* @example
|
|
* // Update or create a Countries
|
|
* const countries = await prisma.countries.upsert({
|
|
* create: {
|
|
* // ... data to create a Countries
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Countries we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends countriesUpsertArgs>(args: SelectSubset<T, countriesUpsertArgs<ExtArgs>>): Prisma__countriesClient<$Result.GetResult<Prisma.$countriesPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Countries.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {countriesCountArgs} args - Arguments to filter Countries to count.
|
|
* @example
|
|
* // Count the number of Countries
|
|
* const count = await prisma.countries.count({
|
|
* where: {
|
|
* // ... the filter for the Countries we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends countriesCountArgs>(
|
|
args?: Subset<T, countriesCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], CountriesCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Countries.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {CountriesAggregateArgs} 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 CountriesAggregateArgs>(args: Subset<T, CountriesAggregateArgs>): Prisma.PrismaPromise<GetCountriesAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Countries.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {countriesGroupByArgs} 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 countriesGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: countriesGroupByArgs['orderBy'] }
|
|
: { orderBy?: countriesGroupByArgs['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, countriesGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCountriesGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the countries model
|
|
*/
|
|
readonly fields: countriesFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for countries.
|
|
* 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__countriesClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
cities<T extends countries$citiesArgs<ExtArgs> = {}>(args?: Subset<T, countries$citiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
states<T extends countries$statesArgs<ExtArgs> = {}>(args?: Subset<T, countries$statesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$statesPayload<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 countries model
|
|
*/
|
|
interface countriesFieldRefs {
|
|
readonly id: FieldRef<"countries", 'BigInt'>
|
|
readonly name: FieldRef<"countries", 'String'>
|
|
readonly iso3: FieldRef<"countries", 'String'>
|
|
readonly numeric_code: FieldRef<"countries", 'String'>
|
|
readonly iso2: FieldRef<"countries", 'String'>
|
|
readonly phonecode: FieldRef<"countries", 'String'>
|
|
readonly capital: FieldRef<"countries", 'String'>
|
|
readonly currency: FieldRef<"countries", 'String'>
|
|
readonly currency_name: FieldRef<"countries", 'String'>
|
|
readonly currency_symbol: FieldRef<"countries", 'String'>
|
|
readonly tld: FieldRef<"countries", 'String'>
|
|
readonly native: FieldRef<"countries", 'String'>
|
|
readonly population: FieldRef<"countries", 'BigInt'>
|
|
readonly gdp: FieldRef<"countries", 'BigInt'>
|
|
readonly region: FieldRef<"countries", 'String'>
|
|
readonly region_id: FieldRef<"countries", 'BigInt'>
|
|
readonly subregion: FieldRef<"countries", 'String'>
|
|
readonly subregion_id: FieldRef<"countries", 'BigInt'>
|
|
readonly nationality: FieldRef<"countries", 'String'>
|
|
readonly area_sq_km: FieldRef<"countries", 'Float'>
|
|
readonly postal_code_format: FieldRef<"countries", 'String'>
|
|
readonly postal_code_regex: FieldRef<"countries", 'String'>
|
|
readonly timezones: FieldRef<"countries", 'String'>
|
|
readonly translations: FieldRef<"countries", 'String'>
|
|
readonly latitude: FieldRef<"countries", 'Decimal'>
|
|
readonly longitude: FieldRef<"countries", 'Decimal'>
|
|
readonly emoji: FieldRef<"countries", 'String'>
|
|
readonly emojiU: FieldRef<"countries", 'String'>
|
|
readonly created_at: FieldRef<"countries", 'DateTime'>
|
|
readonly updated_at: FieldRef<"countries", 'DateTime'>
|
|
readonly flag: FieldRef<"countries", 'Int'>
|
|
readonly wikiDataId: FieldRef<"countries", 'String'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* countries findUnique
|
|
*/
|
|
export type countriesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: countriesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which countries to fetch.
|
|
*/
|
|
where: countriesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* countries findUniqueOrThrow
|
|
*/
|
|
export type countriesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: countriesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which countries to fetch.
|
|
*/
|
|
where: countriesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* countries findFirst
|
|
*/
|
|
export type countriesFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: countriesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which countries to fetch.
|
|
*/
|
|
where?: countriesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of countries to fetch.
|
|
*/
|
|
orderBy?: countriesOrderByWithRelationInput | countriesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for countries.
|
|
*/
|
|
cursor?: countriesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` countries 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` countries.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of countries.
|
|
*/
|
|
distinct?: CountriesScalarFieldEnum | CountriesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* countries findFirstOrThrow
|
|
*/
|
|
export type countriesFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: countriesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which countries to fetch.
|
|
*/
|
|
where?: countriesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of countries to fetch.
|
|
*/
|
|
orderBy?: countriesOrderByWithRelationInput | countriesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for countries.
|
|
*/
|
|
cursor?: countriesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` countries 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` countries.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of countries.
|
|
*/
|
|
distinct?: CountriesScalarFieldEnum | CountriesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* countries findMany
|
|
*/
|
|
export type countriesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: countriesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which countries to fetch.
|
|
*/
|
|
where?: countriesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of countries to fetch.
|
|
*/
|
|
orderBy?: countriesOrderByWithRelationInput | countriesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing countries.
|
|
*/
|
|
cursor?: countriesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` countries 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` countries.
|
|
*/
|
|
skip?: number
|
|
distinct?: CountriesScalarFieldEnum | CountriesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* countries create
|
|
*/
|
|
export type countriesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: countriesInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a countries.
|
|
*/
|
|
data: XOR<countriesCreateInput, countriesUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* countries createMany
|
|
*/
|
|
export type countriesCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many countries.
|
|
*/
|
|
data: countriesCreateManyInput | countriesCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* countries createManyAndReturn
|
|
*/
|
|
export type countriesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many countries.
|
|
*/
|
|
data: countriesCreateManyInput | countriesCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* countries update
|
|
*/
|
|
export type countriesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: countriesInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a countries.
|
|
*/
|
|
data: XOR<countriesUpdateInput, countriesUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which countries to update.
|
|
*/
|
|
where: countriesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* countries updateMany
|
|
*/
|
|
export type countriesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update countries.
|
|
*/
|
|
data: XOR<countriesUpdateManyMutationInput, countriesUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which countries to update
|
|
*/
|
|
where?: countriesWhereInput
|
|
/**
|
|
* Limit how many countries to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* countries updateManyAndReturn
|
|
*/
|
|
export type countriesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update countries.
|
|
*/
|
|
data: XOR<countriesUpdateManyMutationInput, countriesUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which countries to update
|
|
*/
|
|
where?: countriesWhereInput
|
|
/**
|
|
* Limit how many countries to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* countries upsert
|
|
*/
|
|
export type countriesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: countriesInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the countries to update in case it exists.
|
|
*/
|
|
where: countriesWhereUniqueInput
|
|
/**
|
|
* In case the countries found by the `where` argument doesn't exist, create a new countries with this data.
|
|
*/
|
|
create: XOR<countriesCreateInput, countriesUncheckedCreateInput>
|
|
/**
|
|
* In case the countries was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<countriesUpdateInput, countriesUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* countries delete
|
|
*/
|
|
export type countriesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: countriesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which countries to delete.
|
|
*/
|
|
where: countriesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* countries deleteMany
|
|
*/
|
|
export type countriesDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which countries to delete
|
|
*/
|
|
where?: countriesWhereInput
|
|
/**
|
|
* Limit how many countries to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* countries.cities
|
|
*/
|
|
export type countries$citiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
where?: citiesWhereInput
|
|
orderBy?: citiesOrderByWithRelationInput | citiesOrderByWithRelationInput[]
|
|
cursor?: citiesWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: CitiesScalarFieldEnum | CitiesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* countries.states
|
|
*/
|
|
export type countries$statesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
where?: statesWhereInput
|
|
orderBy?: statesOrderByWithRelationInput | statesOrderByWithRelationInput[]
|
|
cursor?: statesWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: StatesScalarFieldEnum | StatesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* countries without action
|
|
*/
|
|
export type countriesDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the countries
|
|
*/
|
|
select?: countriesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the countries
|
|
*/
|
|
omit?: countriesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: countriesInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model states
|
|
*/
|
|
|
|
export type AggregateStates = {
|
|
_count: StatesCountAggregateOutputType | null
|
|
_avg: StatesAvgAggregateOutputType | null
|
|
_sum: StatesSumAggregateOutputType | null
|
|
_min: StatesMinAggregateOutputType | null
|
|
_max: StatesMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type StatesAvgAggregateOutputType = {
|
|
id: number | null
|
|
country_id: number | null
|
|
level: number | null
|
|
parent_id: number | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
flag: number | null
|
|
}
|
|
|
|
export type StatesSumAggregateOutputType = {
|
|
id: bigint | null
|
|
country_id: bigint | null
|
|
level: number | null
|
|
parent_id: bigint | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
flag: number | null
|
|
}
|
|
|
|
export type StatesMinAggregateOutputType = {
|
|
id: bigint | null
|
|
name: string | null
|
|
country_id: bigint | null
|
|
country_code: string | null
|
|
fips_code: string | null
|
|
iso2: string | null
|
|
iso3166_2: string | null
|
|
type: string | null
|
|
level: number | null
|
|
parent_id: bigint | null
|
|
native: string | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
timezone: string | null
|
|
translations: string | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
flag: number | null
|
|
wikiDataId: string | null
|
|
population: string | null
|
|
}
|
|
|
|
export type StatesMaxAggregateOutputType = {
|
|
id: bigint | null
|
|
name: string | null
|
|
country_id: bigint | null
|
|
country_code: string | null
|
|
fips_code: string | null
|
|
iso2: string | null
|
|
iso3166_2: string | null
|
|
type: string | null
|
|
level: number | null
|
|
parent_id: bigint | null
|
|
native: string | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
timezone: string | null
|
|
translations: string | null
|
|
created_at: Date | null
|
|
updated_at: Date | null
|
|
flag: number | null
|
|
wikiDataId: string | null
|
|
population: string | null
|
|
}
|
|
|
|
export type StatesCountAggregateOutputType = {
|
|
id: number
|
|
name: number
|
|
country_id: number
|
|
country_code: number
|
|
fips_code: number
|
|
iso2: number
|
|
iso3166_2: number
|
|
type: number
|
|
level: number
|
|
parent_id: number
|
|
native: number
|
|
latitude: number
|
|
longitude: number
|
|
timezone: number
|
|
translations: number
|
|
created_at: number
|
|
updated_at: number
|
|
flag: number
|
|
wikiDataId: number
|
|
population: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type StatesAvgAggregateInputType = {
|
|
id?: true
|
|
country_id?: true
|
|
level?: true
|
|
parent_id?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
flag?: true
|
|
}
|
|
|
|
export type StatesSumAggregateInputType = {
|
|
id?: true
|
|
country_id?: true
|
|
level?: true
|
|
parent_id?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
flag?: true
|
|
}
|
|
|
|
export type StatesMinAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
country_id?: true
|
|
country_code?: true
|
|
fips_code?: true
|
|
iso2?: true
|
|
iso3166_2?: true
|
|
type?: true
|
|
level?: true
|
|
parent_id?: true
|
|
native?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
timezone?: true
|
|
translations?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
flag?: true
|
|
wikiDataId?: true
|
|
population?: true
|
|
}
|
|
|
|
export type StatesMaxAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
country_id?: true
|
|
country_code?: true
|
|
fips_code?: true
|
|
iso2?: true
|
|
iso3166_2?: true
|
|
type?: true
|
|
level?: true
|
|
parent_id?: true
|
|
native?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
timezone?: true
|
|
translations?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
flag?: true
|
|
wikiDataId?: true
|
|
population?: true
|
|
}
|
|
|
|
export type StatesCountAggregateInputType = {
|
|
id?: true
|
|
name?: true
|
|
country_id?: true
|
|
country_code?: true
|
|
fips_code?: true
|
|
iso2?: true
|
|
iso3166_2?: true
|
|
type?: true
|
|
level?: true
|
|
parent_id?: true
|
|
native?: true
|
|
latitude?: true
|
|
longitude?: true
|
|
timezone?: true
|
|
translations?: true
|
|
created_at?: true
|
|
updated_at?: true
|
|
flag?: true
|
|
wikiDataId?: true
|
|
population?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type StatesAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which states to aggregate.
|
|
*/
|
|
where?: statesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of states to fetch.
|
|
*/
|
|
orderBy?: statesOrderByWithRelationInput | statesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: statesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` states 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` states.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned states
|
|
**/
|
|
_count?: true | StatesCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: StatesAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: StatesSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: StatesMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: StatesMaxAggregateInputType
|
|
}
|
|
|
|
export type GetStatesAggregateType<T extends StatesAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateStates]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateStates[P]>
|
|
: GetScalarType<T[P], AggregateStates[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type statesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: statesWhereInput
|
|
orderBy?: statesOrderByWithAggregationInput | statesOrderByWithAggregationInput[]
|
|
by: StatesScalarFieldEnum[] | StatesScalarFieldEnum
|
|
having?: statesScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: StatesCountAggregateInputType | true
|
|
_avg?: StatesAvgAggregateInputType
|
|
_sum?: StatesSumAggregateInputType
|
|
_min?: StatesMinAggregateInputType
|
|
_max?: StatesMaxAggregateInputType
|
|
}
|
|
|
|
export type StatesGroupByOutputType = {
|
|
id: bigint
|
|
name: string
|
|
country_id: bigint
|
|
country_code: string
|
|
fips_code: string | null
|
|
iso2: string | null
|
|
iso3166_2: string | null
|
|
type: string | null
|
|
level: number | null
|
|
parent_id: bigint | null
|
|
native: string | null
|
|
latitude: Decimal | null
|
|
longitude: Decimal | null
|
|
timezone: string | null
|
|
translations: string | null
|
|
created_at: Date | null
|
|
updated_at: Date
|
|
flag: number
|
|
wikiDataId: string | null
|
|
population: string | null
|
|
_count: StatesCountAggregateOutputType | null
|
|
_avg: StatesAvgAggregateOutputType | null
|
|
_sum: StatesSumAggregateOutputType | null
|
|
_min: StatesMinAggregateOutputType | null
|
|
_max: StatesMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetStatesGroupByPayload<T extends statesGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<StatesGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof StatesGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], StatesGroupByOutputType[P]>
|
|
: GetScalarType<T[P], StatesGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type statesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
country_id?: boolean
|
|
country_code?: boolean
|
|
fips_code?: boolean
|
|
iso2?: boolean
|
|
iso3166_2?: boolean
|
|
type?: boolean
|
|
level?: boolean
|
|
parent_id?: boolean
|
|
native?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
timezone?: boolean
|
|
translations?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
population?: boolean
|
|
cities?: boolean | states$citiesArgs<ExtArgs>
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
_count?: boolean | StatesCountOutputTypeDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["states"]>
|
|
|
|
export type statesSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
country_id?: boolean
|
|
country_code?: boolean
|
|
fips_code?: boolean
|
|
iso2?: boolean
|
|
iso3166_2?: boolean
|
|
type?: boolean
|
|
level?: boolean
|
|
parent_id?: boolean
|
|
native?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
timezone?: boolean
|
|
translations?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
population?: boolean
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["states"]>
|
|
|
|
export type statesSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
name?: boolean
|
|
country_id?: boolean
|
|
country_code?: boolean
|
|
fips_code?: boolean
|
|
iso2?: boolean
|
|
iso3166_2?: boolean
|
|
type?: boolean
|
|
level?: boolean
|
|
parent_id?: boolean
|
|
native?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
timezone?: boolean
|
|
translations?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
population?: boolean
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
}, ExtArgs["result"]["states"]>
|
|
|
|
export type statesSelectScalar = {
|
|
id?: boolean
|
|
name?: boolean
|
|
country_id?: boolean
|
|
country_code?: boolean
|
|
fips_code?: boolean
|
|
iso2?: boolean
|
|
iso3166_2?: boolean
|
|
type?: boolean
|
|
level?: boolean
|
|
parent_id?: boolean
|
|
native?: boolean
|
|
latitude?: boolean
|
|
longitude?: boolean
|
|
timezone?: boolean
|
|
translations?: boolean
|
|
created_at?: boolean
|
|
updated_at?: boolean
|
|
flag?: boolean
|
|
wikiDataId?: boolean
|
|
population?: boolean
|
|
}
|
|
|
|
export type statesOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "name" | "country_id" | "country_code" | "fips_code" | "iso2" | "iso3166_2" | "type" | "level" | "parent_id" | "native" | "latitude" | "longitude" | "timezone" | "translations" | "created_at" | "updated_at" | "flag" | "wikiDataId" | "population", ExtArgs["result"]["states"]>
|
|
export type statesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
cities?: boolean | states$citiesArgs<ExtArgs>
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
_count?: boolean | StatesCountOutputTypeDefaultArgs<ExtArgs>
|
|
}
|
|
export type statesIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
}
|
|
export type statesIncludeUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
countries?: boolean | countriesDefaultArgs<ExtArgs>
|
|
}
|
|
|
|
export type $statesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "states"
|
|
objects: {
|
|
cities: Prisma.$citiesPayload<ExtArgs>[]
|
|
countries: Prisma.$countriesPayload<ExtArgs>
|
|
}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: bigint
|
|
name: string
|
|
country_id: bigint
|
|
country_code: string
|
|
fips_code: string | null
|
|
iso2: string | null
|
|
iso3166_2: string | null
|
|
type: string | null
|
|
level: number | null
|
|
parent_id: bigint | null
|
|
native: string | null
|
|
latitude: Prisma.Decimal | null
|
|
longitude: Prisma.Decimal | null
|
|
timezone: string | null
|
|
translations: string | null
|
|
created_at: Date | null
|
|
updated_at: Date
|
|
flag: number
|
|
wikiDataId: string | null
|
|
population: string | null
|
|
}, ExtArgs["result"]["states"]>
|
|
composites: {}
|
|
}
|
|
|
|
type statesGetPayload<S extends boolean | null | undefined | statesDefaultArgs> = $Result.GetResult<Prisma.$statesPayload, S>
|
|
|
|
type statesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<statesFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: StatesCountAggregateInputType | true
|
|
}
|
|
|
|
export interface statesDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['states'], meta: { name: 'states' } }
|
|
/**
|
|
* Find zero or one States that matches the filter.
|
|
* @param {statesFindUniqueArgs} args - Arguments to find a States
|
|
* @example
|
|
* // Get one States
|
|
* const states = await prisma.states.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends statesFindUniqueArgs>(args: SelectSubset<T, statesFindUniqueArgs<ExtArgs>>): Prisma__statesClient<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one States that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {statesFindUniqueOrThrowArgs} args - Arguments to find a States
|
|
* @example
|
|
* // Get one States
|
|
* const states = await prisma.states.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends statesFindUniqueOrThrowArgs>(args: SelectSubset<T, statesFindUniqueOrThrowArgs<ExtArgs>>): Prisma__statesClient<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first States 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 {statesFindFirstArgs} args - Arguments to find a States
|
|
* @example
|
|
* // Get one States
|
|
* const states = await prisma.states.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends statesFindFirstArgs>(args?: SelectSubset<T, statesFindFirstArgs<ExtArgs>>): Prisma__statesClient<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first States 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 {statesFindFirstOrThrowArgs} args - Arguments to find a States
|
|
* @example
|
|
* // Get one States
|
|
* const states = await prisma.states.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends statesFindFirstOrThrowArgs>(args?: SelectSubset<T, statesFindFirstOrThrowArgs<ExtArgs>>): Prisma__statesClient<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more States 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 {statesFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all States
|
|
* const states = await prisma.states.findMany()
|
|
*
|
|
* // Get first 10 States
|
|
* const states = await prisma.states.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const statesWithIdOnly = await prisma.states.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends statesFindManyArgs>(args?: SelectSubset<T, statesFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a States.
|
|
* @param {statesCreateArgs} args - Arguments to create a States.
|
|
* @example
|
|
* // Create one States
|
|
* const States = await prisma.states.create({
|
|
* data: {
|
|
* // ... data to create a States
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends statesCreateArgs>(args: SelectSubset<T, statesCreateArgs<ExtArgs>>): Prisma__statesClient<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many States.
|
|
* @param {statesCreateManyArgs} args - Arguments to create many States.
|
|
* @example
|
|
* // Create many States
|
|
* const states = await prisma.states.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends statesCreateManyArgs>(args?: SelectSubset<T, statesCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many States and returns the data saved in the database.
|
|
* @param {statesCreateManyAndReturnArgs} args - Arguments to create many States.
|
|
* @example
|
|
* // Create many States
|
|
* const states = await prisma.states.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many States and only return the `id`
|
|
* const statesWithIdOnly = await prisma.states.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 statesCreateManyAndReturnArgs>(args?: SelectSubset<T, statesCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a States.
|
|
* @param {statesDeleteArgs} args - Arguments to delete one States.
|
|
* @example
|
|
* // Delete one States
|
|
* const States = await prisma.states.delete({
|
|
* where: {
|
|
* // ... filter to delete one States
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends statesDeleteArgs>(args: SelectSubset<T, statesDeleteArgs<ExtArgs>>): Prisma__statesClient<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one States.
|
|
* @param {statesUpdateArgs} args - Arguments to update one States.
|
|
* @example
|
|
* // Update one States
|
|
* const states = await prisma.states.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends statesUpdateArgs>(args: SelectSubset<T, statesUpdateArgs<ExtArgs>>): Prisma__statesClient<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more States.
|
|
* @param {statesDeleteManyArgs} args - Arguments to filter States to delete.
|
|
* @example
|
|
* // Delete a few States
|
|
* const { count } = await prisma.states.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends statesDeleteManyArgs>(args?: SelectSubset<T, statesDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more States.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {statesUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many States
|
|
* const states = await prisma.states.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends statesUpdateManyArgs>(args: SelectSubset<T, statesUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more States and returns the data updated in the database.
|
|
* @param {statesUpdateManyAndReturnArgs} args - Arguments to update many States.
|
|
* @example
|
|
* // Update many States
|
|
* const states = await prisma.states.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more States and only return the `id`
|
|
* const statesWithIdOnly = await prisma.states.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 statesUpdateManyAndReturnArgs>(args: SelectSubset<T, statesUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one States.
|
|
* @param {statesUpsertArgs} args - Arguments to update or create a States.
|
|
* @example
|
|
* // Update or create a States
|
|
* const states = await prisma.states.upsert({
|
|
* create: {
|
|
* // ... data to create a States
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the States we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends statesUpsertArgs>(args: SelectSubset<T, statesUpsertArgs<ExtArgs>>): Prisma__statesClient<$Result.GetResult<Prisma.$statesPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of States.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {statesCountArgs} args - Arguments to filter States to count.
|
|
* @example
|
|
* // Count the number of States
|
|
* const count = await prisma.states.count({
|
|
* where: {
|
|
* // ... the filter for the States we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends statesCountArgs>(
|
|
args?: Subset<T, statesCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], StatesCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a States.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {StatesAggregateArgs} 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 StatesAggregateArgs>(args: Subset<T, StatesAggregateArgs>): Prisma.PrismaPromise<GetStatesAggregateType<T>>
|
|
|
|
/**
|
|
* Group by States.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {statesGroupByArgs} 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 statesGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: statesGroupByArgs['orderBy'] }
|
|
: { orderBy?: statesGroupByArgs['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, statesGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetStatesGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the states model
|
|
*/
|
|
readonly fields: statesFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for states.
|
|
* 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__statesClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
|
|
readonly [Symbol.toStringTag]: "PrismaPromise"
|
|
cities<T extends states$citiesArgs<ExtArgs> = {}>(args?: Subset<T, states$citiesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$citiesPayload<ExtArgs>, T, "findMany", GlobalOmitOptions> | Null>
|
|
countries<T extends countriesDefaultArgs<ExtArgs> = {}>(args?: Subset<T, countriesDefaultArgs<ExtArgs>>): Prisma__countriesClient<$Result.GetResult<Prisma.$countriesPayload<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 states model
|
|
*/
|
|
interface statesFieldRefs {
|
|
readonly id: FieldRef<"states", 'BigInt'>
|
|
readonly name: FieldRef<"states", 'String'>
|
|
readonly country_id: FieldRef<"states", 'BigInt'>
|
|
readonly country_code: FieldRef<"states", 'String'>
|
|
readonly fips_code: FieldRef<"states", 'String'>
|
|
readonly iso2: FieldRef<"states", 'String'>
|
|
readonly iso3166_2: FieldRef<"states", 'String'>
|
|
readonly type: FieldRef<"states", 'String'>
|
|
readonly level: FieldRef<"states", 'Int'>
|
|
readonly parent_id: FieldRef<"states", 'BigInt'>
|
|
readonly native: FieldRef<"states", 'String'>
|
|
readonly latitude: FieldRef<"states", 'Decimal'>
|
|
readonly longitude: FieldRef<"states", 'Decimal'>
|
|
readonly timezone: FieldRef<"states", 'String'>
|
|
readonly translations: FieldRef<"states", 'String'>
|
|
readonly created_at: FieldRef<"states", 'DateTime'>
|
|
readonly updated_at: FieldRef<"states", 'DateTime'>
|
|
readonly flag: FieldRef<"states", 'Int'>
|
|
readonly wikiDataId: FieldRef<"states", 'String'>
|
|
readonly population: FieldRef<"states", 'String'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* states findUnique
|
|
*/
|
|
export type statesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which states to fetch.
|
|
*/
|
|
where: statesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* states findUniqueOrThrow
|
|
*/
|
|
export type statesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which states to fetch.
|
|
*/
|
|
where: statesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* states findFirst
|
|
*/
|
|
export type statesFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which states to fetch.
|
|
*/
|
|
where?: statesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of states to fetch.
|
|
*/
|
|
orderBy?: statesOrderByWithRelationInput | statesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for states.
|
|
*/
|
|
cursor?: statesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` states 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` states.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of states.
|
|
*/
|
|
distinct?: StatesScalarFieldEnum | StatesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* states findFirstOrThrow
|
|
*/
|
|
export type statesFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which states to fetch.
|
|
*/
|
|
where?: statesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of states to fetch.
|
|
*/
|
|
orderBy?: statesOrderByWithRelationInput | statesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for states.
|
|
*/
|
|
cursor?: statesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` states 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` states.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of states.
|
|
*/
|
|
distinct?: StatesScalarFieldEnum | StatesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* states findMany
|
|
*/
|
|
export type statesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter, which states to fetch.
|
|
*/
|
|
where?: statesWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of states to fetch.
|
|
*/
|
|
orderBy?: statesOrderByWithRelationInput | statesOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing states.
|
|
*/
|
|
cursor?: statesWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` states 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` states.
|
|
*/
|
|
skip?: number
|
|
distinct?: StatesScalarFieldEnum | StatesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* states create
|
|
*/
|
|
export type statesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a states.
|
|
*/
|
|
data: XOR<statesCreateInput, statesUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* states createMany
|
|
*/
|
|
export type statesCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many states.
|
|
*/
|
|
data: statesCreateManyInput | statesCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* states createManyAndReturn
|
|
*/
|
|
export type statesCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many states.
|
|
*/
|
|
data: statesCreateManyInput | statesCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesIncludeCreateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* states update
|
|
*/
|
|
export type statesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a states.
|
|
*/
|
|
data: XOR<statesUpdateInput, statesUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which states to update.
|
|
*/
|
|
where: statesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* states updateMany
|
|
*/
|
|
export type statesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update states.
|
|
*/
|
|
data: XOR<statesUpdateManyMutationInput, statesUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which states to update
|
|
*/
|
|
where?: statesWhereInput
|
|
/**
|
|
* Limit how many states to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* states updateManyAndReturn
|
|
*/
|
|
export type statesUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update states.
|
|
*/
|
|
data: XOR<statesUpdateManyMutationInput, statesUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which states to update
|
|
*/
|
|
where?: statesWhereInput
|
|
/**
|
|
* Limit how many states to update.
|
|
*/
|
|
limit?: number
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesIncludeUpdateManyAndReturn<ExtArgs> | null
|
|
}
|
|
|
|
/**
|
|
* states upsert
|
|
*/
|
|
export type statesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the states to update in case it exists.
|
|
*/
|
|
where: statesWhereUniqueInput
|
|
/**
|
|
* In case the states found by the `where` argument doesn't exist, create a new states with this data.
|
|
*/
|
|
create: XOR<statesCreateInput, statesUncheckedCreateInput>
|
|
/**
|
|
* In case the states was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<statesUpdateInput, statesUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* states delete
|
|
*/
|
|
export type statesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
/**
|
|
* Filter which states to delete.
|
|
*/
|
|
where: statesWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* states deleteMany
|
|
*/
|
|
export type statesDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which states to delete
|
|
*/
|
|
where?: statesWhereInput
|
|
/**
|
|
* Limit how many states to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* states.cities
|
|
*/
|
|
export type states$citiesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the cities
|
|
*/
|
|
select?: citiesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the cities
|
|
*/
|
|
omit?: citiesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: citiesInclude<ExtArgs> | null
|
|
where?: citiesWhereInput
|
|
orderBy?: citiesOrderByWithRelationInput | citiesOrderByWithRelationInput[]
|
|
cursor?: citiesWhereUniqueInput
|
|
take?: number
|
|
skip?: number
|
|
distinct?: CitiesScalarFieldEnum | CitiesScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* states without action
|
|
*/
|
|
export type statesDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the states
|
|
*/
|
|
select?: statesSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the states
|
|
*/
|
|
omit?: statesOmit<ExtArgs> | null
|
|
/**
|
|
* Choose, which related nodes to fetch as well
|
|
*/
|
|
include?: statesInclude<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model Address
|
|
*/
|
|
|
|
export type AggregateAddress = {
|
|
_count: AddressCountAggregateOutputType | null
|
|
_avg: AddressAvgAggregateOutputType | null
|
|
_sum: AddressSumAggregateOutputType | null
|
|
_min: AddressMinAggregateOutputType | null
|
|
_max: AddressMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type AddressAvgAggregateOutputType = {
|
|
cityId: number | null
|
|
stateId: number | null
|
|
countryId: number | null
|
|
}
|
|
|
|
export type AddressSumAggregateOutputType = {
|
|
cityId: number | null
|
|
stateId: number | null
|
|
countryId: number | null
|
|
}
|
|
|
|
export type AddressMinAggregateOutputType = {
|
|
id: string | null
|
|
street: string | null
|
|
streetNo: string | null
|
|
postalCode: string | null
|
|
cityId: number | null
|
|
stateId: number | null
|
|
countryId: number | null
|
|
rawCity: string | null
|
|
rawCountry: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type AddressMaxAggregateOutputType = {
|
|
id: string | null
|
|
street: string | null
|
|
streetNo: string | null
|
|
postalCode: string | null
|
|
cityId: number | null
|
|
stateId: number | null
|
|
countryId: number | null
|
|
rawCity: string | null
|
|
rawCountry: string | null
|
|
createdAt: Date | null
|
|
updatedAt: Date | null
|
|
}
|
|
|
|
export type AddressCountAggregateOutputType = {
|
|
id: number
|
|
street: number
|
|
streetNo: number
|
|
postalCode: number
|
|
cityId: number
|
|
stateId: number
|
|
countryId: number
|
|
rawCity: number
|
|
rawCountry: number
|
|
createdAt: number
|
|
updatedAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type AddressAvgAggregateInputType = {
|
|
cityId?: true
|
|
stateId?: true
|
|
countryId?: true
|
|
}
|
|
|
|
export type AddressSumAggregateInputType = {
|
|
cityId?: true
|
|
stateId?: true
|
|
countryId?: true
|
|
}
|
|
|
|
export type AddressMinAggregateInputType = {
|
|
id?: true
|
|
street?: true
|
|
streetNo?: true
|
|
postalCode?: true
|
|
cityId?: true
|
|
stateId?: true
|
|
countryId?: true
|
|
rawCity?: true
|
|
rawCountry?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type AddressMaxAggregateInputType = {
|
|
id?: true
|
|
street?: true
|
|
streetNo?: true
|
|
postalCode?: true
|
|
cityId?: true
|
|
stateId?: true
|
|
countryId?: true
|
|
rawCity?: true
|
|
rawCountry?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
}
|
|
|
|
export type AddressCountAggregateInputType = {
|
|
id?: true
|
|
street?: true
|
|
streetNo?: true
|
|
postalCode?: true
|
|
cityId?: true
|
|
stateId?: true
|
|
countryId?: true
|
|
rawCity?: true
|
|
rawCountry?: true
|
|
createdAt?: true
|
|
updatedAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type AddressAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Address to aggregate.
|
|
*/
|
|
where?: AddressWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Addresses to fetch.
|
|
*/
|
|
orderBy?: AddressOrderByWithRelationInput | AddressOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: AddressWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Addresses 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` Addresses.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned Addresses
|
|
**/
|
|
_count?: true | AddressCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to average
|
|
**/
|
|
_avg?: AddressAvgAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to sum
|
|
**/
|
|
_sum?: AddressSumAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: AddressMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: AddressMaxAggregateInputType
|
|
}
|
|
|
|
export type GetAddressAggregateType<T extends AddressAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateAddress]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateAddress[P]>
|
|
: GetScalarType<T[P], AggregateAddress[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type AddressGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: AddressWhereInput
|
|
orderBy?: AddressOrderByWithAggregationInput | AddressOrderByWithAggregationInput[]
|
|
by: AddressScalarFieldEnum[] | AddressScalarFieldEnum
|
|
having?: AddressScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: AddressCountAggregateInputType | true
|
|
_avg?: AddressAvgAggregateInputType
|
|
_sum?: AddressSumAggregateInputType
|
|
_min?: AddressMinAggregateInputType
|
|
_max?: AddressMaxAggregateInputType
|
|
}
|
|
|
|
export type AddressGroupByOutputType = {
|
|
id: string
|
|
street: string
|
|
streetNo: string | null
|
|
postalCode: string | null
|
|
cityId: number | null
|
|
stateId: number | null
|
|
countryId: number | null
|
|
rawCity: string | null
|
|
rawCountry: string | null
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
_count: AddressCountAggregateOutputType | null
|
|
_avg: AddressAvgAggregateOutputType | null
|
|
_sum: AddressSumAggregateOutputType | null
|
|
_min: AddressMinAggregateOutputType | null
|
|
_max: AddressMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetAddressGroupByPayload<T extends AddressGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<AddressGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof AddressGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], AddressGroupByOutputType[P]>
|
|
: GetScalarType<T[P], AddressGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type AddressSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
street?: boolean
|
|
streetNo?: boolean
|
|
postalCode?: boolean
|
|
cityId?: boolean
|
|
stateId?: boolean
|
|
countryId?: boolean
|
|
rawCity?: boolean
|
|
rawCountry?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["address"]>
|
|
|
|
export type AddressSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
street?: boolean
|
|
streetNo?: boolean
|
|
postalCode?: boolean
|
|
cityId?: boolean
|
|
stateId?: boolean
|
|
countryId?: boolean
|
|
rawCity?: boolean
|
|
rawCountry?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["address"]>
|
|
|
|
export type AddressSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
street?: boolean
|
|
streetNo?: boolean
|
|
postalCode?: boolean
|
|
cityId?: boolean
|
|
stateId?: boolean
|
|
countryId?: boolean
|
|
rawCity?: boolean
|
|
rawCountry?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}, ExtArgs["result"]["address"]>
|
|
|
|
export type AddressSelectScalar = {
|
|
id?: boolean
|
|
street?: boolean
|
|
streetNo?: boolean
|
|
postalCode?: boolean
|
|
cityId?: boolean
|
|
stateId?: boolean
|
|
countryId?: boolean
|
|
rawCity?: boolean
|
|
rawCountry?: boolean
|
|
createdAt?: boolean
|
|
updatedAt?: boolean
|
|
}
|
|
|
|
export type AddressOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "street" | "streetNo" | "postalCode" | "cityId" | "stateId" | "countryId" | "rawCity" | "rawCountry" | "createdAt" | "updatedAt", ExtArgs["result"]["address"]>
|
|
|
|
export type $AddressPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "Address"
|
|
objects: {}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
street: string
|
|
streetNo: string | null
|
|
postalCode: string | null
|
|
cityId: number | null
|
|
stateId: number | null
|
|
countryId: number | null
|
|
rawCity: string | null
|
|
rawCountry: string | null
|
|
createdAt: Date
|
|
updatedAt: Date
|
|
}, ExtArgs["result"]["address"]>
|
|
composites: {}
|
|
}
|
|
|
|
type AddressGetPayload<S extends boolean | null | undefined | AddressDefaultArgs> = $Result.GetResult<Prisma.$AddressPayload, S>
|
|
|
|
type AddressCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<AddressFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: AddressCountAggregateInputType | true
|
|
}
|
|
|
|
export interface AddressDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Address'], meta: { name: 'Address' } }
|
|
/**
|
|
* Find zero or one Address that matches the filter.
|
|
* @param {AddressFindUniqueArgs} args - Arguments to find a Address
|
|
* @example
|
|
* // Get one Address
|
|
* const address = await prisma.address.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends AddressFindUniqueArgs>(args: SelectSubset<T, AddressFindUniqueArgs<ExtArgs>>): Prisma__AddressClient<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one Address that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {AddressFindUniqueOrThrowArgs} args - Arguments to find a Address
|
|
* @example
|
|
* // Get one Address
|
|
* const address = await prisma.address.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends AddressFindUniqueOrThrowArgs>(args: SelectSubset<T, AddressFindUniqueOrThrowArgs<ExtArgs>>): Prisma__AddressClient<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Address 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 {AddressFindFirstArgs} args - Arguments to find a Address
|
|
* @example
|
|
* // Get one Address
|
|
* const address = await prisma.address.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends AddressFindFirstArgs>(args?: SelectSubset<T, AddressFindFirstArgs<ExtArgs>>): Prisma__AddressClient<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first Address 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 {AddressFindFirstOrThrowArgs} args - Arguments to find a Address
|
|
* @example
|
|
* // Get one Address
|
|
* const address = await prisma.address.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends AddressFindFirstOrThrowArgs>(args?: SelectSubset<T, AddressFindFirstOrThrowArgs<ExtArgs>>): Prisma__AddressClient<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more Addresses 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 {AddressFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all Addresses
|
|
* const addresses = await prisma.address.findMany()
|
|
*
|
|
* // Get first 10 Addresses
|
|
* const addresses = await prisma.address.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const addressWithIdOnly = await prisma.address.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends AddressFindManyArgs>(args?: SelectSubset<T, AddressFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a Address.
|
|
* @param {AddressCreateArgs} args - Arguments to create a Address.
|
|
* @example
|
|
* // Create one Address
|
|
* const Address = await prisma.address.create({
|
|
* data: {
|
|
* // ... data to create a Address
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends AddressCreateArgs>(args: SelectSubset<T, AddressCreateArgs<ExtArgs>>): Prisma__AddressClient<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many Addresses.
|
|
* @param {AddressCreateManyArgs} args - Arguments to create many Addresses.
|
|
* @example
|
|
* // Create many Addresses
|
|
* const address = await prisma.address.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends AddressCreateManyArgs>(args?: SelectSubset<T, AddressCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many Addresses and returns the data saved in the database.
|
|
* @param {AddressCreateManyAndReturnArgs} args - Arguments to create many Addresses.
|
|
* @example
|
|
* // Create many Addresses
|
|
* const address = await prisma.address.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many Addresses and only return the `id`
|
|
* const addressWithIdOnly = await prisma.address.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 AddressCreateManyAndReturnArgs>(args?: SelectSubset<T, AddressCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a Address.
|
|
* @param {AddressDeleteArgs} args - Arguments to delete one Address.
|
|
* @example
|
|
* // Delete one Address
|
|
* const Address = await prisma.address.delete({
|
|
* where: {
|
|
* // ... filter to delete one Address
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends AddressDeleteArgs>(args: SelectSubset<T, AddressDeleteArgs<ExtArgs>>): Prisma__AddressClient<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one Address.
|
|
* @param {AddressUpdateArgs} args - Arguments to update one Address.
|
|
* @example
|
|
* // Update one Address
|
|
* const address = await prisma.address.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends AddressUpdateArgs>(args: SelectSubset<T, AddressUpdateArgs<ExtArgs>>): Prisma__AddressClient<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more Addresses.
|
|
* @param {AddressDeleteManyArgs} args - Arguments to filter Addresses to delete.
|
|
* @example
|
|
* // Delete a few Addresses
|
|
* const { count } = await prisma.address.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends AddressDeleteManyArgs>(args?: SelectSubset<T, AddressDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Addresses.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AddressUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many Addresses
|
|
* const address = await prisma.address.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends AddressUpdateManyArgs>(args: SelectSubset<T, AddressUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more Addresses and returns the data updated in the database.
|
|
* @param {AddressUpdateManyAndReturnArgs} args - Arguments to update many Addresses.
|
|
* @example
|
|
* // Update many Addresses
|
|
* const address = await prisma.address.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more Addresses and only return the `id`
|
|
* const addressWithIdOnly = await prisma.address.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 AddressUpdateManyAndReturnArgs>(args: SelectSubset<T, AddressUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one Address.
|
|
* @param {AddressUpsertArgs} args - Arguments to update or create a Address.
|
|
* @example
|
|
* // Update or create a Address
|
|
* const address = await prisma.address.upsert({
|
|
* create: {
|
|
* // ... data to create a Address
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the Address we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends AddressUpsertArgs>(args: SelectSubset<T, AddressUpsertArgs<ExtArgs>>): Prisma__AddressClient<$Result.GetResult<Prisma.$AddressPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of Addresses.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AddressCountArgs} args - Arguments to filter Addresses to count.
|
|
* @example
|
|
* // Count the number of Addresses
|
|
* const count = await prisma.address.count({
|
|
* where: {
|
|
* // ... the filter for the Addresses we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends AddressCountArgs>(
|
|
args?: Subset<T, AddressCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], AddressCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a Address.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AddressAggregateArgs} 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 AddressAggregateArgs>(args: Subset<T, AddressAggregateArgs>): Prisma.PrismaPromise<GetAddressAggregateType<T>>
|
|
|
|
/**
|
|
* Group by Address.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {AddressGroupByArgs} 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 AddressGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: AddressGroupByArgs['orderBy'] }
|
|
: { orderBy?: AddressGroupByArgs['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, AddressGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAddressGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the Address model
|
|
*/
|
|
readonly fields: AddressFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for Address.
|
|
* 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__AddressClient<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 Address model
|
|
*/
|
|
interface AddressFieldRefs {
|
|
readonly id: FieldRef<"Address", 'String'>
|
|
readonly street: FieldRef<"Address", 'String'>
|
|
readonly streetNo: FieldRef<"Address", 'String'>
|
|
readonly postalCode: FieldRef<"Address", 'String'>
|
|
readonly cityId: FieldRef<"Address", 'Int'>
|
|
readonly stateId: FieldRef<"Address", 'Int'>
|
|
readonly countryId: FieldRef<"Address", 'Int'>
|
|
readonly rawCity: FieldRef<"Address", 'String'>
|
|
readonly rawCountry: FieldRef<"Address", 'String'>
|
|
readonly createdAt: FieldRef<"Address", 'DateTime'>
|
|
readonly updatedAt: FieldRef<"Address", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* Address findUnique
|
|
*/
|
|
export type AddressFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which Address to fetch.
|
|
*/
|
|
where: AddressWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Address findUniqueOrThrow
|
|
*/
|
|
export type AddressFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which Address to fetch.
|
|
*/
|
|
where: AddressWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Address findFirst
|
|
*/
|
|
export type AddressFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which Address to fetch.
|
|
*/
|
|
where?: AddressWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Addresses to fetch.
|
|
*/
|
|
orderBy?: AddressOrderByWithRelationInput | AddressOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Addresses.
|
|
*/
|
|
cursor?: AddressWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Addresses 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` Addresses.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Addresses.
|
|
*/
|
|
distinct?: AddressScalarFieldEnum | AddressScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Address findFirstOrThrow
|
|
*/
|
|
export type AddressFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which Address to fetch.
|
|
*/
|
|
where?: AddressWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Addresses to fetch.
|
|
*/
|
|
orderBy?: AddressOrderByWithRelationInput | AddressOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for Addresses.
|
|
*/
|
|
cursor?: AddressWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Addresses 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` Addresses.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of Addresses.
|
|
*/
|
|
distinct?: AddressScalarFieldEnum | AddressScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Address findMany
|
|
*/
|
|
export type AddressFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which Addresses to fetch.
|
|
*/
|
|
where?: AddressWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of Addresses to fetch.
|
|
*/
|
|
orderBy?: AddressOrderByWithRelationInput | AddressOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing Addresses.
|
|
*/
|
|
cursor?: AddressWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` Addresses 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` Addresses.
|
|
*/
|
|
skip?: number
|
|
distinct?: AddressScalarFieldEnum | AddressScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* Address create
|
|
*/
|
|
export type AddressCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a Address.
|
|
*/
|
|
data: XOR<AddressCreateInput, AddressUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* Address createMany
|
|
*/
|
|
export type AddressCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many Addresses.
|
|
*/
|
|
data: AddressCreateManyInput | AddressCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Address createManyAndReturn
|
|
*/
|
|
export type AddressCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many Addresses.
|
|
*/
|
|
data: AddressCreateManyInput | AddressCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* Address update
|
|
*/
|
|
export type AddressUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a Address.
|
|
*/
|
|
data: XOR<AddressUpdateInput, AddressUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which Address to update.
|
|
*/
|
|
where: AddressWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Address updateMany
|
|
*/
|
|
export type AddressUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update Addresses.
|
|
*/
|
|
data: XOR<AddressUpdateManyMutationInput, AddressUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Addresses to update
|
|
*/
|
|
where?: AddressWhereInput
|
|
/**
|
|
* Limit how many Addresses to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Address updateManyAndReturn
|
|
*/
|
|
export type AddressUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update Addresses.
|
|
*/
|
|
data: XOR<AddressUpdateManyMutationInput, AddressUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which Addresses to update
|
|
*/
|
|
where?: AddressWhereInput
|
|
/**
|
|
* Limit how many Addresses to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Address upsert
|
|
*/
|
|
export type AddressUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the Address to update in case it exists.
|
|
*/
|
|
where: AddressWhereUniqueInput
|
|
/**
|
|
* In case the Address found by the `where` argument doesn't exist, create a new Address with this data.
|
|
*/
|
|
create: XOR<AddressCreateInput, AddressUncheckedCreateInput>
|
|
/**
|
|
* In case the Address was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<AddressUpdateInput, AddressUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* Address delete
|
|
*/
|
|
export type AddressDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
/**
|
|
* Filter which Address to delete.
|
|
*/
|
|
where: AddressWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* Address deleteMany
|
|
*/
|
|
export type AddressDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which Addresses to delete
|
|
*/
|
|
where?: AddressWhereInput
|
|
/**
|
|
* Limit how many Addresses to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* Address without action
|
|
*/
|
|
export type AddressDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the Address
|
|
*/
|
|
select?: AddressSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the Address
|
|
*/
|
|
omit?: AddressOmit<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Model VaultData
|
|
*/
|
|
|
|
export type AggregateVaultData = {
|
|
_count: VaultDataCountAggregateOutputType | null
|
|
_min: VaultDataMinAggregateOutputType | null
|
|
_max: VaultDataMaxAggregateOutputType | null
|
|
}
|
|
|
|
export type VaultDataMinAggregateOutputType = {
|
|
id: string | null
|
|
entityType: string | null
|
|
entityId: string | null
|
|
secureData: string | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type VaultDataMaxAggregateOutputType = {
|
|
id: string | null
|
|
entityType: string | null
|
|
entityId: string | null
|
|
secureData: string | null
|
|
createdAt: Date | null
|
|
}
|
|
|
|
export type VaultDataCountAggregateOutputType = {
|
|
id: number
|
|
entityType: number
|
|
entityId: number
|
|
secureData: number
|
|
createdAt: number
|
|
_all: number
|
|
}
|
|
|
|
|
|
export type VaultDataMinAggregateInputType = {
|
|
id?: true
|
|
entityType?: true
|
|
entityId?: true
|
|
secureData?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type VaultDataMaxAggregateInputType = {
|
|
id?: true
|
|
entityType?: true
|
|
entityId?: true
|
|
secureData?: true
|
|
createdAt?: true
|
|
}
|
|
|
|
export type VaultDataCountAggregateInputType = {
|
|
id?: true
|
|
entityType?: true
|
|
entityId?: true
|
|
secureData?: true
|
|
createdAt?: true
|
|
_all?: true
|
|
}
|
|
|
|
export type VaultDataAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which VaultData to aggregate.
|
|
*/
|
|
where?: VaultDataWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of VaultData to fetch.
|
|
*/
|
|
orderBy?: VaultDataOrderByWithRelationInput | VaultDataOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the start position
|
|
*/
|
|
cursor?: VaultDataWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` VaultData 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` VaultData.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Count returned VaultData
|
|
**/
|
|
_count?: true | VaultDataCountAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the minimum value
|
|
**/
|
|
_min?: VaultDataMinAggregateInputType
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
|
|
*
|
|
* Select which fields to find the maximum value
|
|
**/
|
|
_max?: VaultDataMaxAggregateInputType
|
|
}
|
|
|
|
export type GetVaultDataAggregateType<T extends VaultDataAggregateArgs> = {
|
|
[P in keyof T & keyof AggregateVaultData]: P extends '_count' | 'count'
|
|
? T[P] extends true
|
|
? number
|
|
: GetScalarType<T[P], AggregateVaultData[P]>
|
|
: GetScalarType<T[P], AggregateVaultData[P]>
|
|
}
|
|
|
|
|
|
|
|
|
|
export type VaultDataGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
where?: VaultDataWhereInput
|
|
orderBy?: VaultDataOrderByWithAggregationInput | VaultDataOrderByWithAggregationInput[]
|
|
by: VaultDataScalarFieldEnum[] | VaultDataScalarFieldEnum
|
|
having?: VaultDataScalarWhereWithAggregatesInput
|
|
take?: number
|
|
skip?: number
|
|
_count?: VaultDataCountAggregateInputType | true
|
|
_min?: VaultDataMinAggregateInputType
|
|
_max?: VaultDataMaxAggregateInputType
|
|
}
|
|
|
|
export type VaultDataGroupByOutputType = {
|
|
id: string
|
|
entityType: string
|
|
entityId: string
|
|
secureData: string
|
|
createdAt: Date
|
|
_count: VaultDataCountAggregateOutputType | null
|
|
_min: VaultDataMinAggregateOutputType | null
|
|
_max: VaultDataMaxAggregateOutputType | null
|
|
}
|
|
|
|
type GetVaultDataGroupByPayload<T extends VaultDataGroupByArgs> = Prisma.PrismaPromise<
|
|
Array<
|
|
PickEnumerable<VaultDataGroupByOutputType, T['by']> &
|
|
{
|
|
[P in ((keyof T) & (keyof VaultDataGroupByOutputType))]: P extends '_count'
|
|
? T[P] extends boolean
|
|
? number
|
|
: GetScalarType<T[P], VaultDataGroupByOutputType[P]>
|
|
: GetScalarType<T[P], VaultDataGroupByOutputType[P]>
|
|
}
|
|
>
|
|
>
|
|
|
|
|
|
export type VaultDataSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
secureData?: boolean
|
|
createdAt?: boolean
|
|
}, ExtArgs["result"]["vaultData"]>
|
|
|
|
export type VaultDataSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
secureData?: boolean
|
|
createdAt?: boolean
|
|
}, ExtArgs["result"]["vaultData"]>
|
|
|
|
export type VaultDataSelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
|
|
id?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
secureData?: boolean
|
|
createdAt?: boolean
|
|
}, ExtArgs["result"]["vaultData"]>
|
|
|
|
export type VaultDataSelectScalar = {
|
|
id?: boolean
|
|
entityType?: boolean
|
|
entityId?: boolean
|
|
secureData?: boolean
|
|
createdAt?: boolean
|
|
}
|
|
|
|
export type VaultDataOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "entityType" | "entityId" | "secureData" | "createdAt", ExtArgs["result"]["vaultData"]>
|
|
|
|
export type $VaultDataPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
name: "VaultData"
|
|
objects: {}
|
|
scalars: $Extensions.GetPayloadResult<{
|
|
id: string
|
|
entityType: string
|
|
entityId: string
|
|
secureData: string
|
|
createdAt: Date
|
|
}, ExtArgs["result"]["vaultData"]>
|
|
composites: {}
|
|
}
|
|
|
|
type VaultDataGetPayload<S extends boolean | null | undefined | VaultDataDefaultArgs> = $Result.GetResult<Prisma.$VaultDataPayload, S>
|
|
|
|
type VaultDataCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
|
|
Omit<VaultDataFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
|
|
select?: VaultDataCountAggregateInputType | true
|
|
}
|
|
|
|
export interface VaultDataDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
|
|
[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['VaultData'], meta: { name: 'VaultData' } }
|
|
/**
|
|
* Find zero or one VaultData that matches the filter.
|
|
* @param {VaultDataFindUniqueArgs} args - Arguments to find a VaultData
|
|
* @example
|
|
* // Get one VaultData
|
|
* const vaultData = await prisma.vaultData.findUnique({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUnique<T extends VaultDataFindUniqueArgs>(args: SelectSubset<T, VaultDataFindUniqueArgs<ExtArgs>>): Prisma__VaultDataClient<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find one VaultData that matches the filter or throw an error with `error.code='P2025'`
|
|
* if no matches were found.
|
|
* @param {VaultDataFindUniqueOrThrowArgs} args - Arguments to find a VaultData
|
|
* @example
|
|
* // Get one VaultData
|
|
* const vaultData = await prisma.vaultData.findUniqueOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findUniqueOrThrow<T extends VaultDataFindUniqueOrThrowArgs>(args: SelectSubset<T, VaultDataFindUniqueOrThrowArgs<ExtArgs>>): Prisma__VaultDataClient<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first VaultData 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 {VaultDataFindFirstArgs} args - Arguments to find a VaultData
|
|
* @example
|
|
* // Get one VaultData
|
|
* const vaultData = await prisma.vaultData.findFirst({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirst<T extends VaultDataFindFirstArgs>(args?: SelectSubset<T, VaultDataFindFirstArgs<ExtArgs>>): Prisma__VaultDataClient<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find the first VaultData 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 {VaultDataFindFirstOrThrowArgs} args - Arguments to find a VaultData
|
|
* @example
|
|
* // Get one VaultData
|
|
* const vaultData = await prisma.vaultData.findFirstOrThrow({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*/
|
|
findFirstOrThrow<T extends VaultDataFindFirstOrThrowArgs>(args?: SelectSubset<T, VaultDataFindFirstOrThrowArgs<ExtArgs>>): Prisma__VaultDataClient<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Find zero or more VaultData 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 {VaultDataFindManyArgs} args - Arguments to filter and select certain fields only.
|
|
* @example
|
|
* // Get all VaultData
|
|
* const vaultData = await prisma.vaultData.findMany()
|
|
*
|
|
* // Get first 10 VaultData
|
|
* const vaultData = await prisma.vaultData.findMany({ take: 10 })
|
|
*
|
|
* // Only select the `id`
|
|
* const vaultDataWithIdOnly = await prisma.vaultData.findMany({ select: { id: true } })
|
|
*
|
|
*/
|
|
findMany<T extends VaultDataFindManyArgs>(args?: SelectSubset<T, VaultDataFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create a VaultData.
|
|
* @param {VaultDataCreateArgs} args - Arguments to create a VaultData.
|
|
* @example
|
|
* // Create one VaultData
|
|
* const VaultData = await prisma.vaultData.create({
|
|
* data: {
|
|
* // ... data to create a VaultData
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
create<T extends VaultDataCreateArgs>(args: SelectSubset<T, VaultDataCreateArgs<ExtArgs>>): Prisma__VaultDataClient<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Create many VaultData.
|
|
* @param {VaultDataCreateManyArgs} args - Arguments to create many VaultData.
|
|
* @example
|
|
* // Create many VaultData
|
|
* const vaultData = await prisma.vaultData.createMany({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
*/
|
|
createMany<T extends VaultDataCreateManyArgs>(args?: SelectSubset<T, VaultDataCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Create many VaultData and returns the data saved in the database.
|
|
* @param {VaultDataCreateManyAndReturnArgs} args - Arguments to create many VaultData.
|
|
* @example
|
|
* // Create many VaultData
|
|
* const vaultData = await prisma.vaultData.createManyAndReturn({
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Create many VaultData and only return the `id`
|
|
* const vaultDataWithIdOnly = await prisma.vaultData.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 VaultDataCreateManyAndReturnArgs>(args?: SelectSubset<T, VaultDataCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Delete a VaultData.
|
|
* @param {VaultDataDeleteArgs} args - Arguments to delete one VaultData.
|
|
* @example
|
|
* // Delete one VaultData
|
|
* const VaultData = await prisma.vaultData.delete({
|
|
* where: {
|
|
* // ... filter to delete one VaultData
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
delete<T extends VaultDataDeleteArgs>(args: SelectSubset<T, VaultDataDeleteArgs<ExtArgs>>): Prisma__VaultDataClient<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Update one VaultData.
|
|
* @param {VaultDataUpdateArgs} args - Arguments to update one VaultData.
|
|
* @example
|
|
* // Update one VaultData
|
|
* const vaultData = await prisma.vaultData.update({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
update<T extends VaultDataUpdateArgs>(args: SelectSubset<T, VaultDataUpdateArgs<ExtArgs>>): Prisma__VaultDataClient<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
/**
|
|
* Delete zero or more VaultData.
|
|
* @param {VaultDataDeleteManyArgs} args - Arguments to filter VaultData to delete.
|
|
* @example
|
|
* // Delete a few VaultData
|
|
* const { count } = await prisma.vaultData.deleteMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
deleteMany<T extends VaultDataDeleteManyArgs>(args?: SelectSubset<T, VaultDataDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more VaultData.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VaultDataUpdateManyArgs} args - Arguments to update one or more rows.
|
|
* @example
|
|
* // Update many VaultData
|
|
* const vaultData = await prisma.vaultData.updateMany({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: {
|
|
* // ... provide data here
|
|
* }
|
|
* })
|
|
*
|
|
*/
|
|
updateMany<T extends VaultDataUpdateManyArgs>(args: SelectSubset<T, VaultDataUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
|
|
|
|
/**
|
|
* Update zero or more VaultData and returns the data updated in the database.
|
|
* @param {VaultDataUpdateManyAndReturnArgs} args - Arguments to update many VaultData.
|
|
* @example
|
|
* // Update many VaultData
|
|
* const vaultData = await prisma.vaultData.updateManyAndReturn({
|
|
* where: {
|
|
* // ... provide filter here
|
|
* },
|
|
* data: [
|
|
* // ... provide data here
|
|
* ]
|
|
* })
|
|
*
|
|
* // Update zero or more VaultData and only return the `id`
|
|
* const vaultDataWithIdOnly = await prisma.vaultData.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 VaultDataUpdateManyAndReturnArgs>(args: SelectSubset<T, VaultDataUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
|
|
|
|
/**
|
|
* Create or update one VaultData.
|
|
* @param {VaultDataUpsertArgs} args - Arguments to update or create a VaultData.
|
|
* @example
|
|
* // Update or create a VaultData
|
|
* const vaultData = await prisma.vaultData.upsert({
|
|
* create: {
|
|
* // ... data to create a VaultData
|
|
* },
|
|
* update: {
|
|
* // ... in case it already exists, update
|
|
* },
|
|
* where: {
|
|
* // ... the filter for the VaultData we want to update
|
|
* }
|
|
* })
|
|
*/
|
|
upsert<T extends VaultDataUpsertArgs>(args: SelectSubset<T, VaultDataUpsertArgs<ExtArgs>>): Prisma__VaultDataClient<$Result.GetResult<Prisma.$VaultDataPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
|
|
|
|
|
|
/**
|
|
* Count the number of VaultData.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VaultDataCountArgs} args - Arguments to filter VaultData to count.
|
|
* @example
|
|
* // Count the number of VaultData
|
|
* const count = await prisma.vaultData.count({
|
|
* where: {
|
|
* // ... the filter for the VaultData we want to count
|
|
* }
|
|
* })
|
|
**/
|
|
count<T extends VaultDataCountArgs>(
|
|
args?: Subset<T, VaultDataCountArgs>,
|
|
): Prisma.PrismaPromise<
|
|
T extends $Utils.Record<'select', any>
|
|
? T['select'] extends true
|
|
? number
|
|
: GetScalarType<T['select'], VaultDataCountAggregateOutputType>
|
|
: number
|
|
>
|
|
|
|
/**
|
|
* Allows you to perform aggregations operations on a VaultData.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VaultDataAggregateArgs} 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 VaultDataAggregateArgs>(args: Subset<T, VaultDataAggregateArgs>): Prisma.PrismaPromise<GetVaultDataAggregateType<T>>
|
|
|
|
/**
|
|
* Group by VaultData.
|
|
* Note, that providing `undefined` is treated as the value not being there.
|
|
* Read more here: https://pris.ly/d/null-undefined
|
|
* @param {VaultDataGroupByArgs} 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 VaultDataGroupByArgs,
|
|
HasSelectOrTake extends Or<
|
|
Extends<'skip', Keys<T>>,
|
|
Extends<'take', Keys<T>>
|
|
>,
|
|
OrderByArg extends True extends HasSelectOrTake
|
|
? { orderBy: VaultDataGroupByArgs['orderBy'] }
|
|
: { orderBy?: VaultDataGroupByArgs['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, VaultDataGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetVaultDataGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
|
|
/**
|
|
* Fields of the VaultData model
|
|
*/
|
|
readonly fields: VaultDataFieldRefs;
|
|
}
|
|
|
|
/**
|
|
* The delegate class that acts as a "Promise-like" for VaultData.
|
|
* 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__VaultDataClient<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 VaultData model
|
|
*/
|
|
interface VaultDataFieldRefs {
|
|
readonly id: FieldRef<"VaultData", 'String'>
|
|
readonly entityType: FieldRef<"VaultData", 'String'>
|
|
readonly entityId: FieldRef<"VaultData", 'String'>
|
|
readonly secureData: FieldRef<"VaultData", 'String'>
|
|
readonly createdAt: FieldRef<"VaultData", 'DateTime'>
|
|
}
|
|
|
|
|
|
// Custom InputTypes
|
|
/**
|
|
* VaultData findUnique
|
|
*/
|
|
export type VaultDataFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which VaultData to fetch.
|
|
*/
|
|
where: VaultDataWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* VaultData findUniqueOrThrow
|
|
*/
|
|
export type VaultDataFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which VaultData to fetch.
|
|
*/
|
|
where: VaultDataWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* VaultData findFirst
|
|
*/
|
|
export type VaultDataFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which VaultData to fetch.
|
|
*/
|
|
where?: VaultDataWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of VaultData to fetch.
|
|
*/
|
|
orderBy?: VaultDataOrderByWithRelationInput | VaultDataOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for VaultData.
|
|
*/
|
|
cursor?: VaultDataWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` VaultData 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` VaultData.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of VaultData.
|
|
*/
|
|
distinct?: VaultDataScalarFieldEnum | VaultDataScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* VaultData findFirstOrThrow
|
|
*/
|
|
export type VaultDataFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which VaultData to fetch.
|
|
*/
|
|
where?: VaultDataWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of VaultData to fetch.
|
|
*/
|
|
orderBy?: VaultDataOrderByWithRelationInput | VaultDataOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for searching for VaultData.
|
|
*/
|
|
cursor?: VaultDataWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` VaultData 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` VaultData.
|
|
*/
|
|
skip?: number
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
|
|
*
|
|
* Filter by unique combinations of VaultData.
|
|
*/
|
|
distinct?: VaultDataScalarFieldEnum | VaultDataScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* VaultData findMany
|
|
*/
|
|
export type VaultDataFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* Filter, which VaultData to fetch.
|
|
*/
|
|
where?: VaultDataWhereInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
|
|
*
|
|
* Determine the order of VaultData to fetch.
|
|
*/
|
|
orderBy?: VaultDataOrderByWithRelationInput | VaultDataOrderByWithRelationInput[]
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
|
|
*
|
|
* Sets the position for listing VaultData.
|
|
*/
|
|
cursor?: VaultDataWhereUniqueInput
|
|
/**
|
|
* {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
|
|
*
|
|
* Take `±n` VaultData 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` VaultData.
|
|
*/
|
|
skip?: number
|
|
distinct?: VaultDataScalarFieldEnum | VaultDataScalarFieldEnum[]
|
|
}
|
|
|
|
/**
|
|
* VaultData create
|
|
*/
|
|
export type VaultDataCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to create a VaultData.
|
|
*/
|
|
data: XOR<VaultDataCreateInput, VaultDataUncheckedCreateInput>
|
|
}
|
|
|
|
/**
|
|
* VaultData createMany
|
|
*/
|
|
export type VaultDataCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to create many VaultData.
|
|
*/
|
|
data: VaultDataCreateManyInput | VaultDataCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* VaultData createManyAndReturn
|
|
*/
|
|
export type VaultDataCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelectCreateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to create many VaultData.
|
|
*/
|
|
data: VaultDataCreateManyInput | VaultDataCreateManyInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
/**
|
|
* VaultData update
|
|
*/
|
|
export type VaultDataUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* The data needed to update a VaultData.
|
|
*/
|
|
data: XOR<VaultDataUpdateInput, VaultDataUncheckedUpdateInput>
|
|
/**
|
|
* Choose, which VaultData to update.
|
|
*/
|
|
where: VaultDataWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* VaultData updateMany
|
|
*/
|
|
export type VaultDataUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* The data used to update VaultData.
|
|
*/
|
|
data: XOR<VaultDataUpdateManyMutationInput, VaultDataUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which VaultData to update
|
|
*/
|
|
where?: VaultDataWhereInput
|
|
/**
|
|
* Limit how many VaultData to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* VaultData updateManyAndReturn
|
|
*/
|
|
export type VaultDataUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelectUpdateManyAndReturn<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* The data used to update VaultData.
|
|
*/
|
|
data: XOR<VaultDataUpdateManyMutationInput, VaultDataUncheckedUpdateManyInput>
|
|
/**
|
|
* Filter which VaultData to update
|
|
*/
|
|
where?: VaultDataWhereInput
|
|
/**
|
|
* Limit how many VaultData to update.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* VaultData upsert
|
|
*/
|
|
export type VaultDataUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* The filter to search for the VaultData to update in case it exists.
|
|
*/
|
|
where: VaultDataWhereUniqueInput
|
|
/**
|
|
* In case the VaultData found by the `where` argument doesn't exist, create a new VaultData with this data.
|
|
*/
|
|
create: XOR<VaultDataCreateInput, VaultDataUncheckedCreateInput>
|
|
/**
|
|
* In case the VaultData was found with the provided `where` argument, update it with this data.
|
|
*/
|
|
update: XOR<VaultDataUpdateInput, VaultDataUncheckedUpdateInput>
|
|
}
|
|
|
|
/**
|
|
* VaultData delete
|
|
*/
|
|
export type VaultDataDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
/**
|
|
* Filter which VaultData to delete.
|
|
*/
|
|
where: VaultDataWhereUniqueInput
|
|
}
|
|
|
|
/**
|
|
* VaultData deleteMany
|
|
*/
|
|
export type VaultDataDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Filter which VaultData to delete
|
|
*/
|
|
where?: VaultDataWhereInput
|
|
/**
|
|
* Limit how many VaultData to delete.
|
|
*/
|
|
limit?: number
|
|
}
|
|
|
|
/**
|
|
* VaultData without action
|
|
*/
|
|
export type VaultDataDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
|
|
/**
|
|
* Select specific fields to fetch from the VaultData
|
|
*/
|
|
select?: VaultDataSelect<ExtArgs> | null
|
|
/**
|
|
* Omit specific fields from the VaultData
|
|
*/
|
|
omit?: VaultDataOmit<ExtArgs> | null
|
|
}
|
|
|
|
|
|
/**
|
|
* Enums
|
|
*/
|
|
|
|
export const TransactionIsolationLevel: {
|
|
ReadUncommitted: 'ReadUncommitted',
|
|
ReadCommitted: 'ReadCommitted',
|
|
RepeatableRead: 'RepeatableRead',
|
|
Serializable: 'Serializable'
|
|
};
|
|
|
|
export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
|
|
|
|
|
|
export const UnitScalarFieldEnum: {
|
|
id: 'id',
|
|
name: 'name',
|
|
description: 'description',
|
|
parentId: 'parentId',
|
|
traits: 'traits',
|
|
createdAt: 'createdAt',
|
|
updatedAt: 'updatedAt'
|
|
};
|
|
|
|
export type UnitScalarFieldEnum = (typeof UnitScalarFieldEnum)[keyof typeof UnitScalarFieldEnum]
|
|
|
|
|
|
export const PersonScalarFieldEnum: {
|
|
id: 'id',
|
|
firstName: 'firstName',
|
|
lastName: 'lastName',
|
|
email: 'email',
|
|
phone: 'phone',
|
|
ssoId: 'ssoId',
|
|
traits: 'traits',
|
|
createdAt: 'createdAt',
|
|
updatedAt: 'updatedAt'
|
|
};
|
|
|
|
export type PersonScalarFieldEnum = (typeof PersonScalarFieldEnum)[keyof typeof PersonScalarFieldEnum]
|
|
|
|
|
|
export const GroupScalarFieldEnum: {
|
|
id: 'id',
|
|
name: 'name',
|
|
traits: 'traits',
|
|
createdAt: 'createdAt',
|
|
updatedAt: 'updatedAt'
|
|
};
|
|
|
|
export type GroupScalarFieldEnum = (typeof GroupScalarFieldEnum)[keyof typeof GroupScalarFieldEnum]
|
|
|
|
|
|
export const GroupMembershipScalarFieldEnum: {
|
|
id: 'id',
|
|
personId: 'personId',
|
|
groupId: 'groupId',
|
|
role: 'role'
|
|
};
|
|
|
|
export type GroupMembershipScalarFieldEnum = (typeof GroupMembershipScalarFieldEnum)[keyof typeof GroupMembershipScalarFieldEnum]
|
|
|
|
|
|
export const EventScalarFieldEnum: {
|
|
id: 'id',
|
|
type: 'type',
|
|
status: 'status',
|
|
startTime: 'startTime',
|
|
endTime: 'endTime',
|
|
targetUnitId: 'targetUnitId',
|
|
targetGroupId: 'targetGroupId',
|
|
targetPersonId: 'targetPersonId',
|
|
payload: 'payload',
|
|
parentEventId: 'parentEventId',
|
|
createdAt: 'createdAt',
|
|
updatedAt: 'updatedAt'
|
|
};
|
|
|
|
export type EventScalarFieldEnum = (typeof EventScalarFieldEnum)[keyof typeof EventScalarFieldEnum]
|
|
|
|
|
|
export const CitiesScalarFieldEnum: {
|
|
id: 'id',
|
|
name: 'name',
|
|
state_id: 'state_id',
|
|
state_code: 'state_code',
|
|
country_id: 'country_id',
|
|
country_code: 'country_code',
|
|
type: 'type',
|
|
level: 'level',
|
|
parent_id: 'parent_id',
|
|
latitude: 'latitude',
|
|
longitude: 'longitude',
|
|
native: 'native',
|
|
population: 'population',
|
|
timezone: 'timezone',
|
|
translations: 'translations',
|
|
created_at: 'created_at',
|
|
updated_at: 'updated_at',
|
|
flag: 'flag',
|
|
wikiDataId: 'wikiDataId'
|
|
};
|
|
|
|
export type CitiesScalarFieldEnum = (typeof CitiesScalarFieldEnum)[keyof typeof CitiesScalarFieldEnum]
|
|
|
|
|
|
export const CountriesScalarFieldEnum: {
|
|
id: 'id',
|
|
name: 'name',
|
|
iso3: 'iso3',
|
|
numeric_code: 'numeric_code',
|
|
iso2: 'iso2',
|
|
phonecode: 'phonecode',
|
|
capital: 'capital',
|
|
currency: 'currency',
|
|
currency_name: 'currency_name',
|
|
currency_symbol: 'currency_symbol',
|
|
tld: 'tld',
|
|
native: 'native',
|
|
population: 'population',
|
|
gdp: 'gdp',
|
|
region: 'region',
|
|
region_id: 'region_id',
|
|
subregion: 'subregion',
|
|
subregion_id: 'subregion_id',
|
|
nationality: 'nationality',
|
|
area_sq_km: 'area_sq_km',
|
|
postal_code_format: 'postal_code_format',
|
|
postal_code_regex: 'postal_code_regex',
|
|
timezones: 'timezones',
|
|
translations: 'translations',
|
|
latitude: 'latitude',
|
|
longitude: 'longitude',
|
|
emoji: 'emoji',
|
|
emojiU: 'emojiU',
|
|
created_at: 'created_at',
|
|
updated_at: 'updated_at',
|
|
flag: 'flag',
|
|
wikiDataId: 'wikiDataId'
|
|
};
|
|
|
|
export type CountriesScalarFieldEnum = (typeof CountriesScalarFieldEnum)[keyof typeof CountriesScalarFieldEnum]
|
|
|
|
|
|
export const StatesScalarFieldEnum: {
|
|
id: 'id',
|
|
name: 'name',
|
|
country_id: 'country_id',
|
|
country_code: 'country_code',
|
|
fips_code: 'fips_code',
|
|
iso2: 'iso2',
|
|
iso3166_2: 'iso3166_2',
|
|
type: 'type',
|
|
level: 'level',
|
|
parent_id: 'parent_id',
|
|
native: 'native',
|
|
latitude: 'latitude',
|
|
longitude: 'longitude',
|
|
timezone: 'timezone',
|
|
translations: 'translations',
|
|
created_at: 'created_at',
|
|
updated_at: 'updated_at',
|
|
flag: 'flag',
|
|
wikiDataId: 'wikiDataId',
|
|
population: 'population'
|
|
};
|
|
|
|
export type StatesScalarFieldEnum = (typeof StatesScalarFieldEnum)[keyof typeof StatesScalarFieldEnum]
|
|
|
|
|
|
export const AddressScalarFieldEnum: {
|
|
id: 'id',
|
|
street: 'street',
|
|
streetNo: 'streetNo',
|
|
postalCode: 'postalCode',
|
|
cityId: 'cityId',
|
|
stateId: 'stateId',
|
|
countryId: 'countryId',
|
|
rawCity: 'rawCity',
|
|
rawCountry: 'rawCountry',
|
|
createdAt: 'createdAt',
|
|
updatedAt: 'updatedAt'
|
|
};
|
|
|
|
export type AddressScalarFieldEnum = (typeof AddressScalarFieldEnum)[keyof typeof AddressScalarFieldEnum]
|
|
|
|
|
|
export const VaultDataScalarFieldEnum: {
|
|
id: 'id',
|
|
entityType: 'entityType',
|
|
entityId: 'entityId',
|
|
secureData: 'secureData',
|
|
createdAt: 'createdAt'
|
|
};
|
|
|
|
export type VaultDataScalarFieldEnum = (typeof VaultDataScalarFieldEnum)[keyof typeof VaultDataScalarFieldEnum]
|
|
|
|
|
|
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 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 '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 '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 'BigInt'
|
|
*/
|
|
export type BigIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'BigInt'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'BigInt[]'
|
|
*/
|
|
export type ListBigIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'BigInt[]'>
|
|
|
|
|
|
|
|
/**
|
|
* 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 'Decimal'
|
|
*/
|
|
export type DecimalFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Decimal'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Decimal[]'
|
|
*/
|
|
export type ListDecimalFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Decimal[]'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Float'
|
|
*/
|
|
export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
|
|
|
|
|
|
|
|
/**
|
|
* Reference to a field of type 'Float[]'
|
|
*/
|
|
export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
|
|
|
|
/**
|
|
* Deep Input Types
|
|
*/
|
|
|
|
|
|
export type UnitWhereInput = {
|
|
AND?: UnitWhereInput | UnitWhereInput[]
|
|
OR?: UnitWhereInput[]
|
|
NOT?: UnitWhereInput | UnitWhereInput[]
|
|
id?: StringFilter<"Unit"> | string
|
|
name?: StringFilter<"Unit"> | string
|
|
description?: StringNullableFilter<"Unit"> | string | null
|
|
parentId?: StringNullableFilter<"Unit"> | string | null
|
|
traits?: JsonFilter<"Unit">
|
|
createdAt?: DateTimeFilter<"Unit"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Unit"> | Date | string
|
|
parent?: XOR<UnitNullableScalarRelationFilter, UnitWhereInput> | null
|
|
children?: UnitListRelationFilter
|
|
}
|
|
|
|
export type UnitOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
description?: SortOrderInput | SortOrder
|
|
parentId?: SortOrderInput | SortOrder
|
|
traits?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
parent?: UnitOrderByWithRelationInput
|
|
children?: UnitOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type UnitWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: UnitWhereInput | UnitWhereInput[]
|
|
OR?: UnitWhereInput[]
|
|
NOT?: UnitWhereInput | UnitWhereInput[]
|
|
name?: StringFilter<"Unit"> | string
|
|
description?: StringNullableFilter<"Unit"> | string | null
|
|
parentId?: StringNullableFilter<"Unit"> | string | null
|
|
traits?: JsonFilter<"Unit">
|
|
createdAt?: DateTimeFilter<"Unit"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Unit"> | Date | string
|
|
parent?: XOR<UnitNullableScalarRelationFilter, UnitWhereInput> | null
|
|
children?: UnitListRelationFilter
|
|
}, "id">
|
|
|
|
export type UnitOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
description?: SortOrderInput | SortOrder
|
|
parentId?: SortOrderInput | SortOrder
|
|
traits?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
_count?: UnitCountOrderByAggregateInput
|
|
_max?: UnitMaxOrderByAggregateInput
|
|
_min?: UnitMinOrderByAggregateInput
|
|
}
|
|
|
|
export type UnitScalarWhereWithAggregatesInput = {
|
|
AND?: UnitScalarWhereWithAggregatesInput | UnitScalarWhereWithAggregatesInput[]
|
|
OR?: UnitScalarWhereWithAggregatesInput[]
|
|
NOT?: UnitScalarWhereWithAggregatesInput | UnitScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Unit"> | string
|
|
name?: StringWithAggregatesFilter<"Unit"> | string
|
|
description?: StringNullableWithAggregatesFilter<"Unit"> | string | null
|
|
parentId?: StringNullableWithAggregatesFilter<"Unit"> | string | null
|
|
traits?: JsonWithAggregatesFilter<"Unit">
|
|
createdAt?: DateTimeWithAggregatesFilter<"Unit"> | Date | string
|
|
updatedAt?: DateTimeWithAggregatesFilter<"Unit"> | Date | string
|
|
}
|
|
|
|
export type PersonWhereInput = {
|
|
AND?: PersonWhereInput | PersonWhereInput[]
|
|
OR?: PersonWhereInput[]
|
|
NOT?: PersonWhereInput | PersonWhereInput[]
|
|
id?: StringFilter<"Person"> | string
|
|
firstName?: StringFilter<"Person"> | string
|
|
lastName?: StringFilter<"Person"> | string
|
|
email?: StringNullableFilter<"Person"> | string | null
|
|
phone?: StringNullableFilter<"Person"> | string | null
|
|
ssoId?: StringNullableFilter<"Person"> | string | null
|
|
traits?: JsonFilter<"Person">
|
|
createdAt?: DateTimeFilter<"Person"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Person"> | Date | string
|
|
groupMemberships?: GroupMembershipListRelationFilter
|
|
}
|
|
|
|
export type PersonOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
firstName?: SortOrder
|
|
lastName?: SortOrder
|
|
email?: SortOrderInput | SortOrder
|
|
phone?: SortOrderInput | SortOrder
|
|
ssoId?: SortOrderInput | SortOrder
|
|
traits?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
groupMemberships?: GroupMembershipOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type PersonWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
email?: string
|
|
ssoId?: string
|
|
AND?: PersonWhereInput | PersonWhereInput[]
|
|
OR?: PersonWhereInput[]
|
|
NOT?: PersonWhereInput | PersonWhereInput[]
|
|
firstName?: StringFilter<"Person"> | string
|
|
lastName?: StringFilter<"Person"> | string
|
|
phone?: StringNullableFilter<"Person"> | string | null
|
|
traits?: JsonFilter<"Person">
|
|
createdAt?: DateTimeFilter<"Person"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Person"> | Date | string
|
|
groupMemberships?: GroupMembershipListRelationFilter
|
|
}, "id" | "email" | "ssoId">
|
|
|
|
export type PersonOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
firstName?: SortOrder
|
|
lastName?: SortOrder
|
|
email?: SortOrderInput | SortOrder
|
|
phone?: SortOrderInput | SortOrder
|
|
ssoId?: SortOrderInput | SortOrder
|
|
traits?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
_count?: PersonCountOrderByAggregateInput
|
|
_max?: PersonMaxOrderByAggregateInput
|
|
_min?: PersonMinOrderByAggregateInput
|
|
}
|
|
|
|
export type PersonScalarWhereWithAggregatesInput = {
|
|
AND?: PersonScalarWhereWithAggregatesInput | PersonScalarWhereWithAggregatesInput[]
|
|
OR?: PersonScalarWhereWithAggregatesInput[]
|
|
NOT?: PersonScalarWhereWithAggregatesInput | PersonScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Person"> | string
|
|
firstName?: StringWithAggregatesFilter<"Person"> | string
|
|
lastName?: StringWithAggregatesFilter<"Person"> | string
|
|
email?: StringNullableWithAggregatesFilter<"Person"> | string | null
|
|
phone?: StringNullableWithAggregatesFilter<"Person"> | string | null
|
|
ssoId?: StringNullableWithAggregatesFilter<"Person"> | string | null
|
|
traits?: JsonWithAggregatesFilter<"Person">
|
|
createdAt?: DateTimeWithAggregatesFilter<"Person"> | Date | string
|
|
updatedAt?: DateTimeWithAggregatesFilter<"Person"> | Date | string
|
|
}
|
|
|
|
export type GroupWhereInput = {
|
|
AND?: GroupWhereInput | GroupWhereInput[]
|
|
OR?: GroupWhereInput[]
|
|
NOT?: GroupWhereInput | GroupWhereInput[]
|
|
id?: StringFilter<"Group"> | string
|
|
name?: StringFilter<"Group"> | string
|
|
traits?: JsonFilter<"Group">
|
|
createdAt?: DateTimeFilter<"Group"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Group"> | Date | string
|
|
members?: GroupMembershipListRelationFilter
|
|
}
|
|
|
|
export type GroupOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
traits?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
members?: GroupMembershipOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type GroupWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: GroupWhereInput | GroupWhereInput[]
|
|
OR?: GroupWhereInput[]
|
|
NOT?: GroupWhereInput | GroupWhereInput[]
|
|
name?: StringFilter<"Group"> | string
|
|
traits?: JsonFilter<"Group">
|
|
createdAt?: DateTimeFilter<"Group"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Group"> | Date | string
|
|
members?: GroupMembershipListRelationFilter
|
|
}, "id">
|
|
|
|
export type GroupOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
traits?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
_count?: GroupCountOrderByAggregateInput
|
|
_max?: GroupMaxOrderByAggregateInput
|
|
_min?: GroupMinOrderByAggregateInput
|
|
}
|
|
|
|
export type GroupScalarWhereWithAggregatesInput = {
|
|
AND?: GroupScalarWhereWithAggregatesInput | GroupScalarWhereWithAggregatesInput[]
|
|
OR?: GroupScalarWhereWithAggregatesInput[]
|
|
NOT?: GroupScalarWhereWithAggregatesInput | GroupScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Group"> | string
|
|
name?: StringWithAggregatesFilter<"Group"> | string
|
|
traits?: JsonWithAggregatesFilter<"Group">
|
|
createdAt?: DateTimeWithAggregatesFilter<"Group"> | Date | string
|
|
updatedAt?: DateTimeWithAggregatesFilter<"Group"> | Date | string
|
|
}
|
|
|
|
export type GroupMembershipWhereInput = {
|
|
AND?: GroupMembershipWhereInput | GroupMembershipWhereInput[]
|
|
OR?: GroupMembershipWhereInput[]
|
|
NOT?: GroupMembershipWhereInput | GroupMembershipWhereInput[]
|
|
id?: StringFilter<"GroupMembership"> | string
|
|
personId?: StringFilter<"GroupMembership"> | string
|
|
groupId?: StringFilter<"GroupMembership"> | string
|
|
role?: StringFilter<"GroupMembership"> | string
|
|
group?: XOR<GroupScalarRelationFilter, GroupWhereInput>
|
|
person?: XOR<PersonScalarRelationFilter, PersonWhereInput>
|
|
}
|
|
|
|
export type GroupMembershipOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
personId?: SortOrder
|
|
groupId?: SortOrder
|
|
role?: SortOrder
|
|
group?: GroupOrderByWithRelationInput
|
|
person?: PersonOrderByWithRelationInput
|
|
}
|
|
|
|
export type GroupMembershipWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
personId_groupId_role?: GroupMembershipPersonIdGroupIdRoleCompoundUniqueInput
|
|
AND?: GroupMembershipWhereInput | GroupMembershipWhereInput[]
|
|
OR?: GroupMembershipWhereInput[]
|
|
NOT?: GroupMembershipWhereInput | GroupMembershipWhereInput[]
|
|
personId?: StringFilter<"GroupMembership"> | string
|
|
groupId?: StringFilter<"GroupMembership"> | string
|
|
role?: StringFilter<"GroupMembership"> | string
|
|
group?: XOR<GroupScalarRelationFilter, GroupWhereInput>
|
|
person?: XOR<PersonScalarRelationFilter, PersonWhereInput>
|
|
}, "id" | "personId_groupId_role">
|
|
|
|
export type GroupMembershipOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
personId?: SortOrder
|
|
groupId?: SortOrder
|
|
role?: SortOrder
|
|
_count?: GroupMembershipCountOrderByAggregateInput
|
|
_max?: GroupMembershipMaxOrderByAggregateInput
|
|
_min?: GroupMembershipMinOrderByAggregateInput
|
|
}
|
|
|
|
export type GroupMembershipScalarWhereWithAggregatesInput = {
|
|
AND?: GroupMembershipScalarWhereWithAggregatesInput | GroupMembershipScalarWhereWithAggregatesInput[]
|
|
OR?: GroupMembershipScalarWhereWithAggregatesInput[]
|
|
NOT?: GroupMembershipScalarWhereWithAggregatesInput | GroupMembershipScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"GroupMembership"> | string
|
|
personId?: StringWithAggregatesFilter<"GroupMembership"> | string
|
|
groupId?: StringWithAggregatesFilter<"GroupMembership"> | string
|
|
role?: StringWithAggregatesFilter<"GroupMembership"> | string
|
|
}
|
|
|
|
export type EventWhereInput = {
|
|
AND?: EventWhereInput | EventWhereInput[]
|
|
OR?: EventWhereInput[]
|
|
NOT?: EventWhereInput | EventWhereInput[]
|
|
id?: StringFilter<"Event"> | string
|
|
type?: StringFilter<"Event"> | string
|
|
status?: StringFilter<"Event"> | string
|
|
startTime?: DateTimeFilter<"Event"> | Date | string
|
|
endTime?: DateTimeNullableFilter<"Event"> | Date | string | null
|
|
targetUnitId?: StringNullableFilter<"Event"> | string | null
|
|
targetGroupId?: StringNullableFilter<"Event"> | string | null
|
|
targetPersonId?: StringNullableFilter<"Event"> | string | null
|
|
payload?: JsonFilter<"Event">
|
|
parentEventId?: StringNullableFilter<"Event"> | string | null
|
|
createdAt?: DateTimeFilter<"Event"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Event"> | Date | string
|
|
}
|
|
|
|
export type EventOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
type?: SortOrder
|
|
status?: SortOrder
|
|
startTime?: SortOrder
|
|
endTime?: SortOrderInput | SortOrder
|
|
targetUnitId?: SortOrderInput | SortOrder
|
|
targetGroupId?: SortOrderInput | SortOrder
|
|
targetPersonId?: SortOrderInput | SortOrder
|
|
payload?: SortOrder
|
|
parentEventId?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type EventWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: EventWhereInput | EventWhereInput[]
|
|
OR?: EventWhereInput[]
|
|
NOT?: EventWhereInput | EventWhereInput[]
|
|
type?: StringFilter<"Event"> | string
|
|
status?: StringFilter<"Event"> | string
|
|
startTime?: DateTimeFilter<"Event"> | Date | string
|
|
endTime?: DateTimeNullableFilter<"Event"> | Date | string | null
|
|
targetUnitId?: StringNullableFilter<"Event"> | string | null
|
|
targetGroupId?: StringNullableFilter<"Event"> | string | null
|
|
targetPersonId?: StringNullableFilter<"Event"> | string | null
|
|
payload?: JsonFilter<"Event">
|
|
parentEventId?: StringNullableFilter<"Event"> | string | null
|
|
createdAt?: DateTimeFilter<"Event"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Event"> | Date | string
|
|
}, "id">
|
|
|
|
export type EventOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
type?: SortOrder
|
|
status?: SortOrder
|
|
startTime?: SortOrder
|
|
endTime?: SortOrderInput | SortOrder
|
|
targetUnitId?: SortOrderInput | SortOrder
|
|
targetGroupId?: SortOrderInput | SortOrder
|
|
targetPersonId?: SortOrderInput | SortOrder
|
|
payload?: SortOrder
|
|
parentEventId?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
_count?: EventCountOrderByAggregateInput
|
|
_max?: EventMaxOrderByAggregateInput
|
|
_min?: EventMinOrderByAggregateInput
|
|
}
|
|
|
|
export type EventScalarWhereWithAggregatesInput = {
|
|
AND?: EventScalarWhereWithAggregatesInput | EventScalarWhereWithAggregatesInput[]
|
|
OR?: EventScalarWhereWithAggregatesInput[]
|
|
NOT?: EventScalarWhereWithAggregatesInput | EventScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Event"> | string
|
|
type?: StringWithAggregatesFilter<"Event"> | string
|
|
status?: StringWithAggregatesFilter<"Event"> | string
|
|
startTime?: DateTimeWithAggregatesFilter<"Event"> | Date | string
|
|
endTime?: DateTimeNullableWithAggregatesFilter<"Event"> | Date | string | null
|
|
targetUnitId?: StringNullableWithAggregatesFilter<"Event"> | string | null
|
|
targetGroupId?: StringNullableWithAggregatesFilter<"Event"> | string | null
|
|
targetPersonId?: StringNullableWithAggregatesFilter<"Event"> | string | null
|
|
payload?: JsonWithAggregatesFilter<"Event">
|
|
parentEventId?: StringNullableWithAggregatesFilter<"Event"> | string | null
|
|
createdAt?: DateTimeWithAggregatesFilter<"Event"> | Date | string
|
|
updatedAt?: DateTimeWithAggregatesFilter<"Event"> | Date | string
|
|
}
|
|
|
|
export type citiesWhereInput = {
|
|
AND?: citiesWhereInput | citiesWhereInput[]
|
|
OR?: citiesWhereInput[]
|
|
NOT?: citiesWhereInput | citiesWhereInput[]
|
|
id?: BigIntFilter<"cities"> | bigint | number
|
|
name?: StringFilter<"cities"> | string
|
|
state_id?: BigIntFilter<"cities"> | bigint | number
|
|
state_code?: StringFilter<"cities"> | string
|
|
country_id?: BigIntFilter<"cities"> | bigint | number
|
|
country_code?: StringFilter<"cities"> | string
|
|
type?: StringNullableFilter<"cities"> | string | null
|
|
level?: IntNullableFilter<"cities"> | number | null
|
|
parent_id?: BigIntNullableFilter<"cities"> | bigint | number | null
|
|
latitude?: DecimalFilter<"cities"> | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFilter<"cities"> | Decimal | DecimalJsLike | number | string
|
|
native?: StringNullableFilter<"cities"> | string | null
|
|
population?: BigIntNullableFilter<"cities"> | bigint | number | null
|
|
timezone?: StringNullableFilter<"cities"> | string | null
|
|
translations?: StringNullableFilter<"cities"> | string | null
|
|
created_at?: DateTimeFilter<"cities"> | Date | string
|
|
updated_at?: DateTimeFilter<"cities"> | Date | string
|
|
flag?: IntFilter<"cities"> | number
|
|
wikiDataId?: StringNullableFilter<"cities"> | string | null
|
|
countries?: XOR<CountriesScalarRelationFilter, countriesWhereInput>
|
|
states?: XOR<StatesScalarRelationFilter, statesWhereInput>
|
|
}
|
|
|
|
export type citiesOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
state_id?: SortOrder
|
|
state_code?: SortOrder
|
|
country_id?: SortOrder
|
|
country_code?: SortOrder
|
|
type?: SortOrderInput | SortOrder
|
|
level?: SortOrderInput | SortOrder
|
|
parent_id?: SortOrderInput | SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
native?: SortOrderInput | SortOrder
|
|
population?: SortOrderInput | SortOrder
|
|
timezone?: SortOrderInput | SortOrder
|
|
translations?: SortOrderInput | SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrderInput | SortOrder
|
|
countries?: countriesOrderByWithRelationInput
|
|
states?: statesOrderByWithRelationInput
|
|
}
|
|
|
|
export type citiesWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: bigint | number
|
|
AND?: citiesWhereInput | citiesWhereInput[]
|
|
OR?: citiesWhereInput[]
|
|
NOT?: citiesWhereInput | citiesWhereInput[]
|
|
name?: StringFilter<"cities"> | string
|
|
state_id?: BigIntFilter<"cities"> | bigint | number
|
|
state_code?: StringFilter<"cities"> | string
|
|
country_id?: BigIntFilter<"cities"> | bigint | number
|
|
country_code?: StringFilter<"cities"> | string
|
|
type?: StringNullableFilter<"cities"> | string | null
|
|
level?: IntNullableFilter<"cities"> | number | null
|
|
parent_id?: BigIntNullableFilter<"cities"> | bigint | number | null
|
|
latitude?: DecimalFilter<"cities"> | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFilter<"cities"> | Decimal | DecimalJsLike | number | string
|
|
native?: StringNullableFilter<"cities"> | string | null
|
|
population?: BigIntNullableFilter<"cities"> | bigint | number | null
|
|
timezone?: StringNullableFilter<"cities"> | string | null
|
|
translations?: StringNullableFilter<"cities"> | string | null
|
|
created_at?: DateTimeFilter<"cities"> | Date | string
|
|
updated_at?: DateTimeFilter<"cities"> | Date | string
|
|
flag?: IntFilter<"cities"> | number
|
|
wikiDataId?: StringNullableFilter<"cities"> | string | null
|
|
countries?: XOR<CountriesScalarRelationFilter, countriesWhereInput>
|
|
states?: XOR<StatesScalarRelationFilter, statesWhereInput>
|
|
}, "id">
|
|
|
|
export type citiesOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
state_id?: SortOrder
|
|
state_code?: SortOrder
|
|
country_id?: SortOrder
|
|
country_code?: SortOrder
|
|
type?: SortOrderInput | SortOrder
|
|
level?: SortOrderInput | SortOrder
|
|
parent_id?: SortOrderInput | SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
native?: SortOrderInput | SortOrder
|
|
population?: SortOrderInput | SortOrder
|
|
timezone?: SortOrderInput | SortOrder
|
|
translations?: SortOrderInput | SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrderInput | SortOrder
|
|
_count?: citiesCountOrderByAggregateInput
|
|
_avg?: citiesAvgOrderByAggregateInput
|
|
_max?: citiesMaxOrderByAggregateInput
|
|
_min?: citiesMinOrderByAggregateInput
|
|
_sum?: citiesSumOrderByAggregateInput
|
|
}
|
|
|
|
export type citiesScalarWhereWithAggregatesInput = {
|
|
AND?: citiesScalarWhereWithAggregatesInput | citiesScalarWhereWithAggregatesInput[]
|
|
OR?: citiesScalarWhereWithAggregatesInput[]
|
|
NOT?: citiesScalarWhereWithAggregatesInput | citiesScalarWhereWithAggregatesInput[]
|
|
id?: BigIntWithAggregatesFilter<"cities"> | bigint | number
|
|
name?: StringWithAggregatesFilter<"cities"> | string
|
|
state_id?: BigIntWithAggregatesFilter<"cities"> | bigint | number
|
|
state_code?: StringWithAggregatesFilter<"cities"> | string
|
|
country_id?: BigIntWithAggregatesFilter<"cities"> | bigint | number
|
|
country_code?: StringWithAggregatesFilter<"cities"> | string
|
|
type?: StringNullableWithAggregatesFilter<"cities"> | string | null
|
|
level?: IntNullableWithAggregatesFilter<"cities"> | number | null
|
|
parent_id?: BigIntNullableWithAggregatesFilter<"cities"> | bigint | number | null
|
|
latitude?: DecimalWithAggregatesFilter<"cities"> | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalWithAggregatesFilter<"cities"> | Decimal | DecimalJsLike | number | string
|
|
native?: StringNullableWithAggregatesFilter<"cities"> | string | null
|
|
population?: BigIntNullableWithAggregatesFilter<"cities"> | bigint | number | null
|
|
timezone?: StringNullableWithAggregatesFilter<"cities"> | string | null
|
|
translations?: StringNullableWithAggregatesFilter<"cities"> | string | null
|
|
created_at?: DateTimeWithAggregatesFilter<"cities"> | Date | string
|
|
updated_at?: DateTimeWithAggregatesFilter<"cities"> | Date | string
|
|
flag?: IntWithAggregatesFilter<"cities"> | number
|
|
wikiDataId?: StringNullableWithAggregatesFilter<"cities"> | string | null
|
|
}
|
|
|
|
export type countriesWhereInput = {
|
|
AND?: countriesWhereInput | countriesWhereInput[]
|
|
OR?: countriesWhereInput[]
|
|
NOT?: countriesWhereInput | countriesWhereInput[]
|
|
id?: BigIntFilter<"countries"> | bigint | number
|
|
name?: StringFilter<"countries"> | string
|
|
iso3?: StringNullableFilter<"countries"> | string | null
|
|
numeric_code?: StringNullableFilter<"countries"> | string | null
|
|
iso2?: StringNullableFilter<"countries"> | string | null
|
|
phonecode?: StringNullableFilter<"countries"> | string | null
|
|
capital?: StringNullableFilter<"countries"> | string | null
|
|
currency?: StringNullableFilter<"countries"> | string | null
|
|
currency_name?: StringNullableFilter<"countries"> | string | null
|
|
currency_symbol?: StringNullableFilter<"countries"> | string | null
|
|
tld?: StringNullableFilter<"countries"> | string | null
|
|
native?: StringNullableFilter<"countries"> | string | null
|
|
population?: BigIntNullableFilter<"countries"> | bigint | number | null
|
|
gdp?: BigIntNullableFilter<"countries"> | bigint | number | null
|
|
region?: StringNullableFilter<"countries"> | string | null
|
|
region_id?: BigIntNullableFilter<"countries"> | bigint | number | null
|
|
subregion?: StringNullableFilter<"countries"> | string | null
|
|
subregion_id?: BigIntNullableFilter<"countries"> | bigint | number | null
|
|
nationality?: StringNullableFilter<"countries"> | string | null
|
|
area_sq_km?: FloatNullableFilter<"countries"> | number | null
|
|
postal_code_format?: StringNullableFilter<"countries"> | string | null
|
|
postal_code_regex?: StringNullableFilter<"countries"> | string | null
|
|
timezones?: StringNullableFilter<"countries"> | string | null
|
|
translations?: StringNullableFilter<"countries"> | string | null
|
|
latitude?: DecimalNullableFilter<"countries"> | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: DecimalNullableFilter<"countries"> | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: StringNullableFilter<"countries"> | string | null
|
|
emojiU?: StringNullableFilter<"countries"> | string | null
|
|
created_at?: DateTimeNullableFilter<"countries"> | Date | string | null
|
|
updated_at?: DateTimeFilter<"countries"> | Date | string
|
|
flag?: IntFilter<"countries"> | number
|
|
wikiDataId?: StringNullableFilter<"countries"> | string | null
|
|
cities?: CitiesListRelationFilter
|
|
states?: StatesListRelationFilter
|
|
}
|
|
|
|
export type countriesOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
iso3?: SortOrderInput | SortOrder
|
|
numeric_code?: SortOrderInput | SortOrder
|
|
iso2?: SortOrderInput | SortOrder
|
|
phonecode?: SortOrderInput | SortOrder
|
|
capital?: SortOrderInput | SortOrder
|
|
currency?: SortOrderInput | SortOrder
|
|
currency_name?: SortOrderInput | SortOrder
|
|
currency_symbol?: SortOrderInput | SortOrder
|
|
tld?: SortOrderInput | SortOrder
|
|
native?: SortOrderInput | SortOrder
|
|
population?: SortOrderInput | SortOrder
|
|
gdp?: SortOrderInput | SortOrder
|
|
region?: SortOrderInput | SortOrder
|
|
region_id?: SortOrderInput | SortOrder
|
|
subregion?: SortOrderInput | SortOrder
|
|
subregion_id?: SortOrderInput | SortOrder
|
|
nationality?: SortOrderInput | SortOrder
|
|
area_sq_km?: SortOrderInput | SortOrder
|
|
postal_code_format?: SortOrderInput | SortOrder
|
|
postal_code_regex?: SortOrderInput | SortOrder
|
|
timezones?: SortOrderInput | SortOrder
|
|
translations?: SortOrderInput | SortOrder
|
|
latitude?: SortOrderInput | SortOrder
|
|
longitude?: SortOrderInput | SortOrder
|
|
emoji?: SortOrderInput | SortOrder
|
|
emojiU?: SortOrderInput | SortOrder
|
|
created_at?: SortOrderInput | SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrderInput | SortOrder
|
|
cities?: citiesOrderByRelationAggregateInput
|
|
states?: statesOrderByRelationAggregateInput
|
|
}
|
|
|
|
export type countriesWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: bigint | number
|
|
AND?: countriesWhereInput | countriesWhereInput[]
|
|
OR?: countriesWhereInput[]
|
|
NOT?: countriesWhereInput | countriesWhereInput[]
|
|
name?: StringFilter<"countries"> | string
|
|
iso3?: StringNullableFilter<"countries"> | string | null
|
|
numeric_code?: StringNullableFilter<"countries"> | string | null
|
|
iso2?: StringNullableFilter<"countries"> | string | null
|
|
phonecode?: StringNullableFilter<"countries"> | string | null
|
|
capital?: StringNullableFilter<"countries"> | string | null
|
|
currency?: StringNullableFilter<"countries"> | string | null
|
|
currency_name?: StringNullableFilter<"countries"> | string | null
|
|
currency_symbol?: StringNullableFilter<"countries"> | string | null
|
|
tld?: StringNullableFilter<"countries"> | string | null
|
|
native?: StringNullableFilter<"countries"> | string | null
|
|
population?: BigIntNullableFilter<"countries"> | bigint | number | null
|
|
gdp?: BigIntNullableFilter<"countries"> | bigint | number | null
|
|
region?: StringNullableFilter<"countries"> | string | null
|
|
region_id?: BigIntNullableFilter<"countries"> | bigint | number | null
|
|
subregion?: StringNullableFilter<"countries"> | string | null
|
|
subregion_id?: BigIntNullableFilter<"countries"> | bigint | number | null
|
|
nationality?: StringNullableFilter<"countries"> | string | null
|
|
area_sq_km?: FloatNullableFilter<"countries"> | number | null
|
|
postal_code_format?: StringNullableFilter<"countries"> | string | null
|
|
postal_code_regex?: StringNullableFilter<"countries"> | string | null
|
|
timezones?: StringNullableFilter<"countries"> | string | null
|
|
translations?: StringNullableFilter<"countries"> | string | null
|
|
latitude?: DecimalNullableFilter<"countries"> | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: DecimalNullableFilter<"countries"> | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: StringNullableFilter<"countries"> | string | null
|
|
emojiU?: StringNullableFilter<"countries"> | string | null
|
|
created_at?: DateTimeNullableFilter<"countries"> | Date | string | null
|
|
updated_at?: DateTimeFilter<"countries"> | Date | string
|
|
flag?: IntFilter<"countries"> | number
|
|
wikiDataId?: StringNullableFilter<"countries"> | string | null
|
|
cities?: CitiesListRelationFilter
|
|
states?: StatesListRelationFilter
|
|
}, "id">
|
|
|
|
export type countriesOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
iso3?: SortOrderInput | SortOrder
|
|
numeric_code?: SortOrderInput | SortOrder
|
|
iso2?: SortOrderInput | SortOrder
|
|
phonecode?: SortOrderInput | SortOrder
|
|
capital?: SortOrderInput | SortOrder
|
|
currency?: SortOrderInput | SortOrder
|
|
currency_name?: SortOrderInput | SortOrder
|
|
currency_symbol?: SortOrderInput | SortOrder
|
|
tld?: SortOrderInput | SortOrder
|
|
native?: SortOrderInput | SortOrder
|
|
population?: SortOrderInput | SortOrder
|
|
gdp?: SortOrderInput | SortOrder
|
|
region?: SortOrderInput | SortOrder
|
|
region_id?: SortOrderInput | SortOrder
|
|
subregion?: SortOrderInput | SortOrder
|
|
subregion_id?: SortOrderInput | SortOrder
|
|
nationality?: SortOrderInput | SortOrder
|
|
area_sq_km?: SortOrderInput | SortOrder
|
|
postal_code_format?: SortOrderInput | SortOrder
|
|
postal_code_regex?: SortOrderInput | SortOrder
|
|
timezones?: SortOrderInput | SortOrder
|
|
translations?: SortOrderInput | SortOrder
|
|
latitude?: SortOrderInput | SortOrder
|
|
longitude?: SortOrderInput | SortOrder
|
|
emoji?: SortOrderInput | SortOrder
|
|
emojiU?: SortOrderInput | SortOrder
|
|
created_at?: SortOrderInput | SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrderInput | SortOrder
|
|
_count?: countriesCountOrderByAggregateInput
|
|
_avg?: countriesAvgOrderByAggregateInput
|
|
_max?: countriesMaxOrderByAggregateInput
|
|
_min?: countriesMinOrderByAggregateInput
|
|
_sum?: countriesSumOrderByAggregateInput
|
|
}
|
|
|
|
export type countriesScalarWhereWithAggregatesInput = {
|
|
AND?: countriesScalarWhereWithAggregatesInput | countriesScalarWhereWithAggregatesInput[]
|
|
OR?: countriesScalarWhereWithAggregatesInput[]
|
|
NOT?: countriesScalarWhereWithAggregatesInput | countriesScalarWhereWithAggregatesInput[]
|
|
id?: BigIntWithAggregatesFilter<"countries"> | bigint | number
|
|
name?: StringWithAggregatesFilter<"countries"> | string
|
|
iso3?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
numeric_code?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
iso2?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
phonecode?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
capital?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
currency?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
currency_name?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
currency_symbol?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
tld?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
native?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
population?: BigIntNullableWithAggregatesFilter<"countries"> | bigint | number | null
|
|
gdp?: BigIntNullableWithAggregatesFilter<"countries"> | bigint | number | null
|
|
region?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
region_id?: BigIntNullableWithAggregatesFilter<"countries"> | bigint | number | null
|
|
subregion?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
subregion_id?: BigIntNullableWithAggregatesFilter<"countries"> | bigint | number | null
|
|
nationality?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
area_sq_km?: FloatNullableWithAggregatesFilter<"countries"> | number | null
|
|
postal_code_format?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
postal_code_regex?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
timezones?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
translations?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
latitude?: DecimalNullableWithAggregatesFilter<"countries"> | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: DecimalNullableWithAggregatesFilter<"countries"> | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
emojiU?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
created_at?: DateTimeNullableWithAggregatesFilter<"countries"> | Date | string | null
|
|
updated_at?: DateTimeWithAggregatesFilter<"countries"> | Date | string
|
|
flag?: IntWithAggregatesFilter<"countries"> | number
|
|
wikiDataId?: StringNullableWithAggregatesFilter<"countries"> | string | null
|
|
}
|
|
|
|
export type statesWhereInput = {
|
|
AND?: statesWhereInput | statesWhereInput[]
|
|
OR?: statesWhereInput[]
|
|
NOT?: statesWhereInput | statesWhereInput[]
|
|
id?: BigIntFilter<"states"> | bigint | number
|
|
name?: StringFilter<"states"> | string
|
|
country_id?: BigIntFilter<"states"> | bigint | number
|
|
country_code?: StringFilter<"states"> | string
|
|
fips_code?: StringNullableFilter<"states"> | string | null
|
|
iso2?: StringNullableFilter<"states"> | string | null
|
|
iso3166_2?: StringNullableFilter<"states"> | string | null
|
|
type?: StringNullableFilter<"states"> | string | null
|
|
level?: IntNullableFilter<"states"> | number | null
|
|
parent_id?: BigIntNullableFilter<"states"> | bigint | number | null
|
|
native?: StringNullableFilter<"states"> | string | null
|
|
latitude?: DecimalNullableFilter<"states"> | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: DecimalNullableFilter<"states"> | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: StringNullableFilter<"states"> | string | null
|
|
translations?: StringNullableFilter<"states"> | string | null
|
|
created_at?: DateTimeNullableFilter<"states"> | Date | string | null
|
|
updated_at?: DateTimeFilter<"states"> | Date | string
|
|
flag?: IntFilter<"states"> | number
|
|
wikiDataId?: StringNullableFilter<"states"> | string | null
|
|
population?: StringNullableFilter<"states"> | string | null
|
|
cities?: CitiesListRelationFilter
|
|
countries?: XOR<CountriesScalarRelationFilter, countriesWhereInput>
|
|
}
|
|
|
|
export type statesOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
country_id?: SortOrder
|
|
country_code?: SortOrder
|
|
fips_code?: SortOrderInput | SortOrder
|
|
iso2?: SortOrderInput | SortOrder
|
|
iso3166_2?: SortOrderInput | SortOrder
|
|
type?: SortOrderInput | SortOrder
|
|
level?: SortOrderInput | SortOrder
|
|
parent_id?: SortOrderInput | SortOrder
|
|
native?: SortOrderInput | SortOrder
|
|
latitude?: SortOrderInput | SortOrder
|
|
longitude?: SortOrderInput | SortOrder
|
|
timezone?: SortOrderInput | SortOrder
|
|
translations?: SortOrderInput | SortOrder
|
|
created_at?: SortOrderInput | SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrderInput | SortOrder
|
|
population?: SortOrderInput | SortOrder
|
|
cities?: citiesOrderByRelationAggregateInput
|
|
countries?: countriesOrderByWithRelationInput
|
|
}
|
|
|
|
export type statesWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: bigint | number
|
|
AND?: statesWhereInput | statesWhereInput[]
|
|
OR?: statesWhereInput[]
|
|
NOT?: statesWhereInput | statesWhereInput[]
|
|
name?: StringFilter<"states"> | string
|
|
country_id?: BigIntFilter<"states"> | bigint | number
|
|
country_code?: StringFilter<"states"> | string
|
|
fips_code?: StringNullableFilter<"states"> | string | null
|
|
iso2?: StringNullableFilter<"states"> | string | null
|
|
iso3166_2?: StringNullableFilter<"states"> | string | null
|
|
type?: StringNullableFilter<"states"> | string | null
|
|
level?: IntNullableFilter<"states"> | number | null
|
|
parent_id?: BigIntNullableFilter<"states"> | bigint | number | null
|
|
native?: StringNullableFilter<"states"> | string | null
|
|
latitude?: DecimalNullableFilter<"states"> | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: DecimalNullableFilter<"states"> | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: StringNullableFilter<"states"> | string | null
|
|
translations?: StringNullableFilter<"states"> | string | null
|
|
created_at?: DateTimeNullableFilter<"states"> | Date | string | null
|
|
updated_at?: DateTimeFilter<"states"> | Date | string
|
|
flag?: IntFilter<"states"> | number
|
|
wikiDataId?: StringNullableFilter<"states"> | string | null
|
|
population?: StringNullableFilter<"states"> | string | null
|
|
cities?: CitiesListRelationFilter
|
|
countries?: XOR<CountriesScalarRelationFilter, countriesWhereInput>
|
|
}, "id">
|
|
|
|
export type statesOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
country_id?: SortOrder
|
|
country_code?: SortOrder
|
|
fips_code?: SortOrderInput | SortOrder
|
|
iso2?: SortOrderInput | SortOrder
|
|
iso3166_2?: SortOrderInput | SortOrder
|
|
type?: SortOrderInput | SortOrder
|
|
level?: SortOrderInput | SortOrder
|
|
parent_id?: SortOrderInput | SortOrder
|
|
native?: SortOrderInput | SortOrder
|
|
latitude?: SortOrderInput | SortOrder
|
|
longitude?: SortOrderInput | SortOrder
|
|
timezone?: SortOrderInput | SortOrder
|
|
translations?: SortOrderInput | SortOrder
|
|
created_at?: SortOrderInput | SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrderInput | SortOrder
|
|
population?: SortOrderInput | SortOrder
|
|
_count?: statesCountOrderByAggregateInput
|
|
_avg?: statesAvgOrderByAggregateInput
|
|
_max?: statesMaxOrderByAggregateInput
|
|
_min?: statesMinOrderByAggregateInput
|
|
_sum?: statesSumOrderByAggregateInput
|
|
}
|
|
|
|
export type statesScalarWhereWithAggregatesInput = {
|
|
AND?: statesScalarWhereWithAggregatesInput | statesScalarWhereWithAggregatesInput[]
|
|
OR?: statesScalarWhereWithAggregatesInput[]
|
|
NOT?: statesScalarWhereWithAggregatesInput | statesScalarWhereWithAggregatesInput[]
|
|
id?: BigIntWithAggregatesFilter<"states"> | bigint | number
|
|
name?: StringWithAggregatesFilter<"states"> | string
|
|
country_id?: BigIntWithAggregatesFilter<"states"> | bigint | number
|
|
country_code?: StringWithAggregatesFilter<"states"> | string
|
|
fips_code?: StringNullableWithAggregatesFilter<"states"> | string | null
|
|
iso2?: StringNullableWithAggregatesFilter<"states"> | string | null
|
|
iso3166_2?: StringNullableWithAggregatesFilter<"states"> | string | null
|
|
type?: StringNullableWithAggregatesFilter<"states"> | string | null
|
|
level?: IntNullableWithAggregatesFilter<"states"> | number | null
|
|
parent_id?: BigIntNullableWithAggregatesFilter<"states"> | bigint | number | null
|
|
native?: StringNullableWithAggregatesFilter<"states"> | string | null
|
|
latitude?: DecimalNullableWithAggregatesFilter<"states"> | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: DecimalNullableWithAggregatesFilter<"states"> | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: StringNullableWithAggregatesFilter<"states"> | string | null
|
|
translations?: StringNullableWithAggregatesFilter<"states"> | string | null
|
|
created_at?: DateTimeNullableWithAggregatesFilter<"states"> | Date | string | null
|
|
updated_at?: DateTimeWithAggregatesFilter<"states"> | Date | string
|
|
flag?: IntWithAggregatesFilter<"states"> | number
|
|
wikiDataId?: StringNullableWithAggregatesFilter<"states"> | string | null
|
|
population?: StringNullableWithAggregatesFilter<"states"> | string | null
|
|
}
|
|
|
|
export type AddressWhereInput = {
|
|
AND?: AddressWhereInput | AddressWhereInput[]
|
|
OR?: AddressWhereInput[]
|
|
NOT?: AddressWhereInput | AddressWhereInput[]
|
|
id?: StringFilter<"Address"> | string
|
|
street?: StringFilter<"Address"> | string
|
|
streetNo?: StringNullableFilter<"Address"> | string | null
|
|
postalCode?: StringNullableFilter<"Address"> | string | null
|
|
cityId?: IntNullableFilter<"Address"> | number | null
|
|
stateId?: IntNullableFilter<"Address"> | number | null
|
|
countryId?: IntNullableFilter<"Address"> | number | null
|
|
rawCity?: StringNullableFilter<"Address"> | string | null
|
|
rawCountry?: StringNullableFilter<"Address"> | string | null
|
|
createdAt?: DateTimeFilter<"Address"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Address"> | Date | string
|
|
}
|
|
|
|
export type AddressOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
street?: SortOrder
|
|
streetNo?: SortOrderInput | SortOrder
|
|
postalCode?: SortOrderInput | SortOrder
|
|
cityId?: SortOrderInput | SortOrder
|
|
stateId?: SortOrderInput | SortOrder
|
|
countryId?: SortOrderInput | SortOrder
|
|
rawCity?: SortOrderInput | SortOrder
|
|
rawCountry?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type AddressWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: AddressWhereInput | AddressWhereInput[]
|
|
OR?: AddressWhereInput[]
|
|
NOT?: AddressWhereInput | AddressWhereInput[]
|
|
street?: StringFilter<"Address"> | string
|
|
streetNo?: StringNullableFilter<"Address"> | string | null
|
|
postalCode?: StringNullableFilter<"Address"> | string | null
|
|
cityId?: IntNullableFilter<"Address"> | number | null
|
|
stateId?: IntNullableFilter<"Address"> | number | null
|
|
countryId?: IntNullableFilter<"Address"> | number | null
|
|
rawCity?: StringNullableFilter<"Address"> | string | null
|
|
rawCountry?: StringNullableFilter<"Address"> | string | null
|
|
createdAt?: DateTimeFilter<"Address"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Address"> | Date | string
|
|
}, "id">
|
|
|
|
export type AddressOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
street?: SortOrder
|
|
streetNo?: SortOrderInput | SortOrder
|
|
postalCode?: SortOrderInput | SortOrder
|
|
cityId?: SortOrderInput | SortOrder
|
|
stateId?: SortOrderInput | SortOrder
|
|
countryId?: SortOrderInput | SortOrder
|
|
rawCity?: SortOrderInput | SortOrder
|
|
rawCountry?: SortOrderInput | SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
_count?: AddressCountOrderByAggregateInput
|
|
_avg?: AddressAvgOrderByAggregateInput
|
|
_max?: AddressMaxOrderByAggregateInput
|
|
_min?: AddressMinOrderByAggregateInput
|
|
_sum?: AddressSumOrderByAggregateInput
|
|
}
|
|
|
|
export type AddressScalarWhereWithAggregatesInput = {
|
|
AND?: AddressScalarWhereWithAggregatesInput | AddressScalarWhereWithAggregatesInput[]
|
|
OR?: AddressScalarWhereWithAggregatesInput[]
|
|
NOT?: AddressScalarWhereWithAggregatesInput | AddressScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"Address"> | string
|
|
street?: StringWithAggregatesFilter<"Address"> | string
|
|
streetNo?: StringNullableWithAggregatesFilter<"Address"> | string | null
|
|
postalCode?: StringNullableWithAggregatesFilter<"Address"> | string | null
|
|
cityId?: IntNullableWithAggregatesFilter<"Address"> | number | null
|
|
stateId?: IntNullableWithAggregatesFilter<"Address"> | number | null
|
|
countryId?: IntNullableWithAggregatesFilter<"Address"> | number | null
|
|
rawCity?: StringNullableWithAggregatesFilter<"Address"> | string | null
|
|
rawCountry?: StringNullableWithAggregatesFilter<"Address"> | string | null
|
|
createdAt?: DateTimeWithAggregatesFilter<"Address"> | Date | string
|
|
updatedAt?: DateTimeWithAggregatesFilter<"Address"> | Date | string
|
|
}
|
|
|
|
export type VaultDataWhereInput = {
|
|
AND?: VaultDataWhereInput | VaultDataWhereInput[]
|
|
OR?: VaultDataWhereInput[]
|
|
NOT?: VaultDataWhereInput | VaultDataWhereInput[]
|
|
id?: StringFilter<"VaultData"> | string
|
|
entityType?: StringFilter<"VaultData"> | string
|
|
entityId?: StringFilter<"VaultData"> | string
|
|
secureData?: StringFilter<"VaultData"> | string
|
|
createdAt?: DateTimeFilter<"VaultData"> | Date | string
|
|
}
|
|
|
|
export type VaultDataOrderByWithRelationInput = {
|
|
id?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
secureData?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type VaultDataWhereUniqueInput = Prisma.AtLeast<{
|
|
id?: string
|
|
AND?: VaultDataWhereInput | VaultDataWhereInput[]
|
|
OR?: VaultDataWhereInput[]
|
|
NOT?: VaultDataWhereInput | VaultDataWhereInput[]
|
|
entityType?: StringFilter<"VaultData"> | string
|
|
entityId?: StringFilter<"VaultData"> | string
|
|
secureData?: StringFilter<"VaultData"> | string
|
|
createdAt?: DateTimeFilter<"VaultData"> | Date | string
|
|
}, "id">
|
|
|
|
export type VaultDataOrderByWithAggregationInput = {
|
|
id?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
secureData?: SortOrder
|
|
createdAt?: SortOrder
|
|
_count?: VaultDataCountOrderByAggregateInput
|
|
_max?: VaultDataMaxOrderByAggregateInput
|
|
_min?: VaultDataMinOrderByAggregateInput
|
|
}
|
|
|
|
export type VaultDataScalarWhereWithAggregatesInput = {
|
|
AND?: VaultDataScalarWhereWithAggregatesInput | VaultDataScalarWhereWithAggregatesInput[]
|
|
OR?: VaultDataScalarWhereWithAggregatesInput[]
|
|
NOT?: VaultDataScalarWhereWithAggregatesInput | VaultDataScalarWhereWithAggregatesInput[]
|
|
id?: StringWithAggregatesFilter<"VaultData"> | string
|
|
entityType?: StringWithAggregatesFilter<"VaultData"> | string
|
|
entityId?: StringWithAggregatesFilter<"VaultData"> | string
|
|
secureData?: StringWithAggregatesFilter<"VaultData"> | string
|
|
createdAt?: DateTimeWithAggregatesFilter<"VaultData"> | Date | string
|
|
}
|
|
|
|
export type UnitCreateInput = {
|
|
id?: string
|
|
name: string
|
|
description?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
parent?: UnitCreateNestedOneWithoutChildrenInput
|
|
children?: UnitCreateNestedManyWithoutParentInput
|
|
}
|
|
|
|
export type UnitUncheckedCreateInput = {
|
|
id?: string
|
|
name: string
|
|
description?: string | null
|
|
parentId?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
children?: UnitUncheckedCreateNestedManyWithoutParentInput
|
|
}
|
|
|
|
export type UnitUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
parent?: UnitUpdateOneWithoutChildrenNestedInput
|
|
children?: UnitUpdateManyWithoutParentNestedInput
|
|
}
|
|
|
|
export type UnitUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
parentId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
children?: UnitUncheckedUpdateManyWithoutParentNestedInput
|
|
}
|
|
|
|
export type UnitCreateManyInput = {
|
|
id?: string
|
|
name: string
|
|
description?: string | null
|
|
parentId?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type UnitUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UnitUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
parentId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type PersonCreateInput = {
|
|
id?: string
|
|
firstName: string
|
|
lastName: string
|
|
email?: string | null
|
|
phone?: string | null
|
|
ssoId?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
groupMemberships?: GroupMembershipCreateNestedManyWithoutPersonInput
|
|
}
|
|
|
|
export type PersonUncheckedCreateInput = {
|
|
id?: string
|
|
firstName: string
|
|
lastName: string
|
|
email?: string | null
|
|
phone?: string | null
|
|
ssoId?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
groupMemberships?: GroupMembershipUncheckedCreateNestedManyWithoutPersonInput
|
|
}
|
|
|
|
export type PersonUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
firstName?: StringFieldUpdateOperationsInput | string
|
|
lastName?: StringFieldUpdateOperationsInput | string
|
|
email?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ssoId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
groupMemberships?: GroupMembershipUpdateManyWithoutPersonNestedInput
|
|
}
|
|
|
|
export type PersonUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
firstName?: StringFieldUpdateOperationsInput | string
|
|
lastName?: StringFieldUpdateOperationsInput | string
|
|
email?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ssoId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
groupMemberships?: GroupMembershipUncheckedUpdateManyWithoutPersonNestedInput
|
|
}
|
|
|
|
export type PersonCreateManyInput = {
|
|
id?: string
|
|
firstName: string
|
|
lastName: string
|
|
email?: string | null
|
|
phone?: string | null
|
|
ssoId?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type PersonUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
firstName?: StringFieldUpdateOperationsInput | string
|
|
lastName?: StringFieldUpdateOperationsInput | string
|
|
email?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ssoId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type PersonUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
firstName?: StringFieldUpdateOperationsInput | string
|
|
lastName?: StringFieldUpdateOperationsInput | string
|
|
email?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ssoId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type GroupCreateInput = {
|
|
id?: string
|
|
name: string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
members?: GroupMembershipCreateNestedManyWithoutGroupInput
|
|
}
|
|
|
|
export type GroupUncheckedCreateInput = {
|
|
id?: string
|
|
name: string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
members?: GroupMembershipUncheckedCreateNestedManyWithoutGroupInput
|
|
}
|
|
|
|
export type GroupUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
members?: GroupMembershipUpdateManyWithoutGroupNestedInput
|
|
}
|
|
|
|
export type GroupUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
members?: GroupMembershipUncheckedUpdateManyWithoutGroupNestedInput
|
|
}
|
|
|
|
export type GroupCreateManyInput = {
|
|
id?: string
|
|
name: string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type GroupUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type GroupUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type GroupMembershipCreateInput = {
|
|
id?: string
|
|
role: string
|
|
group: GroupCreateNestedOneWithoutMembersInput
|
|
person: PersonCreateNestedOneWithoutGroupMembershipsInput
|
|
}
|
|
|
|
export type GroupMembershipUncheckedCreateInput = {
|
|
id?: string
|
|
personId: string
|
|
groupId: string
|
|
role: string
|
|
}
|
|
|
|
export type GroupMembershipUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
role?: StringFieldUpdateOperationsInput | string
|
|
group?: GroupUpdateOneRequiredWithoutMembersNestedInput
|
|
person?: PersonUpdateOneRequiredWithoutGroupMembershipsNestedInput
|
|
}
|
|
|
|
export type GroupMembershipUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
personId?: StringFieldUpdateOperationsInput | string
|
|
groupId?: StringFieldUpdateOperationsInput | string
|
|
role?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type GroupMembershipCreateManyInput = {
|
|
id?: string
|
|
personId: string
|
|
groupId: string
|
|
role: string
|
|
}
|
|
|
|
export type GroupMembershipUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
role?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type GroupMembershipUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
personId?: StringFieldUpdateOperationsInput | string
|
|
groupId?: StringFieldUpdateOperationsInput | string
|
|
role?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type EventCreateInput = {
|
|
id?: string
|
|
type: string
|
|
status: string
|
|
startTime: Date | string
|
|
endTime?: Date | string | null
|
|
targetUnitId?: string | null
|
|
targetGroupId?: string | null
|
|
targetPersonId?: string | null
|
|
payload?: JsonNullValueInput | InputJsonValue
|
|
parentEventId?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type EventUncheckedCreateInput = {
|
|
id?: string
|
|
type: string
|
|
status: string
|
|
startTime: Date | string
|
|
endTime?: Date | string | null
|
|
targetUnitId?: string | null
|
|
targetGroupId?: string | null
|
|
targetPersonId?: string | null
|
|
payload?: JsonNullValueInput | InputJsonValue
|
|
parentEventId?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type EventUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
startTime?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
targetUnitId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
targetGroupId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
targetPersonId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
payload?: JsonNullValueInput | InputJsonValue
|
|
parentEventId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type EventUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
startTime?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
targetUnitId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
targetGroupId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
targetPersonId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
payload?: JsonNullValueInput | InputJsonValue
|
|
parentEventId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type EventCreateManyInput = {
|
|
id?: string
|
|
type: string
|
|
status: string
|
|
startTime: Date | string
|
|
endTime?: Date | string | null
|
|
targetUnitId?: string | null
|
|
targetGroupId?: string | null
|
|
targetPersonId?: string | null
|
|
payload?: JsonNullValueInput | InputJsonValue
|
|
parentEventId?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type EventUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
startTime?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
targetUnitId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
targetGroupId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
targetPersonId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
payload?: JsonNullValueInput | InputJsonValue
|
|
parentEventId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type EventUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
type?: StringFieldUpdateOperationsInput | string
|
|
status?: StringFieldUpdateOperationsInput | string
|
|
startTime?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
endTime?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
targetUnitId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
targetGroupId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
targetPersonId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
payload?: JsonNullValueInput | InputJsonValue
|
|
parentEventId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type citiesCreateInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
state_code: string
|
|
country_code: string
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
latitude: Decimal | DecimalJsLike | number | string
|
|
longitude: Decimal | DecimalJsLike | number | string
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
countries: countriesCreateNestedOneWithoutCitiesInput
|
|
states: statesCreateNestedOneWithoutCitiesInput
|
|
}
|
|
|
|
export type citiesUncheckedCreateInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
state_id: bigint | number
|
|
state_code: string
|
|
country_id: bigint | number
|
|
country_code: string
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
latitude: Decimal | DecimalJsLike | number | string
|
|
longitude: Decimal | DecimalJsLike | number | string
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
}
|
|
|
|
export type citiesUpdateInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
state_code?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
latitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
countries?: countriesUpdateOneRequiredWithoutCitiesNestedInput
|
|
states?: statesUpdateOneRequiredWithoutCitiesNestedInput
|
|
}
|
|
|
|
export type citiesUncheckedUpdateInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
state_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
state_code?: StringFieldUpdateOperationsInput | string
|
|
country_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
latitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type citiesCreateManyInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
state_id: bigint | number
|
|
state_code: string
|
|
country_id: bigint | number
|
|
country_code: string
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
latitude: Decimal | DecimalJsLike | number | string
|
|
longitude: Decimal | DecimalJsLike | number | string
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
}
|
|
|
|
export type citiesUpdateManyMutationInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
state_code?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
latitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type citiesUncheckedUpdateManyInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
state_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
state_code?: StringFieldUpdateOperationsInput | string
|
|
country_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
latitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type countriesCreateInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
iso3?: string | null
|
|
numeric_code?: string | null
|
|
iso2?: string | null
|
|
phonecode?: string | null
|
|
capital?: string | null
|
|
currency?: string | null
|
|
currency_name?: string | null
|
|
currency_symbol?: string | null
|
|
tld?: string | null
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
gdp?: bigint | number | null
|
|
region?: string | null
|
|
region_id?: bigint | number | null
|
|
subregion?: string | null
|
|
subregion_id?: bigint | number | null
|
|
nationality?: string | null
|
|
area_sq_km?: number | null
|
|
postal_code_format?: string | null
|
|
postal_code_regex?: string | null
|
|
timezones?: string | null
|
|
translations?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
emoji?: string | null
|
|
emojiU?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
cities?: citiesCreateNestedManyWithoutCountriesInput
|
|
states?: statesCreateNestedManyWithoutCountriesInput
|
|
}
|
|
|
|
export type countriesUncheckedCreateInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
iso3?: string | null
|
|
numeric_code?: string | null
|
|
iso2?: string | null
|
|
phonecode?: string | null
|
|
capital?: string | null
|
|
currency?: string | null
|
|
currency_name?: string | null
|
|
currency_symbol?: string | null
|
|
tld?: string | null
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
gdp?: bigint | number | null
|
|
region?: string | null
|
|
region_id?: bigint | number | null
|
|
subregion?: string | null
|
|
subregion_id?: bigint | number | null
|
|
nationality?: string | null
|
|
area_sq_km?: number | null
|
|
postal_code_format?: string | null
|
|
postal_code_regex?: string | null
|
|
timezones?: string | null
|
|
translations?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
emoji?: string | null
|
|
emojiU?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
cities?: citiesUncheckedCreateNestedManyWithoutCountriesInput
|
|
states?: statesUncheckedCreateNestedManyWithoutCountriesInput
|
|
}
|
|
|
|
export type countriesUpdateInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
iso3?: NullableStringFieldUpdateOperationsInput | string | null
|
|
numeric_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phonecode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
capital?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_symbol?: NullableStringFieldUpdateOperationsInput | string | null
|
|
tld?: NullableStringFieldUpdateOperationsInput | string | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
gdp?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
region?: NullableStringFieldUpdateOperationsInput | string | null
|
|
region_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
subregion?: NullableStringFieldUpdateOperationsInput | string | null
|
|
subregion_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
nationality?: NullableStringFieldUpdateOperationsInput | string | null
|
|
area_sq_km?: NullableFloatFieldUpdateOperationsInput | number | null
|
|
postal_code_format?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postal_code_regex?: NullableStringFieldUpdateOperationsInput | string | null
|
|
timezones?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emojiU?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cities?: citiesUpdateManyWithoutCountriesNestedInput
|
|
states?: statesUpdateManyWithoutCountriesNestedInput
|
|
}
|
|
|
|
export type countriesUncheckedUpdateInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
iso3?: NullableStringFieldUpdateOperationsInput | string | null
|
|
numeric_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phonecode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
capital?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_symbol?: NullableStringFieldUpdateOperationsInput | string | null
|
|
tld?: NullableStringFieldUpdateOperationsInput | string | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
gdp?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
region?: NullableStringFieldUpdateOperationsInput | string | null
|
|
region_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
subregion?: NullableStringFieldUpdateOperationsInput | string | null
|
|
subregion_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
nationality?: NullableStringFieldUpdateOperationsInput | string | null
|
|
area_sq_km?: NullableFloatFieldUpdateOperationsInput | number | null
|
|
postal_code_format?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postal_code_regex?: NullableStringFieldUpdateOperationsInput | string | null
|
|
timezones?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emojiU?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cities?: citiesUncheckedUpdateManyWithoutCountriesNestedInput
|
|
states?: statesUncheckedUpdateManyWithoutCountriesNestedInput
|
|
}
|
|
|
|
export type countriesCreateManyInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
iso3?: string | null
|
|
numeric_code?: string | null
|
|
iso2?: string | null
|
|
phonecode?: string | null
|
|
capital?: string | null
|
|
currency?: string | null
|
|
currency_name?: string | null
|
|
currency_symbol?: string | null
|
|
tld?: string | null
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
gdp?: bigint | number | null
|
|
region?: string | null
|
|
region_id?: bigint | number | null
|
|
subregion?: string | null
|
|
subregion_id?: bigint | number | null
|
|
nationality?: string | null
|
|
area_sq_km?: number | null
|
|
postal_code_format?: string | null
|
|
postal_code_regex?: string | null
|
|
timezones?: string | null
|
|
translations?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
emoji?: string | null
|
|
emojiU?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
}
|
|
|
|
export type countriesUpdateManyMutationInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
iso3?: NullableStringFieldUpdateOperationsInput | string | null
|
|
numeric_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phonecode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
capital?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_symbol?: NullableStringFieldUpdateOperationsInput | string | null
|
|
tld?: NullableStringFieldUpdateOperationsInput | string | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
gdp?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
region?: NullableStringFieldUpdateOperationsInput | string | null
|
|
region_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
subregion?: NullableStringFieldUpdateOperationsInput | string | null
|
|
subregion_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
nationality?: NullableStringFieldUpdateOperationsInput | string | null
|
|
area_sq_km?: NullableFloatFieldUpdateOperationsInput | number | null
|
|
postal_code_format?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postal_code_regex?: NullableStringFieldUpdateOperationsInput | string | null
|
|
timezones?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emojiU?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type countriesUncheckedUpdateManyInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
iso3?: NullableStringFieldUpdateOperationsInput | string | null
|
|
numeric_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phonecode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
capital?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_symbol?: NullableStringFieldUpdateOperationsInput | string | null
|
|
tld?: NullableStringFieldUpdateOperationsInput | string | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
gdp?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
region?: NullableStringFieldUpdateOperationsInput | string | null
|
|
region_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
subregion?: NullableStringFieldUpdateOperationsInput | string | null
|
|
subregion_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
nationality?: NullableStringFieldUpdateOperationsInput | string | null
|
|
area_sq_km?: NullableFloatFieldUpdateOperationsInput | number | null
|
|
postal_code_format?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postal_code_regex?: NullableStringFieldUpdateOperationsInput | string | null
|
|
timezones?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emojiU?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type statesCreateInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
country_code: string
|
|
fips_code?: string | null
|
|
iso2?: string | null
|
|
iso3166_2?: string | null
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
native?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
population?: string | null
|
|
cities?: citiesCreateNestedManyWithoutStatesInput
|
|
countries: countriesCreateNestedOneWithoutStatesInput
|
|
}
|
|
|
|
export type statesUncheckedCreateInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
country_id: bigint | number
|
|
country_code: string
|
|
fips_code?: string | null
|
|
iso2?: string | null
|
|
iso3166_2?: string | null
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
native?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
population?: string | null
|
|
cities?: citiesUncheckedCreateNestedManyWithoutStatesInput
|
|
}
|
|
|
|
export type statesUpdateInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
fips_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso3166_2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cities?: citiesUpdateManyWithoutStatesNestedInput
|
|
countries?: countriesUpdateOneRequiredWithoutStatesNestedInput
|
|
}
|
|
|
|
export type statesUncheckedUpdateInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
country_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
fips_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso3166_2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cities?: citiesUncheckedUpdateManyWithoutStatesNestedInput
|
|
}
|
|
|
|
export type statesCreateManyInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
country_id: bigint | number
|
|
country_code: string
|
|
fips_code?: string | null
|
|
iso2?: string | null
|
|
iso3166_2?: string | null
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
native?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
population?: string | null
|
|
}
|
|
|
|
export type statesUpdateManyMutationInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
fips_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso3166_2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type statesUncheckedUpdateManyInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
country_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
fips_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso3166_2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type AddressCreateInput = {
|
|
id?: string
|
|
street: string
|
|
streetNo?: string | null
|
|
postalCode?: string | null
|
|
cityId?: number | null
|
|
stateId?: number | null
|
|
countryId?: number | null
|
|
rawCity?: string | null
|
|
rawCountry?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type AddressUncheckedCreateInput = {
|
|
id?: string
|
|
street: string
|
|
streetNo?: string | null
|
|
postalCode?: string | null
|
|
cityId?: number | null
|
|
stateId?: number | null
|
|
countryId?: number | null
|
|
rawCity?: string | null
|
|
rawCountry?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type AddressUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
street?: StringFieldUpdateOperationsInput | string
|
|
streetNo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postalCode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cityId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
stateId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
countryId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
rawCity?: NullableStringFieldUpdateOperationsInput | string | null
|
|
rawCountry?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AddressUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
street?: StringFieldUpdateOperationsInput | string
|
|
streetNo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postalCode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cityId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
stateId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
countryId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
rawCity?: NullableStringFieldUpdateOperationsInput | string | null
|
|
rawCountry?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AddressCreateManyInput = {
|
|
id?: string
|
|
street: string
|
|
streetNo?: string | null
|
|
postalCode?: string | null
|
|
cityId?: number | null
|
|
stateId?: number | null
|
|
countryId?: number | null
|
|
rawCity?: string | null
|
|
rawCountry?: string | null
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type AddressUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
street?: StringFieldUpdateOperationsInput | string
|
|
streetNo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postalCode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cityId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
stateId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
countryId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
rawCity?: NullableStringFieldUpdateOperationsInput | string | null
|
|
rawCountry?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type AddressUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
street?: StringFieldUpdateOperationsInput | string
|
|
streetNo?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postalCode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cityId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
stateId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
countryId?: NullableIntFieldUpdateOperationsInput | number | null
|
|
rawCity?: NullableStringFieldUpdateOperationsInput | string | null
|
|
rawCountry?: NullableStringFieldUpdateOperationsInput | string | null
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type VaultDataCreateInput = {
|
|
id?: string
|
|
entityType: string
|
|
entityId: string
|
|
secureData: string
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type VaultDataUncheckedCreateInput = {
|
|
id?: string
|
|
entityType: string
|
|
entityId: string
|
|
secureData: string
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type VaultDataUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
secureData?: StringFieldUpdateOperationsInput | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type VaultDataUncheckedUpdateInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
secureData?: StringFieldUpdateOperationsInput | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type VaultDataCreateManyInput = {
|
|
id?: string
|
|
entityType: string
|
|
entityId: string
|
|
secureData: string
|
|
createdAt?: Date | string
|
|
}
|
|
|
|
export type VaultDataUpdateManyMutationInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
secureData?: StringFieldUpdateOperationsInput | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type VaultDataUncheckedUpdateManyInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
entityType?: StringFieldUpdateOperationsInput | string
|
|
entityId?: StringFieldUpdateOperationsInput | string
|
|
secureData?: StringFieldUpdateOperationsInput | string
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | 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 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 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 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 UnitNullableScalarRelationFilter = {
|
|
is?: UnitWhereInput | null
|
|
isNot?: UnitWhereInput | null
|
|
}
|
|
|
|
export type UnitListRelationFilter = {
|
|
every?: UnitWhereInput
|
|
some?: UnitWhereInput
|
|
none?: UnitWhereInput
|
|
}
|
|
|
|
export type SortOrderInput = {
|
|
sort: SortOrder
|
|
nulls?: NullsOrder
|
|
}
|
|
|
|
export type UnitOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type UnitCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
description?: SortOrder
|
|
parentId?: SortOrder
|
|
traits?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type UnitMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
description?: SortOrder
|
|
parentId?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type UnitMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
description?: SortOrder
|
|
parentId?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
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 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 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 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 GroupMembershipListRelationFilter = {
|
|
every?: GroupMembershipWhereInput
|
|
some?: GroupMembershipWhereInput
|
|
none?: GroupMembershipWhereInput
|
|
}
|
|
|
|
export type GroupMembershipOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type PersonCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
firstName?: SortOrder
|
|
lastName?: SortOrder
|
|
email?: SortOrder
|
|
phone?: SortOrder
|
|
ssoId?: SortOrder
|
|
traits?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type PersonMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
firstName?: SortOrder
|
|
lastName?: SortOrder
|
|
email?: SortOrder
|
|
phone?: SortOrder
|
|
ssoId?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type PersonMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
firstName?: SortOrder
|
|
lastName?: SortOrder
|
|
email?: SortOrder
|
|
phone?: SortOrder
|
|
ssoId?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type GroupCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
traits?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type GroupMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type GroupMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type GroupScalarRelationFilter = {
|
|
is?: GroupWhereInput
|
|
isNot?: GroupWhereInput
|
|
}
|
|
|
|
export type PersonScalarRelationFilter = {
|
|
is?: PersonWhereInput
|
|
isNot?: PersonWhereInput
|
|
}
|
|
|
|
export type GroupMembershipPersonIdGroupIdRoleCompoundUniqueInput = {
|
|
personId: string
|
|
groupId: string
|
|
role: string
|
|
}
|
|
|
|
export type GroupMembershipCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
personId?: SortOrder
|
|
groupId?: SortOrder
|
|
role?: SortOrder
|
|
}
|
|
|
|
export type GroupMembershipMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
personId?: SortOrder
|
|
groupId?: SortOrder
|
|
role?: SortOrder
|
|
}
|
|
|
|
export type GroupMembershipMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
personId?: SortOrder
|
|
groupId?: SortOrder
|
|
role?: SortOrder
|
|
}
|
|
|
|
export type DateTimeNullableFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
|
|
}
|
|
|
|
export type EventCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
type?: SortOrder
|
|
status?: SortOrder
|
|
startTime?: SortOrder
|
|
endTime?: SortOrder
|
|
targetUnitId?: SortOrder
|
|
targetGroupId?: SortOrder
|
|
targetPersonId?: SortOrder
|
|
payload?: SortOrder
|
|
parentEventId?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type EventMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
type?: SortOrder
|
|
status?: SortOrder
|
|
startTime?: SortOrder
|
|
endTime?: SortOrder
|
|
targetUnitId?: SortOrder
|
|
targetGroupId?: SortOrder
|
|
targetPersonId?: SortOrder
|
|
parentEventId?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type EventMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
type?: SortOrder
|
|
status?: SortOrder
|
|
startTime?: SortOrder
|
|
endTime?: SortOrder
|
|
targetUnitId?: SortOrder
|
|
targetGroupId?: SortOrder
|
|
targetPersonId?: SortOrder
|
|
parentEventId?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedDateTimeNullableFilter<$PrismaModel>
|
|
_max?: NestedDateTimeNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type BigIntFilter<$PrismaModel = never> = {
|
|
equals?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
|
|
notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
|
|
lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
not?: NestedBigIntFilter<$PrismaModel> | bigint | number
|
|
}
|
|
|
|
export type IntNullableFilter<$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 BigIntNullableFilter<$PrismaModel = never> = {
|
|
equals?: bigint | number | BigIntFieldRefInput<$PrismaModel> | null
|
|
in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel> | null
|
|
notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel> | null
|
|
lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
not?: NestedBigIntNullableFilter<$PrismaModel> | bigint | number | null
|
|
}
|
|
|
|
export type DecimalFilter<$PrismaModel = never> = {
|
|
equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
|
|
notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
|
|
lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
not?: NestedDecimalFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
|
|
}
|
|
|
|
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 CountriesScalarRelationFilter = {
|
|
is?: countriesWhereInput
|
|
isNot?: countriesWhereInput
|
|
}
|
|
|
|
export type StatesScalarRelationFilter = {
|
|
is?: statesWhereInput
|
|
isNot?: statesWhereInput
|
|
}
|
|
|
|
export type citiesCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
state_id?: SortOrder
|
|
state_code?: SortOrder
|
|
country_id?: SortOrder
|
|
country_code?: SortOrder
|
|
type?: SortOrder
|
|
level?: SortOrder
|
|
parent_id?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
native?: SortOrder
|
|
population?: SortOrder
|
|
timezone?: SortOrder
|
|
translations?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrder
|
|
}
|
|
|
|
export type citiesAvgOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
state_id?: SortOrder
|
|
country_id?: SortOrder
|
|
level?: SortOrder
|
|
parent_id?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
population?: SortOrder
|
|
flag?: SortOrder
|
|
}
|
|
|
|
export type citiesMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
state_id?: SortOrder
|
|
state_code?: SortOrder
|
|
country_id?: SortOrder
|
|
country_code?: SortOrder
|
|
type?: SortOrder
|
|
level?: SortOrder
|
|
parent_id?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
native?: SortOrder
|
|
population?: SortOrder
|
|
timezone?: SortOrder
|
|
translations?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrder
|
|
}
|
|
|
|
export type citiesMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
state_id?: SortOrder
|
|
state_code?: SortOrder
|
|
country_id?: SortOrder
|
|
country_code?: SortOrder
|
|
type?: SortOrder
|
|
level?: SortOrder
|
|
parent_id?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
native?: SortOrder
|
|
population?: SortOrder
|
|
timezone?: SortOrder
|
|
translations?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrder
|
|
}
|
|
|
|
export type citiesSumOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
state_id?: SortOrder
|
|
country_id?: SortOrder
|
|
level?: SortOrder
|
|
parent_id?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
population?: SortOrder
|
|
flag?: SortOrder
|
|
}
|
|
|
|
export type BigIntWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
|
|
notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
|
|
lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
not?: NestedBigIntWithAggregatesFilter<$PrismaModel> | bigint | number
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_avg?: NestedFloatFilter<$PrismaModel>
|
|
_sum?: NestedBigIntFilter<$PrismaModel>
|
|
_min?: NestedBigIntFilter<$PrismaModel>
|
|
_max?: NestedBigIntFilter<$PrismaModel>
|
|
}
|
|
|
|
export type IntNullableWithAggregatesFilter<$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?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_avg?: NestedFloatNullableFilter<$PrismaModel>
|
|
_sum?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedIntNullableFilter<$PrismaModel>
|
|
_max?: NestedIntNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type BigIntNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: bigint | number | BigIntFieldRefInput<$PrismaModel> | null
|
|
in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel> | null
|
|
notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel> | null
|
|
lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
not?: NestedBigIntNullableWithAggregatesFilter<$PrismaModel> | bigint | number | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_avg?: NestedFloatNullableFilter<$PrismaModel>
|
|
_sum?: NestedBigIntNullableFilter<$PrismaModel>
|
|
_min?: NestedBigIntNullableFilter<$PrismaModel>
|
|
_max?: NestedBigIntNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type DecimalWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
|
|
notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
|
|
lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
not?: NestedDecimalWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_avg?: NestedDecimalFilter<$PrismaModel>
|
|
_sum?: NestedDecimalFilter<$PrismaModel>
|
|
_min?: NestedDecimalFilter<$PrismaModel>
|
|
_max?: NestedDecimalFilter<$PrismaModel>
|
|
}
|
|
|
|
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 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 DecimalNullableFilter<$PrismaModel = never> = {
|
|
equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
|
|
in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
|
|
notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
|
|
lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
not?: NestedDecimalNullableFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
|
|
}
|
|
|
|
export type CitiesListRelationFilter = {
|
|
every?: citiesWhereInput
|
|
some?: citiesWhereInput
|
|
none?: citiesWhereInput
|
|
}
|
|
|
|
export type StatesListRelationFilter = {
|
|
every?: statesWhereInput
|
|
some?: statesWhereInput
|
|
none?: statesWhereInput
|
|
}
|
|
|
|
export type citiesOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type statesOrderByRelationAggregateInput = {
|
|
_count?: SortOrder
|
|
}
|
|
|
|
export type countriesCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
iso3?: SortOrder
|
|
numeric_code?: SortOrder
|
|
iso2?: SortOrder
|
|
phonecode?: SortOrder
|
|
capital?: SortOrder
|
|
currency?: SortOrder
|
|
currency_name?: SortOrder
|
|
currency_symbol?: SortOrder
|
|
tld?: SortOrder
|
|
native?: SortOrder
|
|
population?: SortOrder
|
|
gdp?: SortOrder
|
|
region?: SortOrder
|
|
region_id?: SortOrder
|
|
subregion?: SortOrder
|
|
subregion_id?: SortOrder
|
|
nationality?: SortOrder
|
|
area_sq_km?: SortOrder
|
|
postal_code_format?: SortOrder
|
|
postal_code_regex?: SortOrder
|
|
timezones?: SortOrder
|
|
translations?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
emoji?: SortOrder
|
|
emojiU?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrder
|
|
}
|
|
|
|
export type countriesAvgOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
population?: SortOrder
|
|
gdp?: SortOrder
|
|
region_id?: SortOrder
|
|
subregion_id?: SortOrder
|
|
area_sq_km?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
flag?: SortOrder
|
|
}
|
|
|
|
export type countriesMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
iso3?: SortOrder
|
|
numeric_code?: SortOrder
|
|
iso2?: SortOrder
|
|
phonecode?: SortOrder
|
|
capital?: SortOrder
|
|
currency?: SortOrder
|
|
currency_name?: SortOrder
|
|
currency_symbol?: SortOrder
|
|
tld?: SortOrder
|
|
native?: SortOrder
|
|
population?: SortOrder
|
|
gdp?: SortOrder
|
|
region?: SortOrder
|
|
region_id?: SortOrder
|
|
subregion?: SortOrder
|
|
subregion_id?: SortOrder
|
|
nationality?: SortOrder
|
|
area_sq_km?: SortOrder
|
|
postal_code_format?: SortOrder
|
|
postal_code_regex?: SortOrder
|
|
timezones?: SortOrder
|
|
translations?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
emoji?: SortOrder
|
|
emojiU?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrder
|
|
}
|
|
|
|
export type countriesMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
iso3?: SortOrder
|
|
numeric_code?: SortOrder
|
|
iso2?: SortOrder
|
|
phonecode?: SortOrder
|
|
capital?: SortOrder
|
|
currency?: SortOrder
|
|
currency_name?: SortOrder
|
|
currency_symbol?: SortOrder
|
|
tld?: SortOrder
|
|
native?: SortOrder
|
|
population?: SortOrder
|
|
gdp?: SortOrder
|
|
region?: SortOrder
|
|
region_id?: SortOrder
|
|
subregion?: SortOrder
|
|
subregion_id?: SortOrder
|
|
nationality?: SortOrder
|
|
area_sq_km?: SortOrder
|
|
postal_code_format?: SortOrder
|
|
postal_code_regex?: SortOrder
|
|
timezones?: SortOrder
|
|
translations?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
emoji?: SortOrder
|
|
emojiU?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrder
|
|
}
|
|
|
|
export type countriesSumOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
population?: SortOrder
|
|
gdp?: SortOrder
|
|
region_id?: SortOrder
|
|
subregion_id?: SortOrder
|
|
area_sq_km?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
flag?: 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 DecimalNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
|
|
in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
|
|
notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
|
|
lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
not?: NestedDecimalNullableWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_avg?: NestedDecimalNullableFilter<$PrismaModel>
|
|
_sum?: NestedDecimalNullableFilter<$PrismaModel>
|
|
_min?: NestedDecimalNullableFilter<$PrismaModel>
|
|
_max?: NestedDecimalNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type statesCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
country_id?: SortOrder
|
|
country_code?: SortOrder
|
|
fips_code?: SortOrder
|
|
iso2?: SortOrder
|
|
iso3166_2?: SortOrder
|
|
type?: SortOrder
|
|
level?: SortOrder
|
|
parent_id?: SortOrder
|
|
native?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
timezone?: SortOrder
|
|
translations?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrder
|
|
population?: SortOrder
|
|
}
|
|
|
|
export type statesAvgOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
country_id?: SortOrder
|
|
level?: SortOrder
|
|
parent_id?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
flag?: SortOrder
|
|
}
|
|
|
|
export type statesMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
country_id?: SortOrder
|
|
country_code?: SortOrder
|
|
fips_code?: SortOrder
|
|
iso2?: SortOrder
|
|
iso3166_2?: SortOrder
|
|
type?: SortOrder
|
|
level?: SortOrder
|
|
parent_id?: SortOrder
|
|
native?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
timezone?: SortOrder
|
|
translations?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrder
|
|
population?: SortOrder
|
|
}
|
|
|
|
export type statesMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
name?: SortOrder
|
|
country_id?: SortOrder
|
|
country_code?: SortOrder
|
|
fips_code?: SortOrder
|
|
iso2?: SortOrder
|
|
iso3166_2?: SortOrder
|
|
type?: SortOrder
|
|
level?: SortOrder
|
|
parent_id?: SortOrder
|
|
native?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
timezone?: SortOrder
|
|
translations?: SortOrder
|
|
created_at?: SortOrder
|
|
updated_at?: SortOrder
|
|
flag?: SortOrder
|
|
wikiDataId?: SortOrder
|
|
population?: SortOrder
|
|
}
|
|
|
|
export type statesSumOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
country_id?: SortOrder
|
|
level?: SortOrder
|
|
parent_id?: SortOrder
|
|
latitude?: SortOrder
|
|
longitude?: SortOrder
|
|
flag?: SortOrder
|
|
}
|
|
|
|
export type AddressCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
street?: SortOrder
|
|
streetNo?: SortOrder
|
|
postalCode?: SortOrder
|
|
cityId?: SortOrder
|
|
stateId?: SortOrder
|
|
countryId?: SortOrder
|
|
rawCity?: SortOrder
|
|
rawCountry?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type AddressAvgOrderByAggregateInput = {
|
|
cityId?: SortOrder
|
|
stateId?: SortOrder
|
|
countryId?: SortOrder
|
|
}
|
|
|
|
export type AddressMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
street?: SortOrder
|
|
streetNo?: SortOrder
|
|
postalCode?: SortOrder
|
|
cityId?: SortOrder
|
|
stateId?: SortOrder
|
|
countryId?: SortOrder
|
|
rawCity?: SortOrder
|
|
rawCountry?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type AddressMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
street?: SortOrder
|
|
streetNo?: SortOrder
|
|
postalCode?: SortOrder
|
|
cityId?: SortOrder
|
|
stateId?: SortOrder
|
|
countryId?: SortOrder
|
|
rawCity?: SortOrder
|
|
rawCountry?: SortOrder
|
|
createdAt?: SortOrder
|
|
updatedAt?: SortOrder
|
|
}
|
|
|
|
export type AddressSumOrderByAggregateInput = {
|
|
cityId?: SortOrder
|
|
stateId?: SortOrder
|
|
countryId?: SortOrder
|
|
}
|
|
|
|
export type VaultDataCountOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
secureData?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type VaultDataMaxOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
secureData?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type VaultDataMinOrderByAggregateInput = {
|
|
id?: SortOrder
|
|
entityType?: SortOrder
|
|
entityId?: SortOrder
|
|
secureData?: SortOrder
|
|
createdAt?: SortOrder
|
|
}
|
|
|
|
export type UnitCreateNestedOneWithoutChildrenInput = {
|
|
create?: XOR<UnitCreateWithoutChildrenInput, UnitUncheckedCreateWithoutChildrenInput>
|
|
connectOrCreate?: UnitCreateOrConnectWithoutChildrenInput
|
|
connect?: UnitWhereUniqueInput
|
|
}
|
|
|
|
export type UnitCreateNestedManyWithoutParentInput = {
|
|
create?: XOR<UnitCreateWithoutParentInput, UnitUncheckedCreateWithoutParentInput> | UnitCreateWithoutParentInput[] | UnitUncheckedCreateWithoutParentInput[]
|
|
connectOrCreate?: UnitCreateOrConnectWithoutParentInput | UnitCreateOrConnectWithoutParentInput[]
|
|
createMany?: UnitCreateManyParentInputEnvelope
|
|
connect?: UnitWhereUniqueInput | UnitWhereUniqueInput[]
|
|
}
|
|
|
|
export type UnitUncheckedCreateNestedManyWithoutParentInput = {
|
|
create?: XOR<UnitCreateWithoutParentInput, UnitUncheckedCreateWithoutParentInput> | UnitCreateWithoutParentInput[] | UnitUncheckedCreateWithoutParentInput[]
|
|
connectOrCreate?: UnitCreateOrConnectWithoutParentInput | UnitCreateOrConnectWithoutParentInput[]
|
|
createMany?: UnitCreateManyParentInputEnvelope
|
|
connect?: UnitWhereUniqueInput | UnitWhereUniqueInput[]
|
|
}
|
|
|
|
export type StringFieldUpdateOperationsInput = {
|
|
set?: string
|
|
}
|
|
|
|
export type NullableStringFieldUpdateOperationsInput = {
|
|
set?: string | null
|
|
}
|
|
|
|
export type DateTimeFieldUpdateOperationsInput = {
|
|
set?: Date | string
|
|
}
|
|
|
|
export type UnitUpdateOneWithoutChildrenNestedInput = {
|
|
create?: XOR<UnitCreateWithoutChildrenInput, UnitUncheckedCreateWithoutChildrenInput>
|
|
connectOrCreate?: UnitCreateOrConnectWithoutChildrenInput
|
|
upsert?: UnitUpsertWithoutChildrenInput
|
|
disconnect?: UnitWhereInput | boolean
|
|
delete?: UnitWhereInput | boolean
|
|
connect?: UnitWhereUniqueInput
|
|
update?: XOR<XOR<UnitUpdateToOneWithWhereWithoutChildrenInput, UnitUpdateWithoutChildrenInput>, UnitUncheckedUpdateWithoutChildrenInput>
|
|
}
|
|
|
|
export type UnitUpdateManyWithoutParentNestedInput = {
|
|
create?: XOR<UnitCreateWithoutParentInput, UnitUncheckedCreateWithoutParentInput> | UnitCreateWithoutParentInput[] | UnitUncheckedCreateWithoutParentInput[]
|
|
connectOrCreate?: UnitCreateOrConnectWithoutParentInput | UnitCreateOrConnectWithoutParentInput[]
|
|
upsert?: UnitUpsertWithWhereUniqueWithoutParentInput | UnitUpsertWithWhereUniqueWithoutParentInput[]
|
|
createMany?: UnitCreateManyParentInputEnvelope
|
|
set?: UnitWhereUniqueInput | UnitWhereUniqueInput[]
|
|
disconnect?: UnitWhereUniqueInput | UnitWhereUniqueInput[]
|
|
delete?: UnitWhereUniqueInput | UnitWhereUniqueInput[]
|
|
connect?: UnitWhereUniqueInput | UnitWhereUniqueInput[]
|
|
update?: UnitUpdateWithWhereUniqueWithoutParentInput | UnitUpdateWithWhereUniqueWithoutParentInput[]
|
|
updateMany?: UnitUpdateManyWithWhereWithoutParentInput | UnitUpdateManyWithWhereWithoutParentInput[]
|
|
deleteMany?: UnitScalarWhereInput | UnitScalarWhereInput[]
|
|
}
|
|
|
|
export type UnitUncheckedUpdateManyWithoutParentNestedInput = {
|
|
create?: XOR<UnitCreateWithoutParentInput, UnitUncheckedCreateWithoutParentInput> | UnitCreateWithoutParentInput[] | UnitUncheckedCreateWithoutParentInput[]
|
|
connectOrCreate?: UnitCreateOrConnectWithoutParentInput | UnitCreateOrConnectWithoutParentInput[]
|
|
upsert?: UnitUpsertWithWhereUniqueWithoutParentInput | UnitUpsertWithWhereUniqueWithoutParentInput[]
|
|
createMany?: UnitCreateManyParentInputEnvelope
|
|
set?: UnitWhereUniqueInput | UnitWhereUniqueInput[]
|
|
disconnect?: UnitWhereUniqueInput | UnitWhereUniqueInput[]
|
|
delete?: UnitWhereUniqueInput | UnitWhereUniqueInput[]
|
|
connect?: UnitWhereUniqueInput | UnitWhereUniqueInput[]
|
|
update?: UnitUpdateWithWhereUniqueWithoutParentInput | UnitUpdateWithWhereUniqueWithoutParentInput[]
|
|
updateMany?: UnitUpdateManyWithWhereWithoutParentInput | UnitUpdateManyWithWhereWithoutParentInput[]
|
|
deleteMany?: UnitScalarWhereInput | UnitScalarWhereInput[]
|
|
}
|
|
|
|
export type GroupMembershipCreateNestedManyWithoutPersonInput = {
|
|
create?: XOR<GroupMembershipCreateWithoutPersonInput, GroupMembershipUncheckedCreateWithoutPersonInput> | GroupMembershipCreateWithoutPersonInput[] | GroupMembershipUncheckedCreateWithoutPersonInput[]
|
|
connectOrCreate?: GroupMembershipCreateOrConnectWithoutPersonInput | GroupMembershipCreateOrConnectWithoutPersonInput[]
|
|
createMany?: GroupMembershipCreateManyPersonInputEnvelope
|
|
connect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
}
|
|
|
|
export type GroupMembershipUncheckedCreateNestedManyWithoutPersonInput = {
|
|
create?: XOR<GroupMembershipCreateWithoutPersonInput, GroupMembershipUncheckedCreateWithoutPersonInput> | GroupMembershipCreateWithoutPersonInput[] | GroupMembershipUncheckedCreateWithoutPersonInput[]
|
|
connectOrCreate?: GroupMembershipCreateOrConnectWithoutPersonInput | GroupMembershipCreateOrConnectWithoutPersonInput[]
|
|
createMany?: GroupMembershipCreateManyPersonInputEnvelope
|
|
connect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
}
|
|
|
|
export type GroupMembershipUpdateManyWithoutPersonNestedInput = {
|
|
create?: XOR<GroupMembershipCreateWithoutPersonInput, GroupMembershipUncheckedCreateWithoutPersonInput> | GroupMembershipCreateWithoutPersonInput[] | GroupMembershipUncheckedCreateWithoutPersonInput[]
|
|
connectOrCreate?: GroupMembershipCreateOrConnectWithoutPersonInput | GroupMembershipCreateOrConnectWithoutPersonInput[]
|
|
upsert?: GroupMembershipUpsertWithWhereUniqueWithoutPersonInput | GroupMembershipUpsertWithWhereUniqueWithoutPersonInput[]
|
|
createMany?: GroupMembershipCreateManyPersonInputEnvelope
|
|
set?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
disconnect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
delete?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
connect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
update?: GroupMembershipUpdateWithWhereUniqueWithoutPersonInput | GroupMembershipUpdateWithWhereUniqueWithoutPersonInput[]
|
|
updateMany?: GroupMembershipUpdateManyWithWhereWithoutPersonInput | GroupMembershipUpdateManyWithWhereWithoutPersonInput[]
|
|
deleteMany?: GroupMembershipScalarWhereInput | GroupMembershipScalarWhereInput[]
|
|
}
|
|
|
|
export type GroupMembershipUncheckedUpdateManyWithoutPersonNestedInput = {
|
|
create?: XOR<GroupMembershipCreateWithoutPersonInput, GroupMembershipUncheckedCreateWithoutPersonInput> | GroupMembershipCreateWithoutPersonInput[] | GroupMembershipUncheckedCreateWithoutPersonInput[]
|
|
connectOrCreate?: GroupMembershipCreateOrConnectWithoutPersonInput | GroupMembershipCreateOrConnectWithoutPersonInput[]
|
|
upsert?: GroupMembershipUpsertWithWhereUniqueWithoutPersonInput | GroupMembershipUpsertWithWhereUniqueWithoutPersonInput[]
|
|
createMany?: GroupMembershipCreateManyPersonInputEnvelope
|
|
set?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
disconnect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
delete?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
connect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
update?: GroupMembershipUpdateWithWhereUniqueWithoutPersonInput | GroupMembershipUpdateWithWhereUniqueWithoutPersonInput[]
|
|
updateMany?: GroupMembershipUpdateManyWithWhereWithoutPersonInput | GroupMembershipUpdateManyWithWhereWithoutPersonInput[]
|
|
deleteMany?: GroupMembershipScalarWhereInput | GroupMembershipScalarWhereInput[]
|
|
}
|
|
|
|
export type GroupMembershipCreateNestedManyWithoutGroupInput = {
|
|
create?: XOR<GroupMembershipCreateWithoutGroupInput, GroupMembershipUncheckedCreateWithoutGroupInput> | GroupMembershipCreateWithoutGroupInput[] | GroupMembershipUncheckedCreateWithoutGroupInput[]
|
|
connectOrCreate?: GroupMembershipCreateOrConnectWithoutGroupInput | GroupMembershipCreateOrConnectWithoutGroupInput[]
|
|
createMany?: GroupMembershipCreateManyGroupInputEnvelope
|
|
connect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
}
|
|
|
|
export type GroupMembershipUncheckedCreateNestedManyWithoutGroupInput = {
|
|
create?: XOR<GroupMembershipCreateWithoutGroupInput, GroupMembershipUncheckedCreateWithoutGroupInput> | GroupMembershipCreateWithoutGroupInput[] | GroupMembershipUncheckedCreateWithoutGroupInput[]
|
|
connectOrCreate?: GroupMembershipCreateOrConnectWithoutGroupInput | GroupMembershipCreateOrConnectWithoutGroupInput[]
|
|
createMany?: GroupMembershipCreateManyGroupInputEnvelope
|
|
connect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
}
|
|
|
|
export type GroupMembershipUpdateManyWithoutGroupNestedInput = {
|
|
create?: XOR<GroupMembershipCreateWithoutGroupInput, GroupMembershipUncheckedCreateWithoutGroupInput> | GroupMembershipCreateWithoutGroupInput[] | GroupMembershipUncheckedCreateWithoutGroupInput[]
|
|
connectOrCreate?: GroupMembershipCreateOrConnectWithoutGroupInput | GroupMembershipCreateOrConnectWithoutGroupInput[]
|
|
upsert?: GroupMembershipUpsertWithWhereUniqueWithoutGroupInput | GroupMembershipUpsertWithWhereUniqueWithoutGroupInput[]
|
|
createMany?: GroupMembershipCreateManyGroupInputEnvelope
|
|
set?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
disconnect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
delete?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
connect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
update?: GroupMembershipUpdateWithWhereUniqueWithoutGroupInput | GroupMembershipUpdateWithWhereUniqueWithoutGroupInput[]
|
|
updateMany?: GroupMembershipUpdateManyWithWhereWithoutGroupInput | GroupMembershipUpdateManyWithWhereWithoutGroupInput[]
|
|
deleteMany?: GroupMembershipScalarWhereInput | GroupMembershipScalarWhereInput[]
|
|
}
|
|
|
|
export type GroupMembershipUncheckedUpdateManyWithoutGroupNestedInput = {
|
|
create?: XOR<GroupMembershipCreateWithoutGroupInput, GroupMembershipUncheckedCreateWithoutGroupInput> | GroupMembershipCreateWithoutGroupInput[] | GroupMembershipUncheckedCreateWithoutGroupInput[]
|
|
connectOrCreate?: GroupMembershipCreateOrConnectWithoutGroupInput | GroupMembershipCreateOrConnectWithoutGroupInput[]
|
|
upsert?: GroupMembershipUpsertWithWhereUniqueWithoutGroupInput | GroupMembershipUpsertWithWhereUniqueWithoutGroupInput[]
|
|
createMany?: GroupMembershipCreateManyGroupInputEnvelope
|
|
set?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
disconnect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
delete?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
connect?: GroupMembershipWhereUniqueInput | GroupMembershipWhereUniqueInput[]
|
|
update?: GroupMembershipUpdateWithWhereUniqueWithoutGroupInput | GroupMembershipUpdateWithWhereUniqueWithoutGroupInput[]
|
|
updateMany?: GroupMembershipUpdateManyWithWhereWithoutGroupInput | GroupMembershipUpdateManyWithWhereWithoutGroupInput[]
|
|
deleteMany?: GroupMembershipScalarWhereInput | GroupMembershipScalarWhereInput[]
|
|
}
|
|
|
|
export type GroupCreateNestedOneWithoutMembersInput = {
|
|
create?: XOR<GroupCreateWithoutMembersInput, GroupUncheckedCreateWithoutMembersInput>
|
|
connectOrCreate?: GroupCreateOrConnectWithoutMembersInput
|
|
connect?: GroupWhereUniqueInput
|
|
}
|
|
|
|
export type PersonCreateNestedOneWithoutGroupMembershipsInput = {
|
|
create?: XOR<PersonCreateWithoutGroupMembershipsInput, PersonUncheckedCreateWithoutGroupMembershipsInput>
|
|
connectOrCreate?: PersonCreateOrConnectWithoutGroupMembershipsInput
|
|
connect?: PersonWhereUniqueInput
|
|
}
|
|
|
|
export type GroupUpdateOneRequiredWithoutMembersNestedInput = {
|
|
create?: XOR<GroupCreateWithoutMembersInput, GroupUncheckedCreateWithoutMembersInput>
|
|
connectOrCreate?: GroupCreateOrConnectWithoutMembersInput
|
|
upsert?: GroupUpsertWithoutMembersInput
|
|
connect?: GroupWhereUniqueInput
|
|
update?: XOR<XOR<GroupUpdateToOneWithWhereWithoutMembersInput, GroupUpdateWithoutMembersInput>, GroupUncheckedUpdateWithoutMembersInput>
|
|
}
|
|
|
|
export type PersonUpdateOneRequiredWithoutGroupMembershipsNestedInput = {
|
|
create?: XOR<PersonCreateWithoutGroupMembershipsInput, PersonUncheckedCreateWithoutGroupMembershipsInput>
|
|
connectOrCreate?: PersonCreateOrConnectWithoutGroupMembershipsInput
|
|
upsert?: PersonUpsertWithoutGroupMembershipsInput
|
|
connect?: PersonWhereUniqueInput
|
|
update?: XOR<XOR<PersonUpdateToOneWithWhereWithoutGroupMembershipsInput, PersonUpdateWithoutGroupMembershipsInput>, PersonUncheckedUpdateWithoutGroupMembershipsInput>
|
|
}
|
|
|
|
export type NullableDateTimeFieldUpdateOperationsInput = {
|
|
set?: Date | string | null
|
|
}
|
|
|
|
export type countriesCreateNestedOneWithoutCitiesInput = {
|
|
create?: XOR<countriesCreateWithoutCitiesInput, countriesUncheckedCreateWithoutCitiesInput>
|
|
connectOrCreate?: countriesCreateOrConnectWithoutCitiesInput
|
|
connect?: countriesWhereUniqueInput
|
|
}
|
|
|
|
export type statesCreateNestedOneWithoutCitiesInput = {
|
|
create?: XOR<statesCreateWithoutCitiesInput, statesUncheckedCreateWithoutCitiesInput>
|
|
connectOrCreate?: statesCreateOrConnectWithoutCitiesInput
|
|
connect?: statesWhereUniqueInput
|
|
}
|
|
|
|
export type BigIntFieldUpdateOperationsInput = {
|
|
set?: bigint | number
|
|
increment?: bigint | number
|
|
decrement?: bigint | number
|
|
multiply?: bigint | number
|
|
divide?: bigint | number
|
|
}
|
|
|
|
export type NullableIntFieldUpdateOperationsInput = {
|
|
set?: number | null
|
|
increment?: number
|
|
decrement?: number
|
|
multiply?: number
|
|
divide?: number
|
|
}
|
|
|
|
export type NullableBigIntFieldUpdateOperationsInput = {
|
|
set?: bigint | number | null
|
|
increment?: bigint | number
|
|
decrement?: bigint | number
|
|
multiply?: bigint | number
|
|
divide?: bigint | number
|
|
}
|
|
|
|
export type DecimalFieldUpdateOperationsInput = {
|
|
set?: Decimal | DecimalJsLike | number | string
|
|
increment?: Decimal | DecimalJsLike | number | string
|
|
decrement?: Decimal | DecimalJsLike | number | string
|
|
multiply?: Decimal | DecimalJsLike | number | string
|
|
divide?: Decimal | DecimalJsLike | number | string
|
|
}
|
|
|
|
export type IntFieldUpdateOperationsInput = {
|
|
set?: number
|
|
increment?: number
|
|
decrement?: number
|
|
multiply?: number
|
|
divide?: number
|
|
}
|
|
|
|
export type countriesUpdateOneRequiredWithoutCitiesNestedInput = {
|
|
create?: XOR<countriesCreateWithoutCitiesInput, countriesUncheckedCreateWithoutCitiesInput>
|
|
connectOrCreate?: countriesCreateOrConnectWithoutCitiesInput
|
|
upsert?: countriesUpsertWithoutCitiesInput
|
|
connect?: countriesWhereUniqueInput
|
|
update?: XOR<XOR<countriesUpdateToOneWithWhereWithoutCitiesInput, countriesUpdateWithoutCitiesInput>, countriesUncheckedUpdateWithoutCitiesInput>
|
|
}
|
|
|
|
export type statesUpdateOneRequiredWithoutCitiesNestedInput = {
|
|
create?: XOR<statesCreateWithoutCitiesInput, statesUncheckedCreateWithoutCitiesInput>
|
|
connectOrCreate?: statesCreateOrConnectWithoutCitiesInput
|
|
upsert?: statesUpsertWithoutCitiesInput
|
|
connect?: statesWhereUniqueInput
|
|
update?: XOR<XOR<statesUpdateToOneWithWhereWithoutCitiesInput, statesUpdateWithoutCitiesInput>, statesUncheckedUpdateWithoutCitiesInput>
|
|
}
|
|
|
|
export type citiesCreateNestedManyWithoutCountriesInput = {
|
|
create?: XOR<citiesCreateWithoutCountriesInput, citiesUncheckedCreateWithoutCountriesInput> | citiesCreateWithoutCountriesInput[] | citiesUncheckedCreateWithoutCountriesInput[]
|
|
connectOrCreate?: citiesCreateOrConnectWithoutCountriesInput | citiesCreateOrConnectWithoutCountriesInput[]
|
|
createMany?: citiesCreateManyCountriesInputEnvelope
|
|
connect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
}
|
|
|
|
export type statesCreateNestedManyWithoutCountriesInput = {
|
|
create?: XOR<statesCreateWithoutCountriesInput, statesUncheckedCreateWithoutCountriesInput> | statesCreateWithoutCountriesInput[] | statesUncheckedCreateWithoutCountriesInput[]
|
|
connectOrCreate?: statesCreateOrConnectWithoutCountriesInput | statesCreateOrConnectWithoutCountriesInput[]
|
|
createMany?: statesCreateManyCountriesInputEnvelope
|
|
connect?: statesWhereUniqueInput | statesWhereUniqueInput[]
|
|
}
|
|
|
|
export type citiesUncheckedCreateNestedManyWithoutCountriesInput = {
|
|
create?: XOR<citiesCreateWithoutCountriesInput, citiesUncheckedCreateWithoutCountriesInput> | citiesCreateWithoutCountriesInput[] | citiesUncheckedCreateWithoutCountriesInput[]
|
|
connectOrCreate?: citiesCreateOrConnectWithoutCountriesInput | citiesCreateOrConnectWithoutCountriesInput[]
|
|
createMany?: citiesCreateManyCountriesInputEnvelope
|
|
connect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
}
|
|
|
|
export type statesUncheckedCreateNestedManyWithoutCountriesInput = {
|
|
create?: XOR<statesCreateWithoutCountriesInput, statesUncheckedCreateWithoutCountriesInput> | statesCreateWithoutCountriesInput[] | statesUncheckedCreateWithoutCountriesInput[]
|
|
connectOrCreate?: statesCreateOrConnectWithoutCountriesInput | statesCreateOrConnectWithoutCountriesInput[]
|
|
createMany?: statesCreateManyCountriesInputEnvelope
|
|
connect?: statesWhereUniqueInput | statesWhereUniqueInput[]
|
|
}
|
|
|
|
export type NullableFloatFieldUpdateOperationsInput = {
|
|
set?: number | null
|
|
increment?: number
|
|
decrement?: number
|
|
multiply?: number
|
|
divide?: number
|
|
}
|
|
|
|
export type NullableDecimalFieldUpdateOperationsInput = {
|
|
set?: Decimal | DecimalJsLike | number | string | null
|
|
increment?: Decimal | DecimalJsLike | number | string
|
|
decrement?: Decimal | DecimalJsLike | number | string
|
|
multiply?: Decimal | DecimalJsLike | number | string
|
|
divide?: Decimal | DecimalJsLike | number | string
|
|
}
|
|
|
|
export type citiesUpdateManyWithoutCountriesNestedInput = {
|
|
create?: XOR<citiesCreateWithoutCountriesInput, citiesUncheckedCreateWithoutCountriesInput> | citiesCreateWithoutCountriesInput[] | citiesUncheckedCreateWithoutCountriesInput[]
|
|
connectOrCreate?: citiesCreateOrConnectWithoutCountriesInput | citiesCreateOrConnectWithoutCountriesInput[]
|
|
upsert?: citiesUpsertWithWhereUniqueWithoutCountriesInput | citiesUpsertWithWhereUniqueWithoutCountriesInput[]
|
|
createMany?: citiesCreateManyCountriesInputEnvelope
|
|
set?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
disconnect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
delete?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
connect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
update?: citiesUpdateWithWhereUniqueWithoutCountriesInput | citiesUpdateWithWhereUniqueWithoutCountriesInput[]
|
|
updateMany?: citiesUpdateManyWithWhereWithoutCountriesInput | citiesUpdateManyWithWhereWithoutCountriesInput[]
|
|
deleteMany?: citiesScalarWhereInput | citiesScalarWhereInput[]
|
|
}
|
|
|
|
export type statesUpdateManyWithoutCountriesNestedInput = {
|
|
create?: XOR<statesCreateWithoutCountriesInput, statesUncheckedCreateWithoutCountriesInput> | statesCreateWithoutCountriesInput[] | statesUncheckedCreateWithoutCountriesInput[]
|
|
connectOrCreate?: statesCreateOrConnectWithoutCountriesInput | statesCreateOrConnectWithoutCountriesInput[]
|
|
upsert?: statesUpsertWithWhereUniqueWithoutCountriesInput | statesUpsertWithWhereUniqueWithoutCountriesInput[]
|
|
createMany?: statesCreateManyCountriesInputEnvelope
|
|
set?: statesWhereUniqueInput | statesWhereUniqueInput[]
|
|
disconnect?: statesWhereUniqueInput | statesWhereUniqueInput[]
|
|
delete?: statesWhereUniqueInput | statesWhereUniqueInput[]
|
|
connect?: statesWhereUniqueInput | statesWhereUniqueInput[]
|
|
update?: statesUpdateWithWhereUniqueWithoutCountriesInput | statesUpdateWithWhereUniqueWithoutCountriesInput[]
|
|
updateMany?: statesUpdateManyWithWhereWithoutCountriesInput | statesUpdateManyWithWhereWithoutCountriesInput[]
|
|
deleteMany?: statesScalarWhereInput | statesScalarWhereInput[]
|
|
}
|
|
|
|
export type citiesUncheckedUpdateManyWithoutCountriesNestedInput = {
|
|
create?: XOR<citiesCreateWithoutCountriesInput, citiesUncheckedCreateWithoutCountriesInput> | citiesCreateWithoutCountriesInput[] | citiesUncheckedCreateWithoutCountriesInput[]
|
|
connectOrCreate?: citiesCreateOrConnectWithoutCountriesInput | citiesCreateOrConnectWithoutCountriesInput[]
|
|
upsert?: citiesUpsertWithWhereUniqueWithoutCountriesInput | citiesUpsertWithWhereUniqueWithoutCountriesInput[]
|
|
createMany?: citiesCreateManyCountriesInputEnvelope
|
|
set?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
disconnect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
delete?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
connect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
update?: citiesUpdateWithWhereUniqueWithoutCountriesInput | citiesUpdateWithWhereUniqueWithoutCountriesInput[]
|
|
updateMany?: citiesUpdateManyWithWhereWithoutCountriesInput | citiesUpdateManyWithWhereWithoutCountriesInput[]
|
|
deleteMany?: citiesScalarWhereInput | citiesScalarWhereInput[]
|
|
}
|
|
|
|
export type statesUncheckedUpdateManyWithoutCountriesNestedInput = {
|
|
create?: XOR<statesCreateWithoutCountriesInput, statesUncheckedCreateWithoutCountriesInput> | statesCreateWithoutCountriesInput[] | statesUncheckedCreateWithoutCountriesInput[]
|
|
connectOrCreate?: statesCreateOrConnectWithoutCountriesInput | statesCreateOrConnectWithoutCountriesInput[]
|
|
upsert?: statesUpsertWithWhereUniqueWithoutCountriesInput | statesUpsertWithWhereUniqueWithoutCountriesInput[]
|
|
createMany?: statesCreateManyCountriesInputEnvelope
|
|
set?: statesWhereUniqueInput | statesWhereUniqueInput[]
|
|
disconnect?: statesWhereUniqueInput | statesWhereUniqueInput[]
|
|
delete?: statesWhereUniqueInput | statesWhereUniqueInput[]
|
|
connect?: statesWhereUniqueInput | statesWhereUniqueInput[]
|
|
update?: statesUpdateWithWhereUniqueWithoutCountriesInput | statesUpdateWithWhereUniqueWithoutCountriesInput[]
|
|
updateMany?: statesUpdateManyWithWhereWithoutCountriesInput | statesUpdateManyWithWhereWithoutCountriesInput[]
|
|
deleteMany?: statesScalarWhereInput | statesScalarWhereInput[]
|
|
}
|
|
|
|
export type citiesCreateNestedManyWithoutStatesInput = {
|
|
create?: XOR<citiesCreateWithoutStatesInput, citiesUncheckedCreateWithoutStatesInput> | citiesCreateWithoutStatesInput[] | citiesUncheckedCreateWithoutStatesInput[]
|
|
connectOrCreate?: citiesCreateOrConnectWithoutStatesInput | citiesCreateOrConnectWithoutStatesInput[]
|
|
createMany?: citiesCreateManyStatesInputEnvelope
|
|
connect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
}
|
|
|
|
export type countriesCreateNestedOneWithoutStatesInput = {
|
|
create?: XOR<countriesCreateWithoutStatesInput, countriesUncheckedCreateWithoutStatesInput>
|
|
connectOrCreate?: countriesCreateOrConnectWithoutStatesInput
|
|
connect?: countriesWhereUniqueInput
|
|
}
|
|
|
|
export type citiesUncheckedCreateNestedManyWithoutStatesInput = {
|
|
create?: XOR<citiesCreateWithoutStatesInput, citiesUncheckedCreateWithoutStatesInput> | citiesCreateWithoutStatesInput[] | citiesUncheckedCreateWithoutStatesInput[]
|
|
connectOrCreate?: citiesCreateOrConnectWithoutStatesInput | citiesCreateOrConnectWithoutStatesInput[]
|
|
createMany?: citiesCreateManyStatesInputEnvelope
|
|
connect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
}
|
|
|
|
export type citiesUpdateManyWithoutStatesNestedInput = {
|
|
create?: XOR<citiesCreateWithoutStatesInput, citiesUncheckedCreateWithoutStatesInput> | citiesCreateWithoutStatesInput[] | citiesUncheckedCreateWithoutStatesInput[]
|
|
connectOrCreate?: citiesCreateOrConnectWithoutStatesInput | citiesCreateOrConnectWithoutStatesInput[]
|
|
upsert?: citiesUpsertWithWhereUniqueWithoutStatesInput | citiesUpsertWithWhereUniqueWithoutStatesInput[]
|
|
createMany?: citiesCreateManyStatesInputEnvelope
|
|
set?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
disconnect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
delete?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
connect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
update?: citiesUpdateWithWhereUniqueWithoutStatesInput | citiesUpdateWithWhereUniqueWithoutStatesInput[]
|
|
updateMany?: citiesUpdateManyWithWhereWithoutStatesInput | citiesUpdateManyWithWhereWithoutStatesInput[]
|
|
deleteMany?: citiesScalarWhereInput | citiesScalarWhereInput[]
|
|
}
|
|
|
|
export type countriesUpdateOneRequiredWithoutStatesNestedInput = {
|
|
create?: XOR<countriesCreateWithoutStatesInput, countriesUncheckedCreateWithoutStatesInput>
|
|
connectOrCreate?: countriesCreateOrConnectWithoutStatesInput
|
|
upsert?: countriesUpsertWithoutStatesInput
|
|
connect?: countriesWhereUniqueInput
|
|
update?: XOR<XOR<countriesUpdateToOneWithWhereWithoutStatesInput, countriesUpdateWithoutStatesInput>, countriesUncheckedUpdateWithoutStatesInput>
|
|
}
|
|
|
|
export type citiesUncheckedUpdateManyWithoutStatesNestedInput = {
|
|
create?: XOR<citiesCreateWithoutStatesInput, citiesUncheckedCreateWithoutStatesInput> | citiesCreateWithoutStatesInput[] | citiesUncheckedCreateWithoutStatesInput[]
|
|
connectOrCreate?: citiesCreateOrConnectWithoutStatesInput | citiesCreateOrConnectWithoutStatesInput[]
|
|
upsert?: citiesUpsertWithWhereUniqueWithoutStatesInput | citiesUpsertWithWhereUniqueWithoutStatesInput[]
|
|
createMany?: citiesCreateManyStatesInputEnvelope
|
|
set?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
disconnect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
delete?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
connect?: citiesWhereUniqueInput | citiesWhereUniqueInput[]
|
|
update?: citiesUpdateWithWhereUniqueWithoutStatesInput | citiesUpdateWithWhereUniqueWithoutStatesInput[]
|
|
updateMany?: citiesUpdateManyWithWhereWithoutStatesInput | citiesUpdateManyWithWhereWithoutStatesInput[]
|
|
deleteMany?: citiesScalarWhereInput | citiesScalarWhereInput[]
|
|
}
|
|
|
|
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 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 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 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 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 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 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 NestedDateTimeNullableFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
|
|
}
|
|
|
|
export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
|
|
in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
|
|
lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
|
|
not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedDateTimeNullableFilter<$PrismaModel>
|
|
_max?: NestedDateTimeNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedBigIntFilter<$PrismaModel = never> = {
|
|
equals?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
|
|
notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
|
|
lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
not?: NestedBigIntFilter<$PrismaModel> | bigint | number
|
|
}
|
|
|
|
export type NestedBigIntNullableFilter<$PrismaModel = never> = {
|
|
equals?: bigint | number | BigIntFieldRefInput<$PrismaModel> | null
|
|
in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel> | null
|
|
notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel> | null
|
|
lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
not?: NestedBigIntNullableFilter<$PrismaModel> | bigint | number | null
|
|
}
|
|
|
|
export type NestedDecimalFilter<$PrismaModel = never> = {
|
|
equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
|
|
notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
|
|
lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
not?: NestedDecimalFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
|
|
}
|
|
|
|
export type NestedBigIntWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
|
|
notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel>
|
|
lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
not?: NestedBigIntWithAggregatesFilter<$PrismaModel> | bigint | number
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_avg?: NestedFloatFilter<$PrismaModel>
|
|
_sum?: NestedBigIntFilter<$PrismaModel>
|
|
_min?: NestedBigIntFilter<$PrismaModel>
|
|
_max?: NestedBigIntFilter<$PrismaModel>
|
|
}
|
|
|
|
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 NestedIntNullableWithAggregatesFilter<$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?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_avg?: NestedFloatNullableFilter<$PrismaModel>
|
|
_sum?: NestedIntNullableFilter<$PrismaModel>
|
|
_min?: NestedIntNullableFilter<$PrismaModel>
|
|
_max?: NestedIntNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedFloatNullableFilter<$PrismaModel = never> = {
|
|
equals?: number | FloatFieldRefInput<$PrismaModel> | null
|
|
in?: number[] | 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 NestedBigIntNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: bigint | number | BigIntFieldRefInput<$PrismaModel> | null
|
|
in?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel> | null
|
|
notIn?: bigint[] | number[] | ListBigIntFieldRefInput<$PrismaModel> | null
|
|
lt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
lte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gt?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
gte?: bigint | number | BigIntFieldRefInput<$PrismaModel>
|
|
not?: NestedBigIntNullableWithAggregatesFilter<$PrismaModel> | bigint | number | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_avg?: NestedFloatNullableFilter<$PrismaModel>
|
|
_sum?: NestedBigIntNullableFilter<$PrismaModel>
|
|
_min?: NestedBigIntNullableFilter<$PrismaModel>
|
|
_max?: NestedBigIntNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type NestedDecimalWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
|
|
notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
|
|
lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
not?: NestedDecimalWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
|
|
_count?: NestedIntFilter<$PrismaModel>
|
|
_avg?: NestedDecimalFilter<$PrismaModel>
|
|
_sum?: NestedDecimalFilter<$PrismaModel>
|
|
_min?: NestedDecimalFilter<$PrismaModel>
|
|
_max?: NestedDecimalFilter<$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 NestedDecimalNullableFilter<$PrismaModel = never> = {
|
|
equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
|
|
in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
|
|
notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
|
|
lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
not?: NestedDecimalNullableFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | 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 NestedDecimalNullableWithAggregatesFilter<$PrismaModel = never> = {
|
|
equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
|
|
in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
|
|
notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
|
|
lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
|
|
not?: NestedDecimalNullableWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
|
|
_count?: NestedIntNullableFilter<$PrismaModel>
|
|
_avg?: NestedDecimalNullableFilter<$PrismaModel>
|
|
_sum?: NestedDecimalNullableFilter<$PrismaModel>
|
|
_min?: NestedDecimalNullableFilter<$PrismaModel>
|
|
_max?: NestedDecimalNullableFilter<$PrismaModel>
|
|
}
|
|
|
|
export type UnitCreateWithoutChildrenInput = {
|
|
id?: string
|
|
name: string
|
|
description?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
parent?: UnitCreateNestedOneWithoutChildrenInput
|
|
}
|
|
|
|
export type UnitUncheckedCreateWithoutChildrenInput = {
|
|
id?: string
|
|
name: string
|
|
description?: string | null
|
|
parentId?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type UnitCreateOrConnectWithoutChildrenInput = {
|
|
where: UnitWhereUniqueInput
|
|
create: XOR<UnitCreateWithoutChildrenInput, UnitUncheckedCreateWithoutChildrenInput>
|
|
}
|
|
|
|
export type UnitCreateWithoutParentInput = {
|
|
id?: string
|
|
name: string
|
|
description?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
children?: UnitCreateNestedManyWithoutParentInput
|
|
}
|
|
|
|
export type UnitUncheckedCreateWithoutParentInput = {
|
|
id?: string
|
|
name: string
|
|
description?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
children?: UnitUncheckedCreateNestedManyWithoutParentInput
|
|
}
|
|
|
|
export type UnitCreateOrConnectWithoutParentInput = {
|
|
where: UnitWhereUniqueInput
|
|
create: XOR<UnitCreateWithoutParentInput, UnitUncheckedCreateWithoutParentInput>
|
|
}
|
|
|
|
export type UnitCreateManyParentInputEnvelope = {
|
|
data: UnitCreateManyParentInput | UnitCreateManyParentInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type UnitUpsertWithoutChildrenInput = {
|
|
update: XOR<UnitUpdateWithoutChildrenInput, UnitUncheckedUpdateWithoutChildrenInput>
|
|
create: XOR<UnitCreateWithoutChildrenInput, UnitUncheckedCreateWithoutChildrenInput>
|
|
where?: UnitWhereInput
|
|
}
|
|
|
|
export type UnitUpdateToOneWithWhereWithoutChildrenInput = {
|
|
where?: UnitWhereInput
|
|
data: XOR<UnitUpdateWithoutChildrenInput, UnitUncheckedUpdateWithoutChildrenInput>
|
|
}
|
|
|
|
export type UnitUpdateWithoutChildrenInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
parent?: UnitUpdateOneWithoutChildrenNestedInput
|
|
}
|
|
|
|
export type UnitUncheckedUpdateWithoutChildrenInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
parentId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type UnitUpsertWithWhereUniqueWithoutParentInput = {
|
|
where: UnitWhereUniqueInput
|
|
update: XOR<UnitUpdateWithoutParentInput, UnitUncheckedUpdateWithoutParentInput>
|
|
create: XOR<UnitCreateWithoutParentInput, UnitUncheckedCreateWithoutParentInput>
|
|
}
|
|
|
|
export type UnitUpdateWithWhereUniqueWithoutParentInput = {
|
|
where: UnitWhereUniqueInput
|
|
data: XOR<UnitUpdateWithoutParentInput, UnitUncheckedUpdateWithoutParentInput>
|
|
}
|
|
|
|
export type UnitUpdateManyWithWhereWithoutParentInput = {
|
|
where: UnitScalarWhereInput
|
|
data: XOR<UnitUpdateManyMutationInput, UnitUncheckedUpdateManyWithoutParentInput>
|
|
}
|
|
|
|
export type UnitScalarWhereInput = {
|
|
AND?: UnitScalarWhereInput | UnitScalarWhereInput[]
|
|
OR?: UnitScalarWhereInput[]
|
|
NOT?: UnitScalarWhereInput | UnitScalarWhereInput[]
|
|
id?: StringFilter<"Unit"> | string
|
|
name?: StringFilter<"Unit"> | string
|
|
description?: StringNullableFilter<"Unit"> | string | null
|
|
parentId?: StringNullableFilter<"Unit"> | string | null
|
|
traits?: JsonFilter<"Unit">
|
|
createdAt?: DateTimeFilter<"Unit"> | Date | string
|
|
updatedAt?: DateTimeFilter<"Unit"> | Date | string
|
|
}
|
|
|
|
export type GroupMembershipCreateWithoutPersonInput = {
|
|
id?: string
|
|
role: string
|
|
group: GroupCreateNestedOneWithoutMembersInput
|
|
}
|
|
|
|
export type GroupMembershipUncheckedCreateWithoutPersonInput = {
|
|
id?: string
|
|
groupId: string
|
|
role: string
|
|
}
|
|
|
|
export type GroupMembershipCreateOrConnectWithoutPersonInput = {
|
|
where: GroupMembershipWhereUniqueInput
|
|
create: XOR<GroupMembershipCreateWithoutPersonInput, GroupMembershipUncheckedCreateWithoutPersonInput>
|
|
}
|
|
|
|
export type GroupMembershipCreateManyPersonInputEnvelope = {
|
|
data: GroupMembershipCreateManyPersonInput | GroupMembershipCreateManyPersonInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type GroupMembershipUpsertWithWhereUniqueWithoutPersonInput = {
|
|
where: GroupMembershipWhereUniqueInput
|
|
update: XOR<GroupMembershipUpdateWithoutPersonInput, GroupMembershipUncheckedUpdateWithoutPersonInput>
|
|
create: XOR<GroupMembershipCreateWithoutPersonInput, GroupMembershipUncheckedCreateWithoutPersonInput>
|
|
}
|
|
|
|
export type GroupMembershipUpdateWithWhereUniqueWithoutPersonInput = {
|
|
where: GroupMembershipWhereUniqueInput
|
|
data: XOR<GroupMembershipUpdateWithoutPersonInput, GroupMembershipUncheckedUpdateWithoutPersonInput>
|
|
}
|
|
|
|
export type GroupMembershipUpdateManyWithWhereWithoutPersonInput = {
|
|
where: GroupMembershipScalarWhereInput
|
|
data: XOR<GroupMembershipUpdateManyMutationInput, GroupMembershipUncheckedUpdateManyWithoutPersonInput>
|
|
}
|
|
|
|
export type GroupMembershipScalarWhereInput = {
|
|
AND?: GroupMembershipScalarWhereInput | GroupMembershipScalarWhereInput[]
|
|
OR?: GroupMembershipScalarWhereInput[]
|
|
NOT?: GroupMembershipScalarWhereInput | GroupMembershipScalarWhereInput[]
|
|
id?: StringFilter<"GroupMembership"> | string
|
|
personId?: StringFilter<"GroupMembership"> | string
|
|
groupId?: StringFilter<"GroupMembership"> | string
|
|
role?: StringFilter<"GroupMembership"> | string
|
|
}
|
|
|
|
export type GroupMembershipCreateWithoutGroupInput = {
|
|
id?: string
|
|
role: string
|
|
person: PersonCreateNestedOneWithoutGroupMembershipsInput
|
|
}
|
|
|
|
export type GroupMembershipUncheckedCreateWithoutGroupInput = {
|
|
id?: string
|
|
personId: string
|
|
role: string
|
|
}
|
|
|
|
export type GroupMembershipCreateOrConnectWithoutGroupInput = {
|
|
where: GroupMembershipWhereUniqueInput
|
|
create: XOR<GroupMembershipCreateWithoutGroupInput, GroupMembershipUncheckedCreateWithoutGroupInput>
|
|
}
|
|
|
|
export type GroupMembershipCreateManyGroupInputEnvelope = {
|
|
data: GroupMembershipCreateManyGroupInput | GroupMembershipCreateManyGroupInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type GroupMembershipUpsertWithWhereUniqueWithoutGroupInput = {
|
|
where: GroupMembershipWhereUniqueInput
|
|
update: XOR<GroupMembershipUpdateWithoutGroupInput, GroupMembershipUncheckedUpdateWithoutGroupInput>
|
|
create: XOR<GroupMembershipCreateWithoutGroupInput, GroupMembershipUncheckedCreateWithoutGroupInput>
|
|
}
|
|
|
|
export type GroupMembershipUpdateWithWhereUniqueWithoutGroupInput = {
|
|
where: GroupMembershipWhereUniqueInput
|
|
data: XOR<GroupMembershipUpdateWithoutGroupInput, GroupMembershipUncheckedUpdateWithoutGroupInput>
|
|
}
|
|
|
|
export type GroupMembershipUpdateManyWithWhereWithoutGroupInput = {
|
|
where: GroupMembershipScalarWhereInput
|
|
data: XOR<GroupMembershipUpdateManyMutationInput, GroupMembershipUncheckedUpdateManyWithoutGroupInput>
|
|
}
|
|
|
|
export type GroupCreateWithoutMembersInput = {
|
|
id?: string
|
|
name: string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type GroupUncheckedCreateWithoutMembersInput = {
|
|
id?: string
|
|
name: string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type GroupCreateOrConnectWithoutMembersInput = {
|
|
where: GroupWhereUniqueInput
|
|
create: XOR<GroupCreateWithoutMembersInput, GroupUncheckedCreateWithoutMembersInput>
|
|
}
|
|
|
|
export type PersonCreateWithoutGroupMembershipsInput = {
|
|
id?: string
|
|
firstName: string
|
|
lastName: string
|
|
email?: string | null
|
|
phone?: string | null
|
|
ssoId?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type PersonUncheckedCreateWithoutGroupMembershipsInput = {
|
|
id?: string
|
|
firstName: string
|
|
lastName: string
|
|
email?: string | null
|
|
phone?: string | null
|
|
ssoId?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type PersonCreateOrConnectWithoutGroupMembershipsInput = {
|
|
where: PersonWhereUniqueInput
|
|
create: XOR<PersonCreateWithoutGroupMembershipsInput, PersonUncheckedCreateWithoutGroupMembershipsInput>
|
|
}
|
|
|
|
export type GroupUpsertWithoutMembersInput = {
|
|
update: XOR<GroupUpdateWithoutMembersInput, GroupUncheckedUpdateWithoutMembersInput>
|
|
create: XOR<GroupCreateWithoutMembersInput, GroupUncheckedCreateWithoutMembersInput>
|
|
where?: GroupWhereInput
|
|
}
|
|
|
|
export type GroupUpdateToOneWithWhereWithoutMembersInput = {
|
|
where?: GroupWhereInput
|
|
data: XOR<GroupUpdateWithoutMembersInput, GroupUncheckedUpdateWithoutMembersInput>
|
|
}
|
|
|
|
export type GroupUpdateWithoutMembersInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type GroupUncheckedUpdateWithoutMembersInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type PersonUpsertWithoutGroupMembershipsInput = {
|
|
update: XOR<PersonUpdateWithoutGroupMembershipsInput, PersonUncheckedUpdateWithoutGroupMembershipsInput>
|
|
create: XOR<PersonCreateWithoutGroupMembershipsInput, PersonUncheckedCreateWithoutGroupMembershipsInput>
|
|
where?: PersonWhereInput
|
|
}
|
|
|
|
export type PersonUpdateToOneWithWhereWithoutGroupMembershipsInput = {
|
|
where?: PersonWhereInput
|
|
data: XOR<PersonUpdateWithoutGroupMembershipsInput, PersonUncheckedUpdateWithoutGroupMembershipsInput>
|
|
}
|
|
|
|
export type PersonUpdateWithoutGroupMembershipsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
firstName?: StringFieldUpdateOperationsInput | string
|
|
lastName?: StringFieldUpdateOperationsInput | string
|
|
email?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ssoId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type PersonUncheckedUpdateWithoutGroupMembershipsInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
firstName?: StringFieldUpdateOperationsInput | string
|
|
lastName?: StringFieldUpdateOperationsInput | string
|
|
email?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
ssoId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type countriesCreateWithoutCitiesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
iso3?: string | null
|
|
numeric_code?: string | null
|
|
iso2?: string | null
|
|
phonecode?: string | null
|
|
capital?: string | null
|
|
currency?: string | null
|
|
currency_name?: string | null
|
|
currency_symbol?: string | null
|
|
tld?: string | null
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
gdp?: bigint | number | null
|
|
region?: string | null
|
|
region_id?: bigint | number | null
|
|
subregion?: string | null
|
|
subregion_id?: bigint | number | null
|
|
nationality?: string | null
|
|
area_sq_km?: number | null
|
|
postal_code_format?: string | null
|
|
postal_code_regex?: string | null
|
|
timezones?: string | null
|
|
translations?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
emoji?: string | null
|
|
emojiU?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
states?: statesCreateNestedManyWithoutCountriesInput
|
|
}
|
|
|
|
export type countriesUncheckedCreateWithoutCitiesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
iso3?: string | null
|
|
numeric_code?: string | null
|
|
iso2?: string | null
|
|
phonecode?: string | null
|
|
capital?: string | null
|
|
currency?: string | null
|
|
currency_name?: string | null
|
|
currency_symbol?: string | null
|
|
tld?: string | null
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
gdp?: bigint | number | null
|
|
region?: string | null
|
|
region_id?: bigint | number | null
|
|
subregion?: string | null
|
|
subregion_id?: bigint | number | null
|
|
nationality?: string | null
|
|
area_sq_km?: number | null
|
|
postal_code_format?: string | null
|
|
postal_code_regex?: string | null
|
|
timezones?: string | null
|
|
translations?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
emoji?: string | null
|
|
emojiU?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
states?: statesUncheckedCreateNestedManyWithoutCountriesInput
|
|
}
|
|
|
|
export type countriesCreateOrConnectWithoutCitiesInput = {
|
|
where: countriesWhereUniqueInput
|
|
create: XOR<countriesCreateWithoutCitiesInput, countriesUncheckedCreateWithoutCitiesInput>
|
|
}
|
|
|
|
export type statesCreateWithoutCitiesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
country_code: string
|
|
fips_code?: string | null
|
|
iso2?: string | null
|
|
iso3166_2?: string | null
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
native?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
population?: string | null
|
|
countries: countriesCreateNestedOneWithoutStatesInput
|
|
}
|
|
|
|
export type statesUncheckedCreateWithoutCitiesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
country_id: bigint | number
|
|
country_code: string
|
|
fips_code?: string | null
|
|
iso2?: string | null
|
|
iso3166_2?: string | null
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
native?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
population?: string | null
|
|
}
|
|
|
|
export type statesCreateOrConnectWithoutCitiesInput = {
|
|
where: statesWhereUniqueInput
|
|
create: XOR<statesCreateWithoutCitiesInput, statesUncheckedCreateWithoutCitiesInput>
|
|
}
|
|
|
|
export type countriesUpsertWithoutCitiesInput = {
|
|
update: XOR<countriesUpdateWithoutCitiesInput, countriesUncheckedUpdateWithoutCitiesInput>
|
|
create: XOR<countriesCreateWithoutCitiesInput, countriesUncheckedCreateWithoutCitiesInput>
|
|
where?: countriesWhereInput
|
|
}
|
|
|
|
export type countriesUpdateToOneWithWhereWithoutCitiesInput = {
|
|
where?: countriesWhereInput
|
|
data: XOR<countriesUpdateWithoutCitiesInput, countriesUncheckedUpdateWithoutCitiesInput>
|
|
}
|
|
|
|
export type countriesUpdateWithoutCitiesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
iso3?: NullableStringFieldUpdateOperationsInput | string | null
|
|
numeric_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phonecode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
capital?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_symbol?: NullableStringFieldUpdateOperationsInput | string | null
|
|
tld?: NullableStringFieldUpdateOperationsInput | string | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
gdp?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
region?: NullableStringFieldUpdateOperationsInput | string | null
|
|
region_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
subregion?: NullableStringFieldUpdateOperationsInput | string | null
|
|
subregion_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
nationality?: NullableStringFieldUpdateOperationsInput | string | null
|
|
area_sq_km?: NullableFloatFieldUpdateOperationsInput | number | null
|
|
postal_code_format?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postal_code_regex?: NullableStringFieldUpdateOperationsInput | string | null
|
|
timezones?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emojiU?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
states?: statesUpdateManyWithoutCountriesNestedInput
|
|
}
|
|
|
|
export type countriesUncheckedUpdateWithoutCitiesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
iso3?: NullableStringFieldUpdateOperationsInput | string | null
|
|
numeric_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phonecode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
capital?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_symbol?: NullableStringFieldUpdateOperationsInput | string | null
|
|
tld?: NullableStringFieldUpdateOperationsInput | string | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
gdp?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
region?: NullableStringFieldUpdateOperationsInput | string | null
|
|
region_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
subregion?: NullableStringFieldUpdateOperationsInput | string | null
|
|
subregion_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
nationality?: NullableStringFieldUpdateOperationsInput | string | null
|
|
area_sq_km?: NullableFloatFieldUpdateOperationsInput | number | null
|
|
postal_code_format?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postal_code_regex?: NullableStringFieldUpdateOperationsInput | string | null
|
|
timezones?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emojiU?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
states?: statesUncheckedUpdateManyWithoutCountriesNestedInput
|
|
}
|
|
|
|
export type statesUpsertWithoutCitiesInput = {
|
|
update: XOR<statesUpdateWithoutCitiesInput, statesUncheckedUpdateWithoutCitiesInput>
|
|
create: XOR<statesCreateWithoutCitiesInput, statesUncheckedCreateWithoutCitiesInput>
|
|
where?: statesWhereInput
|
|
}
|
|
|
|
export type statesUpdateToOneWithWhereWithoutCitiesInput = {
|
|
where?: statesWhereInput
|
|
data: XOR<statesUpdateWithoutCitiesInput, statesUncheckedUpdateWithoutCitiesInput>
|
|
}
|
|
|
|
export type statesUpdateWithoutCitiesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
fips_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso3166_2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableStringFieldUpdateOperationsInput | string | null
|
|
countries?: countriesUpdateOneRequiredWithoutStatesNestedInput
|
|
}
|
|
|
|
export type statesUncheckedUpdateWithoutCitiesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
country_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
fips_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso3166_2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type citiesCreateWithoutCountriesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
state_code: string
|
|
country_code: string
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
latitude: Decimal | DecimalJsLike | number | string
|
|
longitude: Decimal | DecimalJsLike | number | string
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
states: statesCreateNestedOneWithoutCitiesInput
|
|
}
|
|
|
|
export type citiesUncheckedCreateWithoutCountriesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
state_id: bigint | number
|
|
state_code: string
|
|
country_code: string
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
latitude: Decimal | DecimalJsLike | number | string
|
|
longitude: Decimal | DecimalJsLike | number | string
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
}
|
|
|
|
export type citiesCreateOrConnectWithoutCountriesInput = {
|
|
where: citiesWhereUniqueInput
|
|
create: XOR<citiesCreateWithoutCountriesInput, citiesUncheckedCreateWithoutCountriesInput>
|
|
}
|
|
|
|
export type citiesCreateManyCountriesInputEnvelope = {
|
|
data: citiesCreateManyCountriesInput | citiesCreateManyCountriesInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type statesCreateWithoutCountriesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
country_code: string
|
|
fips_code?: string | null
|
|
iso2?: string | null
|
|
iso3166_2?: string | null
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
native?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
population?: string | null
|
|
cities?: citiesCreateNestedManyWithoutStatesInput
|
|
}
|
|
|
|
export type statesUncheckedCreateWithoutCountriesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
country_code: string
|
|
fips_code?: string | null
|
|
iso2?: string | null
|
|
iso3166_2?: string | null
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
native?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
population?: string | null
|
|
cities?: citiesUncheckedCreateNestedManyWithoutStatesInput
|
|
}
|
|
|
|
export type statesCreateOrConnectWithoutCountriesInput = {
|
|
where: statesWhereUniqueInput
|
|
create: XOR<statesCreateWithoutCountriesInput, statesUncheckedCreateWithoutCountriesInput>
|
|
}
|
|
|
|
export type statesCreateManyCountriesInputEnvelope = {
|
|
data: statesCreateManyCountriesInput | statesCreateManyCountriesInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type citiesUpsertWithWhereUniqueWithoutCountriesInput = {
|
|
where: citiesWhereUniqueInput
|
|
update: XOR<citiesUpdateWithoutCountriesInput, citiesUncheckedUpdateWithoutCountriesInput>
|
|
create: XOR<citiesCreateWithoutCountriesInput, citiesUncheckedCreateWithoutCountriesInput>
|
|
}
|
|
|
|
export type citiesUpdateWithWhereUniqueWithoutCountriesInput = {
|
|
where: citiesWhereUniqueInput
|
|
data: XOR<citiesUpdateWithoutCountriesInput, citiesUncheckedUpdateWithoutCountriesInput>
|
|
}
|
|
|
|
export type citiesUpdateManyWithWhereWithoutCountriesInput = {
|
|
where: citiesScalarWhereInput
|
|
data: XOR<citiesUpdateManyMutationInput, citiesUncheckedUpdateManyWithoutCountriesInput>
|
|
}
|
|
|
|
export type citiesScalarWhereInput = {
|
|
AND?: citiesScalarWhereInput | citiesScalarWhereInput[]
|
|
OR?: citiesScalarWhereInput[]
|
|
NOT?: citiesScalarWhereInput | citiesScalarWhereInput[]
|
|
id?: BigIntFilter<"cities"> | bigint | number
|
|
name?: StringFilter<"cities"> | string
|
|
state_id?: BigIntFilter<"cities"> | bigint | number
|
|
state_code?: StringFilter<"cities"> | string
|
|
country_id?: BigIntFilter<"cities"> | bigint | number
|
|
country_code?: StringFilter<"cities"> | string
|
|
type?: StringNullableFilter<"cities"> | string | null
|
|
level?: IntNullableFilter<"cities"> | number | null
|
|
parent_id?: BigIntNullableFilter<"cities"> | bigint | number | null
|
|
latitude?: DecimalFilter<"cities"> | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFilter<"cities"> | Decimal | DecimalJsLike | number | string
|
|
native?: StringNullableFilter<"cities"> | string | null
|
|
population?: BigIntNullableFilter<"cities"> | bigint | number | null
|
|
timezone?: StringNullableFilter<"cities"> | string | null
|
|
translations?: StringNullableFilter<"cities"> | string | null
|
|
created_at?: DateTimeFilter<"cities"> | Date | string
|
|
updated_at?: DateTimeFilter<"cities"> | Date | string
|
|
flag?: IntFilter<"cities"> | number
|
|
wikiDataId?: StringNullableFilter<"cities"> | string | null
|
|
}
|
|
|
|
export type statesUpsertWithWhereUniqueWithoutCountriesInput = {
|
|
where: statesWhereUniqueInput
|
|
update: XOR<statesUpdateWithoutCountriesInput, statesUncheckedUpdateWithoutCountriesInput>
|
|
create: XOR<statesCreateWithoutCountriesInput, statesUncheckedCreateWithoutCountriesInput>
|
|
}
|
|
|
|
export type statesUpdateWithWhereUniqueWithoutCountriesInput = {
|
|
where: statesWhereUniqueInput
|
|
data: XOR<statesUpdateWithoutCountriesInput, statesUncheckedUpdateWithoutCountriesInput>
|
|
}
|
|
|
|
export type statesUpdateManyWithWhereWithoutCountriesInput = {
|
|
where: statesScalarWhereInput
|
|
data: XOR<statesUpdateManyMutationInput, statesUncheckedUpdateManyWithoutCountriesInput>
|
|
}
|
|
|
|
export type statesScalarWhereInput = {
|
|
AND?: statesScalarWhereInput | statesScalarWhereInput[]
|
|
OR?: statesScalarWhereInput[]
|
|
NOT?: statesScalarWhereInput | statesScalarWhereInput[]
|
|
id?: BigIntFilter<"states"> | bigint | number
|
|
name?: StringFilter<"states"> | string
|
|
country_id?: BigIntFilter<"states"> | bigint | number
|
|
country_code?: StringFilter<"states"> | string
|
|
fips_code?: StringNullableFilter<"states"> | string | null
|
|
iso2?: StringNullableFilter<"states"> | string | null
|
|
iso3166_2?: StringNullableFilter<"states"> | string | null
|
|
type?: StringNullableFilter<"states"> | string | null
|
|
level?: IntNullableFilter<"states"> | number | null
|
|
parent_id?: BigIntNullableFilter<"states"> | bigint | number | null
|
|
native?: StringNullableFilter<"states"> | string | null
|
|
latitude?: DecimalNullableFilter<"states"> | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: DecimalNullableFilter<"states"> | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: StringNullableFilter<"states"> | string | null
|
|
translations?: StringNullableFilter<"states"> | string | null
|
|
created_at?: DateTimeNullableFilter<"states"> | Date | string | null
|
|
updated_at?: DateTimeFilter<"states"> | Date | string
|
|
flag?: IntFilter<"states"> | number
|
|
wikiDataId?: StringNullableFilter<"states"> | string | null
|
|
population?: StringNullableFilter<"states"> | string | null
|
|
}
|
|
|
|
export type citiesCreateWithoutStatesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
state_code: string
|
|
country_code: string
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
latitude: Decimal | DecimalJsLike | number | string
|
|
longitude: Decimal | DecimalJsLike | number | string
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
countries: countriesCreateNestedOneWithoutCitiesInput
|
|
}
|
|
|
|
export type citiesUncheckedCreateWithoutStatesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
state_code: string
|
|
country_id: bigint | number
|
|
country_code: string
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
latitude: Decimal | DecimalJsLike | number | string
|
|
longitude: Decimal | DecimalJsLike | number | string
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
}
|
|
|
|
export type citiesCreateOrConnectWithoutStatesInput = {
|
|
where: citiesWhereUniqueInput
|
|
create: XOR<citiesCreateWithoutStatesInput, citiesUncheckedCreateWithoutStatesInput>
|
|
}
|
|
|
|
export type citiesCreateManyStatesInputEnvelope = {
|
|
data: citiesCreateManyStatesInput | citiesCreateManyStatesInput[]
|
|
skipDuplicates?: boolean
|
|
}
|
|
|
|
export type countriesCreateWithoutStatesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
iso3?: string | null
|
|
numeric_code?: string | null
|
|
iso2?: string | null
|
|
phonecode?: string | null
|
|
capital?: string | null
|
|
currency?: string | null
|
|
currency_name?: string | null
|
|
currency_symbol?: string | null
|
|
tld?: string | null
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
gdp?: bigint | number | null
|
|
region?: string | null
|
|
region_id?: bigint | number | null
|
|
subregion?: string | null
|
|
subregion_id?: bigint | number | null
|
|
nationality?: string | null
|
|
area_sq_km?: number | null
|
|
postal_code_format?: string | null
|
|
postal_code_regex?: string | null
|
|
timezones?: string | null
|
|
translations?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
emoji?: string | null
|
|
emojiU?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
cities?: citiesCreateNestedManyWithoutCountriesInput
|
|
}
|
|
|
|
export type countriesUncheckedCreateWithoutStatesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
iso3?: string | null
|
|
numeric_code?: string | null
|
|
iso2?: string | null
|
|
phonecode?: string | null
|
|
capital?: string | null
|
|
currency?: string | null
|
|
currency_name?: string | null
|
|
currency_symbol?: string | null
|
|
tld?: string | null
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
gdp?: bigint | number | null
|
|
region?: string | null
|
|
region_id?: bigint | number | null
|
|
subregion?: string | null
|
|
subregion_id?: bigint | number | null
|
|
nationality?: string | null
|
|
area_sq_km?: number | null
|
|
postal_code_format?: string | null
|
|
postal_code_regex?: string | null
|
|
timezones?: string | null
|
|
translations?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
emoji?: string | null
|
|
emojiU?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
cities?: citiesUncheckedCreateNestedManyWithoutCountriesInput
|
|
}
|
|
|
|
export type countriesCreateOrConnectWithoutStatesInput = {
|
|
where: countriesWhereUniqueInput
|
|
create: XOR<countriesCreateWithoutStatesInput, countriesUncheckedCreateWithoutStatesInput>
|
|
}
|
|
|
|
export type citiesUpsertWithWhereUniqueWithoutStatesInput = {
|
|
where: citiesWhereUniqueInput
|
|
update: XOR<citiesUpdateWithoutStatesInput, citiesUncheckedUpdateWithoutStatesInput>
|
|
create: XOR<citiesCreateWithoutStatesInput, citiesUncheckedCreateWithoutStatesInput>
|
|
}
|
|
|
|
export type citiesUpdateWithWhereUniqueWithoutStatesInput = {
|
|
where: citiesWhereUniqueInput
|
|
data: XOR<citiesUpdateWithoutStatesInput, citiesUncheckedUpdateWithoutStatesInput>
|
|
}
|
|
|
|
export type citiesUpdateManyWithWhereWithoutStatesInput = {
|
|
where: citiesScalarWhereInput
|
|
data: XOR<citiesUpdateManyMutationInput, citiesUncheckedUpdateManyWithoutStatesInput>
|
|
}
|
|
|
|
export type countriesUpsertWithoutStatesInput = {
|
|
update: XOR<countriesUpdateWithoutStatesInput, countriesUncheckedUpdateWithoutStatesInput>
|
|
create: XOR<countriesCreateWithoutStatesInput, countriesUncheckedCreateWithoutStatesInput>
|
|
where?: countriesWhereInput
|
|
}
|
|
|
|
export type countriesUpdateToOneWithWhereWithoutStatesInput = {
|
|
where?: countriesWhereInput
|
|
data: XOR<countriesUpdateWithoutStatesInput, countriesUncheckedUpdateWithoutStatesInput>
|
|
}
|
|
|
|
export type countriesUpdateWithoutStatesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
iso3?: NullableStringFieldUpdateOperationsInput | string | null
|
|
numeric_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phonecode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
capital?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_symbol?: NullableStringFieldUpdateOperationsInput | string | null
|
|
tld?: NullableStringFieldUpdateOperationsInput | string | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
gdp?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
region?: NullableStringFieldUpdateOperationsInput | string | null
|
|
region_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
subregion?: NullableStringFieldUpdateOperationsInput | string | null
|
|
subregion_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
nationality?: NullableStringFieldUpdateOperationsInput | string | null
|
|
area_sq_km?: NullableFloatFieldUpdateOperationsInput | number | null
|
|
postal_code_format?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postal_code_regex?: NullableStringFieldUpdateOperationsInput | string | null
|
|
timezones?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emojiU?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cities?: citiesUpdateManyWithoutCountriesNestedInput
|
|
}
|
|
|
|
export type countriesUncheckedUpdateWithoutStatesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
iso3?: NullableStringFieldUpdateOperationsInput | string | null
|
|
numeric_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
phonecode?: NullableStringFieldUpdateOperationsInput | string | null
|
|
capital?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_name?: NullableStringFieldUpdateOperationsInput | string | null
|
|
currency_symbol?: NullableStringFieldUpdateOperationsInput | string | null
|
|
tld?: NullableStringFieldUpdateOperationsInput | string | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
gdp?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
region?: NullableStringFieldUpdateOperationsInput | string | null
|
|
region_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
subregion?: NullableStringFieldUpdateOperationsInput | string | null
|
|
subregion_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
nationality?: NullableStringFieldUpdateOperationsInput | string | null
|
|
area_sq_km?: NullableFloatFieldUpdateOperationsInput | number | null
|
|
postal_code_format?: NullableStringFieldUpdateOperationsInput | string | null
|
|
postal_code_regex?: NullableStringFieldUpdateOperationsInput | string | null
|
|
timezones?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
emoji?: NullableStringFieldUpdateOperationsInput | string | null
|
|
emojiU?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cities?: citiesUncheckedUpdateManyWithoutCountriesNestedInput
|
|
}
|
|
|
|
export type UnitCreateManyParentInput = {
|
|
id?: string
|
|
name: string
|
|
description?: string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: Date | string
|
|
updatedAt?: Date | string
|
|
}
|
|
|
|
export type UnitUpdateWithoutParentInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
children?: UnitUpdateManyWithoutParentNestedInput
|
|
}
|
|
|
|
export type UnitUncheckedUpdateWithoutParentInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
children?: UnitUncheckedUpdateManyWithoutParentNestedInput
|
|
}
|
|
|
|
export type UnitUncheckedUpdateManyWithoutParentInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
description?: NullableStringFieldUpdateOperationsInput | string | null
|
|
traits?: JsonNullValueInput | InputJsonValue
|
|
createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
}
|
|
|
|
export type GroupMembershipCreateManyPersonInput = {
|
|
id?: string
|
|
groupId: string
|
|
role: string
|
|
}
|
|
|
|
export type GroupMembershipUpdateWithoutPersonInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
role?: StringFieldUpdateOperationsInput | string
|
|
group?: GroupUpdateOneRequiredWithoutMembersNestedInput
|
|
}
|
|
|
|
export type GroupMembershipUncheckedUpdateWithoutPersonInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
groupId?: StringFieldUpdateOperationsInput | string
|
|
role?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type GroupMembershipUncheckedUpdateManyWithoutPersonInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
groupId?: StringFieldUpdateOperationsInput | string
|
|
role?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type GroupMembershipCreateManyGroupInput = {
|
|
id?: string
|
|
personId: string
|
|
role: string
|
|
}
|
|
|
|
export type GroupMembershipUpdateWithoutGroupInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
role?: StringFieldUpdateOperationsInput | string
|
|
person?: PersonUpdateOneRequiredWithoutGroupMembershipsNestedInput
|
|
}
|
|
|
|
export type GroupMembershipUncheckedUpdateWithoutGroupInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
personId?: StringFieldUpdateOperationsInput | string
|
|
role?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type GroupMembershipUncheckedUpdateManyWithoutGroupInput = {
|
|
id?: StringFieldUpdateOperationsInput | string
|
|
personId?: StringFieldUpdateOperationsInput | string
|
|
role?: StringFieldUpdateOperationsInput | string
|
|
}
|
|
|
|
export type citiesCreateManyCountriesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
state_id: bigint | number
|
|
state_code: string
|
|
country_code: string
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
latitude: Decimal | DecimalJsLike | number | string
|
|
longitude: Decimal | DecimalJsLike | number | string
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
}
|
|
|
|
export type statesCreateManyCountriesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
country_code: string
|
|
fips_code?: string | null
|
|
iso2?: string | null
|
|
iso3166_2?: string | null
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
native?: string | null
|
|
latitude?: Decimal | DecimalJsLike | number | string | null
|
|
longitude?: Decimal | DecimalJsLike | number | string | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string | null
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
population?: string | null
|
|
}
|
|
|
|
export type citiesUpdateWithoutCountriesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
state_code?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
latitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
states?: statesUpdateOneRequiredWithoutCitiesNestedInput
|
|
}
|
|
|
|
export type citiesUncheckedUpdateWithoutCountriesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
state_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
state_code?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
latitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type citiesUncheckedUpdateManyWithoutCountriesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
state_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
state_code?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
latitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type statesUpdateWithoutCountriesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
fips_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso3166_2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cities?: citiesUpdateManyWithoutStatesNestedInput
|
|
}
|
|
|
|
export type statesUncheckedUpdateWithoutCountriesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
fips_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso3166_2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableStringFieldUpdateOperationsInput | string | null
|
|
cities?: citiesUncheckedUpdateManyWithoutStatesNestedInput
|
|
}
|
|
|
|
export type statesUncheckedUpdateManyWithoutCountriesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
fips_code?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
iso3166_2?: NullableStringFieldUpdateOperationsInput | string | null
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
latitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
longitude?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type citiesCreateManyStatesInput = {
|
|
id?: bigint | number
|
|
name: string
|
|
state_code: string
|
|
country_id: bigint | number
|
|
country_code: string
|
|
type?: string | null
|
|
level?: number | null
|
|
parent_id?: bigint | number | null
|
|
latitude: Decimal | DecimalJsLike | number | string
|
|
longitude: Decimal | DecimalJsLike | number | string
|
|
native?: string | null
|
|
population?: bigint | number | null
|
|
timezone?: string | null
|
|
translations?: string | null
|
|
created_at?: Date | string
|
|
updated_at?: Date | string
|
|
flag?: number
|
|
wikiDataId?: string | null
|
|
}
|
|
|
|
export type citiesUpdateWithoutStatesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
state_code?: StringFieldUpdateOperationsInput | string
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
latitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
countries?: countriesUpdateOneRequiredWithoutCitiesNestedInput
|
|
}
|
|
|
|
export type citiesUncheckedUpdateWithoutStatesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
state_code?: StringFieldUpdateOperationsInput | string
|
|
country_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
latitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
export type citiesUncheckedUpdateManyWithoutStatesInput = {
|
|
id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
name?: StringFieldUpdateOperationsInput | string
|
|
state_code?: StringFieldUpdateOperationsInput | string
|
|
country_id?: BigIntFieldUpdateOperationsInput | bigint | number
|
|
country_code?: StringFieldUpdateOperationsInput | string
|
|
type?: NullableStringFieldUpdateOperationsInput | string | null
|
|
level?: NullableIntFieldUpdateOperationsInput | number | null
|
|
parent_id?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
latitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
longitude?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
|
|
native?: NullableStringFieldUpdateOperationsInput | string | null
|
|
population?: NullableBigIntFieldUpdateOperationsInput | bigint | number | null
|
|
timezone?: NullableStringFieldUpdateOperationsInput | string | null
|
|
translations?: NullableStringFieldUpdateOperationsInput | string | null
|
|
created_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
|
|
flag?: IntFieldUpdateOperationsInput | number
|
|
wikiDataId?: NullableStringFieldUpdateOperationsInput | string | null
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Batch Payload for updateMany & deleteMany & createMany
|
|
*/
|
|
|
|
export type BatchPayload = {
|
|
count: number
|
|
}
|
|
|
|
/**
|
|
* DMMF
|
|
*/
|
|
export const dmmf: runtime.BaseDMMF
|
|
} |